]> 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
reSWIGged
[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 /* for raw pointers */
989 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
990 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
991 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
992 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
993 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
994 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
995 #define swig_owntype int
996
997 /* for raw packed data */
998 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
999 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1000
1001 /* for class or struct pointers */
1002 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1003 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1004
1005 /* for C or C++ function pointers */
1006 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1007 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1008
1009 /* for C++ member pointers, ie, member methods */
1010 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1011 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1012
1013
1014 /* Runtime API */
1015
1016 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1017 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1018 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1019
1020 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1021 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1022 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1023 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1024 #define SWIG_fail goto fail
1025
1026
1027 /* Runtime API implementation */
1028
1029 /* Error manipulation */
1030
1031 SWIGINTERN void
1032 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1033 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1034 PyErr_SetObject(errtype, obj);
1035 Py_DECREF(obj);
1036 SWIG_PYTHON_THREAD_END_BLOCK;
1037 }
1038
1039 SWIGINTERN void
1040 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1041 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1042 PyErr_SetString(errtype, (char *) msg);
1043 SWIG_PYTHON_THREAD_END_BLOCK;
1044 }
1045
1046 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1047
1048 /* Set a constant value */
1049
1050 SWIGINTERN void
1051 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1052 PyDict_SetItemString(d, (char*) name, obj);
1053 Py_DECREF(obj);
1054 }
1055
1056 /* Append a value to the result obj */
1057
1058 SWIGINTERN PyObject*
1059 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1060 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1061 if (!result) {
1062 result = obj;
1063 } else if (result == Py_None) {
1064 Py_DECREF(result);
1065 result = obj;
1066 } else {
1067 if (!PyList_Check(result)) {
1068 PyObject *o2 = result;
1069 result = PyList_New(1);
1070 PyList_SetItem(result, 0, o2);
1071 }
1072 PyList_Append(result,obj);
1073 Py_DECREF(obj);
1074 }
1075 return result;
1076 #else
1077 PyObject* o2;
1078 PyObject* o3;
1079 if (!result) {
1080 result = obj;
1081 } else if (result == Py_None) {
1082 Py_DECREF(result);
1083 result = obj;
1084 } else {
1085 if (!PyTuple_Check(result)) {
1086 o2 = result;
1087 result = PyTuple_New(1);
1088 PyTuple_SET_ITEM(result, 0, o2);
1089 }
1090 o3 = PyTuple_New(1);
1091 PyTuple_SET_ITEM(o3, 0, obj);
1092 o2 = result;
1093 result = PySequence_Concat(o2, o3);
1094 Py_DECREF(o2);
1095 Py_DECREF(o3);
1096 }
1097 return result;
1098 #endif
1099 }
1100
1101 /* Unpack the argument tuple */
1102
1103 SWIGINTERN int
1104 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1105 {
1106 if (!args) {
1107 if (!min && !max) {
1108 return 1;
1109 } else {
1110 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1111 name, (min == max ? "" : "at least "), min);
1112 return 0;
1113 }
1114 }
1115 if (!PyTuple_Check(args)) {
1116 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1117 return 0;
1118 } else {
1119 register int l = PyTuple_GET_SIZE(args);
1120 if (l < min) {
1121 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1122 name, (min == max ? "" : "at least "), min, l);
1123 return 0;
1124 } else if (l > max) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at most "), max, l);
1127 return 0;
1128 } else {
1129 register int i;
1130 for (i = 0; i < l; ++i) {
1131 objs[i] = PyTuple_GET_ITEM(args, i);
1132 }
1133 for (; l < max; ++l) {
1134 objs[l] = 0;
1135 }
1136 return i + 1;
1137 }
1138 }
1139 }
1140
1141 /* A functor is a function object with one single object argument */
1142 #if PY_VERSION_HEX >= 0x02020000
1143 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1144 #else
1145 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1146 #endif
1147
1148 /*
1149 Helper for static pointer initialization for both C and C++ code, for example
1150 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1151 */
1152 #ifdef __cplusplus
1153 #define SWIG_STATIC_POINTER(var) var
1154 #else
1155 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1156 #endif
1157
1158 /* -----------------------------------------------------------------------------
1159 * Pointer declarations
1160 * ----------------------------------------------------------------------------- */
1161
1162 /* Flags for new pointer objects */
1163 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1164 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1165
1166 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1167
1168 #ifdef __cplusplus
1169 extern "C" {
1170 #if 0
1171 } /* cc-mode */
1172 #endif
1173 #endif
1174
1175 /* How to access Py_None */
1176 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1177 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1178 # ifndef SWIG_PYTHON_BUILD_NONE
1179 # define SWIG_PYTHON_BUILD_NONE
1180 # endif
1181 # endif
1182 #endif
1183
1184 #ifdef SWIG_PYTHON_BUILD_NONE
1185 # ifdef Py_None
1186 # undef Py_None
1187 # define Py_None SWIG_Py_None()
1188 # endif
1189 SWIGRUNTIMEINLINE PyObject *
1190 _SWIG_Py_None(void)
1191 {
1192 PyObject *none = Py_BuildValue("");
1193 Py_DECREF(none);
1194 return none;
1195 }
1196 SWIGRUNTIME PyObject *
1197 SWIG_Py_None(void)
1198 {
1199 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1200 return none;
1201 }
1202 #endif
1203
1204 /* The python void return value */
1205
1206 SWIGRUNTIMEINLINE PyObject *
1207 SWIG_Py_Void(void)
1208 {
1209 PyObject *none = Py_None;
1210 Py_INCREF(none);
1211 return none;
1212 }
1213
1214 /* PySwigClientData */
1215
1216 typedef struct {
1217 PyObject *klass;
1218 PyObject *newraw;
1219 PyObject *newargs;
1220 PyObject *destroy;
1221 int delargs;
1222 int implicitconv;
1223 } PySwigClientData;
1224
1225 SWIGRUNTIMEINLINE int
1226 SWIG_Python_CheckImplicit(swig_type_info *ty)
1227 {
1228 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1229 return data ? data->implicitconv : 0;
1230 }
1231
1232 SWIGRUNTIMEINLINE PyObject *
1233 SWIG_Python_ExceptionType(swig_type_info *desc) {
1234 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1235 PyObject *klass = data ? data->klass : 0;
1236 return (klass ? klass : PyExc_RuntimeError);
1237 }
1238
1239
1240 SWIGRUNTIME PySwigClientData *
1241 PySwigClientData_New(PyObject* obj)
1242 {
1243 if (!obj) {
1244 return 0;
1245 } else {
1246 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1247 /* the klass element */
1248 data->klass = obj;
1249 Py_INCREF(data->klass);
1250 /* the newraw method and newargs arguments used to create a new raw instance */
1251 if (PyClass_Check(obj)) {
1252 data->newraw = 0;
1253 data->newargs = obj;
1254 Py_INCREF(obj);
1255 } else {
1256 #if (PY_VERSION_HEX < 0x02020000)
1257 data->newraw = 0;
1258 #else
1259 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1260 #endif
1261 if (data->newraw) {
1262 Py_INCREF(data->newraw);
1263 data->newargs = PyTuple_New(1);
1264 PyTuple_SetItem(data->newargs, 0, obj);
1265 } else {
1266 data->newargs = obj;
1267 }
1268 Py_INCREF(data->newargs);
1269 }
1270 /* the destroy method, aka as the C++ delete method */
1271 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1272 if (PyErr_Occurred()) {
1273 PyErr_Clear();
1274 data->destroy = 0;
1275 }
1276 if (data->destroy) {
1277 int flags;
1278 Py_INCREF(data->destroy);
1279 flags = PyCFunction_GET_FLAGS(data->destroy);
1280 #ifdef METH_O
1281 data->delargs = !(flags & (METH_O));
1282 #else
1283 data->delargs = 0;
1284 #endif
1285 } else {
1286 data->delargs = 0;
1287 }
1288 data->implicitconv = 0;
1289 return data;
1290 }
1291 }
1292
1293 SWIGRUNTIME void
1294 PySwigClientData_Del(PySwigClientData* data)
1295 {
1296 Py_XDECREF(data->newraw);
1297 Py_XDECREF(data->newargs);
1298 Py_XDECREF(data->destroy);
1299 }
1300
1301 /* =============== PySwigObject =====================*/
1302
1303 typedef struct {
1304 PyObject_HEAD
1305 void *ptr;
1306 swig_type_info *ty;
1307 int own;
1308 PyObject *next;
1309 } PySwigObject;
1310
1311 SWIGRUNTIME PyObject *
1312 PySwigObject_long(PySwigObject *v)
1313 {
1314 return PyLong_FromVoidPtr(v->ptr);
1315 }
1316
1317 SWIGRUNTIME PyObject *
1318 PySwigObject_format(const char* fmt, PySwigObject *v)
1319 {
1320 PyObject *res = NULL;
1321 PyObject *args = PyTuple_New(1);
1322 if (args) {
1323 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1324 PyObject *ofmt = PyString_FromString(fmt);
1325 if (ofmt) {
1326 res = PyString_Format(ofmt,args);
1327 Py_DECREF(ofmt);
1328 }
1329 Py_DECREF(args);
1330 }
1331 }
1332 return res;
1333 }
1334
1335 SWIGRUNTIME PyObject *
1336 PySwigObject_oct(PySwigObject *v)
1337 {
1338 return PySwigObject_format("%o",v);
1339 }
1340
1341 SWIGRUNTIME PyObject *
1342 PySwigObject_hex(PySwigObject *v)
1343 {
1344 return PySwigObject_format("%x",v);
1345 }
1346
1347 SWIGRUNTIME PyObject *
1348 #ifdef METH_NOARGS
1349 PySwigObject_repr(PySwigObject *v)
1350 #else
1351 PySwigObject_repr(PySwigObject *v, PyObject *args)
1352 #endif
1353 {
1354 const char *name = SWIG_TypePrettyName(v->ty);
1355 PyObject *hex = PySwigObject_hex(v);
1356 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1357 Py_DECREF(hex);
1358 if (v->next) {
1359 #ifdef METH_NOARGS
1360 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1361 #else
1362 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1363 #endif
1364 PyString_ConcatAndDel(&repr,nrep);
1365 }
1366 return repr;
1367 }
1368
1369 SWIGRUNTIME int
1370 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1371 {
1372 #ifdef METH_NOARGS
1373 PyObject *repr = PySwigObject_repr(v);
1374 #else
1375 PyObject *repr = PySwigObject_repr(v, NULL);
1376 #endif
1377 if (repr) {
1378 fputs(PyString_AsString(repr), fp);
1379 Py_DECREF(repr);
1380 return 0;
1381 } else {
1382 return 1;
1383 }
1384 }
1385
1386 SWIGRUNTIME PyObject *
1387 PySwigObject_str(PySwigObject *v)
1388 {
1389 char result[SWIG_BUFFER_SIZE];
1390 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1391 PyString_FromString(result) : 0;
1392 }
1393
1394 SWIGRUNTIME int
1395 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1396 {
1397 void *i = v->ptr;
1398 void *j = w->ptr;
1399 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1400 }
1401
1402 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1403
1404 SWIGRUNTIME PyTypeObject*
1405 PySwigObject_type(void) {
1406 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1407 return type;
1408 }
1409
1410 SWIGRUNTIMEINLINE int
1411 PySwigObject_Check(PyObject *op) {
1412 return ((op)->ob_type == PySwigObject_type())
1413 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1414 }
1415
1416 SWIGRUNTIME PyObject *
1417 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1418
1419 SWIGRUNTIME void
1420 PySwigObject_dealloc(PyObject *v)
1421 {
1422 PySwigObject *sobj = (PySwigObject *) v;
1423 PyObject *next = sobj->next;
1424 if (sobj->own) {
1425 swig_type_info *ty = sobj->ty;
1426 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1427 PyObject *destroy = data ? data->destroy : 0;
1428 if (destroy) {
1429 /* destroy is always a VARARGS method */
1430 PyObject *res;
1431 if (data->delargs) {
1432 /* we need to create a temporal object to carry the destroy operation */
1433 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1434 res = SWIG_Python_CallFunctor(destroy, tmp);
1435 Py_DECREF(tmp);
1436 } else {
1437 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1438 PyObject *mself = PyCFunction_GET_SELF(destroy);
1439 res = ((*meth)(mself, v));
1440 }
1441 Py_XDECREF(res);
1442 } else {
1443 const char *name = SWIG_TypePrettyName(ty);
1444 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1445 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1446 #endif
1447 }
1448 }
1449 Py_XDECREF(next);
1450 PyObject_DEL(v);
1451 }
1452
1453 SWIGRUNTIME PyObject*
1454 PySwigObject_append(PyObject* v, PyObject* next)
1455 {
1456 PySwigObject *sobj = (PySwigObject *) v;
1457 #ifndef METH_O
1458 PyObject *tmp = 0;
1459 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1460 next = tmp;
1461 #endif
1462 if (!PySwigObject_Check(next)) {
1463 return NULL;
1464 }
1465 sobj->next = next;
1466 Py_INCREF(next);
1467 return SWIG_Py_Void();
1468 }
1469
1470 SWIGRUNTIME PyObject*
1471 #ifdef METH_NOARGS
1472 PySwigObject_next(PyObject* v)
1473 #else
1474 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1475 #endif
1476 {
1477 PySwigObject *sobj = (PySwigObject *) v;
1478 if (sobj->next) {
1479 Py_INCREF(sobj->next);
1480 return sobj->next;
1481 } else {
1482 return SWIG_Py_Void();
1483 }
1484 }
1485
1486 SWIGINTERN PyObject*
1487 #ifdef METH_NOARGS
1488 PySwigObject_disown(PyObject *v)
1489 #else
1490 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1491 #endif
1492 {
1493 PySwigObject *sobj = (PySwigObject *)v;
1494 sobj->own = 0;
1495 return SWIG_Py_Void();
1496 }
1497
1498 SWIGINTERN PyObject*
1499 #ifdef METH_NOARGS
1500 PySwigObject_acquire(PyObject *v)
1501 #else
1502 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1503 #endif
1504 {
1505 PySwigObject *sobj = (PySwigObject *)v;
1506 sobj->own = SWIG_POINTER_OWN;
1507 return SWIG_Py_Void();
1508 }
1509
1510 SWIGINTERN PyObject*
1511 PySwigObject_own(PyObject *v, PyObject *args)
1512 {
1513 PyObject *val = 0;
1514 #if (PY_VERSION_HEX < 0x02020000)
1515 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1516 #else
1517 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1518 #endif
1519 {
1520 return NULL;
1521 }
1522 else
1523 {
1524 PySwigObject *sobj = (PySwigObject *)v;
1525 PyObject *obj = PyBool_FromLong(sobj->own);
1526 if (val) {
1527 #ifdef METH_NOARGS
1528 if (PyObject_IsTrue(val)) {
1529 PySwigObject_acquire(v);
1530 } else {
1531 PySwigObject_disown(v);
1532 }
1533 #else
1534 if (PyObject_IsTrue(val)) {
1535 PySwigObject_acquire(v,args);
1536 } else {
1537 PySwigObject_disown(v,args);
1538 }
1539 #endif
1540 }
1541 return obj;
1542 }
1543 }
1544
1545 #ifdef METH_O
1546 static PyMethodDef
1547 swigobject_methods[] = {
1548 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1549 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1550 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1551 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1552 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1553 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1554 {0, 0, 0, 0}
1555 };
1556 #else
1557 static PyMethodDef
1558 swigobject_methods[] = {
1559 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1560 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1561 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1562 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1563 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1564 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1565 {0, 0, 0, 0}
1566 };
1567 #endif
1568
1569 #if PY_VERSION_HEX < 0x02020000
1570 SWIGINTERN PyObject *
1571 PySwigObject_getattr(PySwigObject *sobj,char *name)
1572 {
1573 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1574 }
1575 #endif
1576
1577 SWIGRUNTIME PyTypeObject*
1578 _PySwigObject_type(void) {
1579 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1580
1581 static PyNumberMethods PySwigObject_as_number = {
1582 (binaryfunc)0, /*nb_add*/
1583 (binaryfunc)0, /*nb_subtract*/
1584 (binaryfunc)0, /*nb_multiply*/
1585 (binaryfunc)0, /*nb_divide*/
1586 (binaryfunc)0, /*nb_remainder*/
1587 (binaryfunc)0, /*nb_divmod*/
1588 (ternaryfunc)0,/*nb_power*/
1589 (unaryfunc)0, /*nb_negative*/
1590 (unaryfunc)0, /*nb_positive*/
1591 (unaryfunc)0, /*nb_absolute*/
1592 (inquiry)0, /*nb_nonzero*/
1593 0, /*nb_invert*/
1594 0, /*nb_lshift*/
1595 0, /*nb_rshift*/
1596 0, /*nb_and*/
1597 0, /*nb_xor*/
1598 0, /*nb_or*/
1599 (coercion)0, /*nb_coerce*/
1600 (unaryfunc)PySwigObject_long, /*nb_int*/
1601 (unaryfunc)PySwigObject_long, /*nb_long*/
1602 (unaryfunc)0, /*nb_float*/
1603 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1604 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1605 #if PY_VERSION_HEX >= 0x02020000
1606 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1607 #elif PY_VERSION_HEX >= 0x02000000
1608 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1609 #endif
1610 };
1611
1612 static PyTypeObject pyswigobject_type;
1613 static int type_init = 0;
1614 if (!type_init) {
1615 const PyTypeObject tmp
1616 = {
1617 PyObject_HEAD_INIT(NULL)
1618 0, /* ob_size */
1619 (char *)"PySwigObject", /* tp_name */
1620 sizeof(PySwigObject), /* tp_basicsize */
1621 0, /* tp_itemsize */
1622 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1623 (printfunc)PySwigObject_print, /* tp_print */
1624 #if PY_VERSION_HEX < 0x02020000
1625 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1626 #else
1627 (getattrfunc)0, /* tp_getattr */
1628 #endif
1629 (setattrfunc)0, /* tp_setattr */
1630 (cmpfunc)PySwigObject_compare, /* tp_compare */
1631 (reprfunc)PySwigObject_repr, /* tp_repr */
1632 &PySwigObject_as_number, /* tp_as_number */
1633 0, /* tp_as_sequence */
1634 0, /* tp_as_mapping */
1635 (hashfunc)0, /* tp_hash */
1636 (ternaryfunc)0, /* tp_call */
1637 (reprfunc)PySwigObject_str, /* tp_str */
1638 PyObject_GenericGetAttr, /* tp_getattro */
1639 0, /* tp_setattro */
1640 0, /* tp_as_buffer */
1641 Py_TPFLAGS_DEFAULT, /* tp_flags */
1642 swigobject_doc, /* tp_doc */
1643 0, /* tp_traverse */
1644 0, /* tp_clear */
1645 0, /* tp_richcompare */
1646 0, /* tp_weaklistoffset */
1647 #if PY_VERSION_HEX >= 0x02020000
1648 0, /* tp_iter */
1649 0, /* tp_iternext */
1650 swigobject_methods, /* tp_methods */
1651 0, /* tp_members */
1652 0, /* tp_getset */
1653 0, /* tp_base */
1654 0, /* tp_dict */
1655 0, /* tp_descr_get */
1656 0, /* tp_descr_set */
1657 0, /* tp_dictoffset */
1658 0, /* tp_init */
1659 0, /* tp_alloc */
1660 0, /* tp_new */
1661 0, /* tp_free */
1662 0, /* tp_is_gc */
1663 0, /* tp_bases */
1664 0, /* tp_mro */
1665 0, /* tp_cache */
1666 0, /* tp_subclasses */
1667 0, /* tp_weaklist */
1668 #endif
1669 #if PY_VERSION_HEX >= 0x02030000
1670 0, /* tp_del */
1671 #endif
1672 #ifdef COUNT_ALLOCS
1673 0,0,0,0 /* tp_alloc -> tp_next */
1674 #endif
1675 };
1676 pyswigobject_type = tmp;
1677 pyswigobject_type.ob_type = &PyType_Type;
1678 type_init = 1;
1679 }
1680 return &pyswigobject_type;
1681 }
1682
1683 SWIGRUNTIME PyObject *
1684 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1685 {
1686 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1687 if (sobj) {
1688 sobj->ptr = ptr;
1689 sobj->ty = ty;
1690 sobj->own = own;
1691 sobj->next = 0;
1692 }
1693 return (PyObject *)sobj;
1694 }
1695
1696 /* -----------------------------------------------------------------------------
1697 * Implements a simple Swig Packed type, and use it instead of string
1698 * ----------------------------------------------------------------------------- */
1699
1700 typedef struct {
1701 PyObject_HEAD
1702 void *pack;
1703 swig_type_info *ty;
1704 size_t size;
1705 } PySwigPacked;
1706
1707 SWIGRUNTIME int
1708 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1709 {
1710 char result[SWIG_BUFFER_SIZE];
1711 fputs("<Swig Packed ", fp);
1712 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1713 fputs("at ", fp);
1714 fputs(result, fp);
1715 }
1716 fputs(v->ty->name,fp);
1717 fputs(">", fp);
1718 return 0;
1719 }
1720
1721 SWIGRUNTIME PyObject *
1722 PySwigPacked_repr(PySwigPacked *v)
1723 {
1724 char result[SWIG_BUFFER_SIZE];
1725 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1726 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1727 } else {
1728 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1729 }
1730 }
1731
1732 SWIGRUNTIME PyObject *
1733 PySwigPacked_str(PySwigPacked *v)
1734 {
1735 char result[SWIG_BUFFER_SIZE];
1736 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1737 return PyString_FromFormat("%s%s", result, v->ty->name);
1738 } else {
1739 return PyString_FromString(v->ty->name);
1740 }
1741 }
1742
1743 SWIGRUNTIME int
1744 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1745 {
1746 size_t i = v->size;
1747 size_t j = w->size;
1748 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1749 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1750 }
1751
1752 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1753
1754 SWIGRUNTIME PyTypeObject*
1755 PySwigPacked_type(void) {
1756 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1757 return type;
1758 }
1759
1760 SWIGRUNTIMEINLINE int
1761 PySwigPacked_Check(PyObject *op) {
1762 return ((op)->ob_type == _PySwigPacked_type())
1763 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1764 }
1765
1766 SWIGRUNTIME void
1767 PySwigPacked_dealloc(PyObject *v)
1768 {
1769 if (PySwigPacked_Check(v)) {
1770 PySwigPacked *sobj = (PySwigPacked *) v;
1771 free(sobj->pack);
1772 }
1773 PyObject_DEL(v);
1774 }
1775
1776 SWIGRUNTIME PyTypeObject*
1777 _PySwigPacked_type(void) {
1778 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1779 static PyTypeObject pyswigpacked_type;
1780 static int type_init = 0;
1781 if (!type_init) {
1782 const PyTypeObject tmp
1783 = {
1784 PyObject_HEAD_INIT(NULL)
1785 0, /* ob_size */
1786 (char *)"PySwigPacked", /* tp_name */
1787 sizeof(PySwigPacked), /* tp_basicsize */
1788 0, /* tp_itemsize */
1789 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1790 (printfunc)PySwigPacked_print, /* tp_print */
1791 (getattrfunc)0, /* tp_getattr */
1792 (setattrfunc)0, /* tp_setattr */
1793 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1794 (reprfunc)PySwigPacked_repr, /* tp_repr */
1795 0, /* tp_as_number */
1796 0, /* tp_as_sequence */
1797 0, /* tp_as_mapping */
1798 (hashfunc)0, /* tp_hash */
1799 (ternaryfunc)0, /* tp_call */
1800 (reprfunc)PySwigPacked_str, /* tp_str */
1801 PyObject_GenericGetAttr, /* tp_getattro */
1802 0, /* tp_setattro */
1803 0, /* tp_as_buffer */
1804 Py_TPFLAGS_DEFAULT, /* tp_flags */
1805 swigpacked_doc, /* tp_doc */
1806 0, /* tp_traverse */
1807 0, /* tp_clear */
1808 0, /* tp_richcompare */
1809 0, /* tp_weaklistoffset */
1810 #if PY_VERSION_HEX >= 0x02020000
1811 0, /* tp_iter */
1812 0, /* tp_iternext */
1813 0, /* tp_methods */
1814 0, /* tp_members */
1815 0, /* tp_getset */
1816 0, /* tp_base */
1817 0, /* tp_dict */
1818 0, /* tp_descr_get */
1819 0, /* tp_descr_set */
1820 0, /* tp_dictoffset */
1821 0, /* tp_init */
1822 0, /* tp_alloc */
1823 0, /* tp_new */
1824 0, /* tp_free */
1825 0, /* tp_is_gc */
1826 0, /* tp_bases */
1827 0, /* tp_mro */
1828 0, /* tp_cache */
1829 0, /* tp_subclasses */
1830 0, /* tp_weaklist */
1831 #endif
1832 #if PY_VERSION_HEX >= 0x02030000
1833 0, /* tp_del */
1834 #endif
1835 #ifdef COUNT_ALLOCS
1836 0,0,0,0 /* tp_alloc -> tp_next */
1837 #endif
1838 };
1839 pyswigpacked_type = tmp;
1840 pyswigpacked_type.ob_type = &PyType_Type;
1841 type_init = 1;
1842 }
1843 return &pyswigpacked_type;
1844 }
1845
1846 SWIGRUNTIME PyObject *
1847 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1848 {
1849 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1850 if (sobj) {
1851 void *pack = malloc(size);
1852 if (pack) {
1853 memcpy(pack, ptr, size);
1854 sobj->pack = pack;
1855 sobj->ty = ty;
1856 sobj->size = size;
1857 } else {
1858 PyObject_DEL((PyObject *) sobj);
1859 sobj = 0;
1860 }
1861 }
1862 return (PyObject *) sobj;
1863 }
1864
1865 SWIGRUNTIME swig_type_info *
1866 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1867 {
1868 if (PySwigPacked_Check(obj)) {
1869 PySwigPacked *sobj = (PySwigPacked *)obj;
1870 if (sobj->size != size) return 0;
1871 memcpy(ptr, sobj->pack, size);
1872 return sobj->ty;
1873 } else {
1874 return 0;
1875 }
1876 }
1877
1878 /* -----------------------------------------------------------------------------
1879 * pointers/data manipulation
1880 * ----------------------------------------------------------------------------- */
1881
1882 SWIGRUNTIMEINLINE PyObject *
1883 _SWIG_This(void)
1884 {
1885 return PyString_FromString("this");
1886 }
1887
1888 SWIGRUNTIME PyObject *
1889 SWIG_This(void)
1890 {
1891 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1892 return swig_this;
1893 }
1894
1895 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1896
1897 SWIGRUNTIME PySwigObject *
1898 SWIG_Python_GetSwigThis(PyObject *pyobj)
1899 {
1900 if (PySwigObject_Check(pyobj)) {
1901 return (PySwigObject *) pyobj;
1902 } else {
1903 PyObject *obj = 0;
1904 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1905 if (PyInstance_Check(pyobj)) {
1906 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1907 } else {
1908 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1909 if (dictptr != NULL) {
1910 PyObject *dict = *dictptr;
1911 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1912 } else {
1913 #ifdef PyWeakref_CheckProxy
1914 if (PyWeakref_CheckProxy(pyobj)) {
1915 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1916 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1917 }
1918 #endif
1919 obj = PyObject_GetAttr(pyobj,SWIG_This());
1920 if (obj) {
1921 Py_DECREF(obj);
1922 } else {
1923 if (PyErr_Occurred()) PyErr_Clear();
1924 return 0;
1925 }
1926 }
1927 }
1928 #else
1929 obj = PyObject_GetAttr(pyobj,SWIG_This());
1930 if (obj) {
1931 Py_DECREF(obj);
1932 } else {
1933 if (PyErr_Occurred()) PyErr_Clear();
1934 return 0;
1935 }
1936 #endif
1937 if (obj && !PySwigObject_Check(obj)) {
1938 /* a PyObject is called 'this', try to get the 'real this'
1939 PySwigObject from it */
1940 return SWIG_Python_GetSwigThis(obj);
1941 }
1942 return (PySwigObject *)obj;
1943 }
1944 }
1945
1946 /* Acquire a pointer value */
1947
1948 SWIGRUNTIME int
1949 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1950 if (own) {
1951 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1952 if (sobj) {
1953 int oldown = sobj->own;
1954 sobj->own = own;
1955 return oldown;
1956 }
1957 }
1958 return 0;
1959 }
1960
1961 /* Convert a pointer value */
1962
1963 SWIGRUNTIME int
1964 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1965 if (!obj) return SWIG_ERROR;
1966 if (obj == Py_None) {
1967 if (ptr) *ptr = 0;
1968 return SWIG_OK;
1969 } else {
1970 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1971 while (sobj) {
1972 void *vptr = sobj->ptr;
1973 if (ty) {
1974 swig_type_info *to = sobj->ty;
1975 if (to == ty) {
1976 /* no type cast needed */
1977 if (ptr) *ptr = vptr;
1978 break;
1979 } else {
1980 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1981 if (!tc) {
1982 sobj = (PySwigObject *)sobj->next;
1983 } else {
1984 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1985 break;
1986 }
1987 }
1988 } else {
1989 if (ptr) *ptr = vptr;
1990 break;
1991 }
1992 }
1993 if (sobj) {
1994 if (own) *own = sobj->own;
1995 if (flags & SWIG_POINTER_DISOWN) {
1996 sobj->own = 0;
1997 }
1998 return SWIG_OK;
1999 } else {
2000 int res = SWIG_ERROR;
2001 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2002 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2003 if (data && !data->implicitconv) {
2004 PyObject *klass = data->klass;
2005 if (klass) {
2006 PyObject *impconv;
2007 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2008 impconv = SWIG_Python_CallFunctor(klass, obj);
2009 data->implicitconv = 0;
2010 if (PyErr_Occurred()) {
2011 PyErr_Clear();
2012 impconv = 0;
2013 }
2014 if (impconv) {
2015 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2016 if (iobj) {
2017 void *vptr;
2018 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2019 if (SWIG_IsOK(res)) {
2020 if (ptr) {
2021 *ptr = vptr;
2022 /* transfer the ownership to 'ptr' */
2023 iobj->own = 0;
2024 res = SWIG_AddCast(res);
2025 res = SWIG_AddNewMask(res);
2026 } else {
2027 res = SWIG_AddCast(res);
2028 }
2029 }
2030 }
2031 Py_DECREF(impconv);
2032 }
2033 }
2034 }
2035 }
2036 return res;
2037 }
2038 }
2039 }
2040
2041 /* Convert a function ptr value */
2042
2043 SWIGRUNTIME int
2044 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2045 if (!PyCFunction_Check(obj)) {
2046 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2047 } else {
2048 void *vptr = 0;
2049
2050 /* here we get the method pointer for callbacks */
2051 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2052 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2053 if (desc) {
2054 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2055 if (!desc) return SWIG_ERROR;
2056 }
2057 if (ty) {
2058 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2059 if (!tc) return SWIG_ERROR;
2060 *ptr = SWIG_TypeCast(tc,vptr);
2061 } else {
2062 *ptr = vptr;
2063 }
2064 return SWIG_OK;
2065 }
2066 }
2067
2068 /* Convert a packed value value */
2069
2070 SWIGRUNTIME int
2071 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2072 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2073 if (!to) return SWIG_ERROR;
2074 if (ty) {
2075 if (to != ty) {
2076 /* check type cast? */
2077 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2078 if (!tc) return SWIG_ERROR;
2079 }
2080 }
2081 return SWIG_OK;
2082 }
2083
2084 /* -----------------------------------------------------------------------------
2085 * Create a new pointer object
2086 * ----------------------------------------------------------------------------- */
2087
2088 /*
2089 Create a new instance object, whitout calling __init__, and set the
2090 'this' attribute.
2091 */
2092
2093 SWIGRUNTIME PyObject*
2094 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2095 {
2096 #if (PY_VERSION_HEX >= 0x02020000)
2097 PyObject *inst = 0;
2098 PyObject *newraw = data->newraw;
2099 if (newraw) {
2100 inst = PyObject_Call(newraw, data->newargs, NULL);
2101 if (inst) {
2102 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2103 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2104 if (dictptr != NULL) {
2105 PyObject *dict = *dictptr;
2106 if (dict == NULL) {
2107 dict = PyDict_New();
2108 *dictptr = dict;
2109 PyDict_SetItem(dict, SWIG_This(), swig_this);
2110 }
2111 }
2112 #else
2113 PyObject *key = SWIG_This();
2114 PyObject_SetAttr(inst, key, swig_this);
2115 #endif
2116 }
2117 } else {
2118 PyObject *dict = PyDict_New();
2119 PyDict_SetItem(dict, SWIG_This(), swig_this);
2120 inst = PyInstance_NewRaw(data->newargs, dict);
2121 Py_DECREF(dict);
2122 }
2123 return inst;
2124 #else
2125 #if (PY_VERSION_HEX >= 0x02010000)
2126 PyObject *inst;
2127 PyObject *dict = PyDict_New();
2128 PyDict_SetItem(dict, SWIG_This(), swig_this);
2129 inst = PyInstance_NewRaw(data->newargs, dict);
2130 Py_DECREF(dict);
2131 return (PyObject *) inst;
2132 #else
2133 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2134 if (inst == NULL) {
2135 return NULL;
2136 }
2137 inst->in_class = (PyClassObject *)data->newargs;
2138 Py_INCREF(inst->in_class);
2139 inst->in_dict = PyDict_New();
2140 if (inst->in_dict == NULL) {
2141 Py_DECREF(inst);
2142 return NULL;
2143 }
2144 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2145 inst->in_weakreflist = NULL;
2146 #endif
2147 #ifdef Py_TPFLAGS_GC
2148 PyObject_GC_Init(inst);
2149 #endif
2150 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2151 return (PyObject *) inst;
2152 #endif
2153 #endif
2154 }
2155
2156 SWIGRUNTIME void
2157 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2158 {
2159 PyObject *dict;
2160 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2161 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2162 if (dictptr != NULL) {
2163 dict = *dictptr;
2164 if (dict == NULL) {
2165 dict = PyDict_New();
2166 *dictptr = dict;
2167 }
2168 PyDict_SetItem(dict, SWIG_This(), swig_this);
2169 return;
2170 }
2171 #endif
2172 dict = PyObject_GetAttrString(inst, "__dict__");
2173 PyDict_SetItem(dict, SWIG_This(), swig_this);
2174 Py_DECREF(dict);
2175 }
2176
2177
2178 SWIGINTERN PyObject *
2179 SWIG_Python_InitShadowInstance(PyObject *args) {
2180 PyObject *obj[2];
2181 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2182 return NULL;
2183 } else {
2184 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2185 if (sthis) {
2186 PySwigObject_append((PyObject*) sthis, obj[1]);
2187 } else {
2188 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2189 }
2190 return SWIG_Py_Void();
2191 }
2192 }
2193
2194 /* Create a new pointer object */
2195
2196 SWIGRUNTIME PyObject *
2197 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2198 if (!ptr) {
2199 return SWIG_Py_Void();
2200 } else {
2201 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2202 PyObject *robj = PySwigObject_New(ptr, type, own);
2203 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2204 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2205 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2206 if (inst) {
2207 Py_DECREF(robj);
2208 robj = inst;
2209 }
2210 }
2211 return robj;
2212 }
2213 }
2214
2215 /* Create a new packed object */
2216
2217 SWIGRUNTIMEINLINE PyObject *
2218 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2219 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2220 }
2221
2222 /* -----------------------------------------------------------------------------*
2223 * Get type list
2224 * -----------------------------------------------------------------------------*/
2225
2226 #ifdef SWIG_LINK_RUNTIME
2227 void *SWIG_ReturnGlobalTypeList(void *);
2228 #endif
2229
2230 SWIGRUNTIME swig_module_info *
2231 SWIG_Python_GetModule(void) {
2232 static void *type_pointer = (void *)0;
2233 /* first check if module already created */
2234 if (!type_pointer) {
2235 #ifdef SWIG_LINK_RUNTIME
2236 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2237 #else
2238 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2239 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2240 if (PyErr_Occurred()) {
2241 PyErr_Clear();
2242 type_pointer = (void *)0;
2243 }
2244 #endif
2245 }
2246 return (swig_module_info *) type_pointer;
2247 }
2248
2249 #if PY_MAJOR_VERSION < 2
2250 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2251 is copied out of Python/modsupport.c in python version 2.3.4 */
2252 SWIGINTERN int
2253 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2254 {
2255 PyObject *dict;
2256 if (!PyModule_Check(m)) {
2257 PyErr_SetString(PyExc_TypeError,
2258 "PyModule_AddObject() needs module as first arg");
2259 return SWIG_ERROR;
2260 }
2261 if (!o) {
2262 PyErr_SetString(PyExc_TypeError,
2263 "PyModule_AddObject() needs non-NULL value");
2264 return SWIG_ERROR;
2265 }
2266
2267 dict = PyModule_GetDict(m);
2268 if (dict == NULL) {
2269 /* Internal error -- modules must have a dict! */
2270 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2271 PyModule_GetName(m));
2272 return SWIG_ERROR;
2273 }
2274 if (PyDict_SetItemString(dict, name, o))
2275 return SWIG_ERROR;
2276 Py_DECREF(o);
2277 return SWIG_OK;
2278 }
2279 #endif
2280
2281 SWIGRUNTIME void
2282 SWIG_Python_DestroyModule(void *vptr)
2283 {
2284 swig_module_info *swig_module = (swig_module_info *) vptr;
2285 swig_type_info **types = swig_module->types;
2286 size_t i;
2287 for (i =0; i < swig_module->size; ++i) {
2288 swig_type_info *ty = types[i];
2289 if (ty->owndata) {
2290 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2291 if (data) PySwigClientData_Del(data);
2292 }
2293 }
2294 Py_DECREF(SWIG_This());
2295 }
2296
2297 SWIGRUNTIME void
2298 SWIG_Python_SetModule(swig_module_info *swig_module) {
2299 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2300
2301 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2302 swig_empty_runtime_method_table);
2303 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2304 if (pointer && module) {
2305 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2306 } else {
2307 Py_XDECREF(pointer);
2308 }
2309 }
2310
2311 /* The python cached type query */
2312 SWIGRUNTIME PyObject *
2313 SWIG_Python_TypeCache() {
2314 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2315 return cache;
2316 }
2317
2318 SWIGRUNTIME swig_type_info *
2319 SWIG_Python_TypeQuery(const char *type)
2320 {
2321 PyObject *cache = SWIG_Python_TypeCache();
2322 PyObject *key = PyString_FromString(type);
2323 PyObject *obj = PyDict_GetItem(cache, key);
2324 swig_type_info *descriptor;
2325 if (obj) {
2326 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2327 } else {
2328 swig_module_info *swig_module = SWIG_Python_GetModule();
2329 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2330 if (descriptor) {
2331 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2332 PyDict_SetItem(cache, key, obj);
2333 Py_DECREF(obj);
2334 }
2335 }
2336 Py_DECREF(key);
2337 return descriptor;
2338 }
2339
2340 /*
2341 For backward compatibility only
2342 */
2343 #define SWIG_POINTER_EXCEPTION 0
2344 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2345 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2346
2347 SWIGRUNTIME int
2348 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2349 {
2350 if (PyErr_Occurred()) {
2351 PyObject *type = 0;
2352 PyObject *value = 0;
2353 PyObject *traceback = 0;
2354 PyErr_Fetch(&type, &value, &traceback);
2355 if (value) {
2356 PyObject *old_str = PyObject_Str(value);
2357 Py_XINCREF(type);
2358 PyErr_Clear();
2359 if (infront) {
2360 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2361 } else {
2362 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2363 }
2364 Py_DECREF(old_str);
2365 }
2366 return 1;
2367 } else {
2368 return 0;
2369 }
2370 }
2371
2372 SWIGRUNTIME int
2373 SWIG_Python_ArgFail(int argnum)
2374 {
2375 if (PyErr_Occurred()) {
2376 /* add information about failing argument */
2377 char mesg[256];
2378 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2379 return SWIG_Python_AddErrMesg(mesg, 1);
2380 } else {
2381 return 0;
2382 }
2383 }
2384
2385 SWIGRUNTIMEINLINE const char *
2386 PySwigObject_GetDesc(PyObject *self)
2387 {
2388 PySwigObject *v = (PySwigObject *)self;
2389 swig_type_info *ty = v ? v->ty : 0;
2390 return ty ? ty->str : (char*)"";
2391 }
2392
2393 SWIGRUNTIME void
2394 SWIG_Python_TypeError(const char *type, PyObject *obj)
2395 {
2396 if (type) {
2397 #if defined(SWIG_COBJECT_TYPES)
2398 if (obj && PySwigObject_Check(obj)) {
2399 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2400 if (otype) {
2401 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2402 type, otype);
2403 return;
2404 }
2405 } else
2406 #endif
2407 {
2408 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2409 if (otype) {
2410 PyObject *str = PyObject_Str(obj);
2411 const char *cstr = str ? PyString_AsString(str) : 0;
2412 if (cstr) {
2413 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2414 type, otype, cstr);
2415 } else {
2416 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2417 type, otype);
2418 }
2419 Py_XDECREF(str);
2420 return;
2421 }
2422 }
2423 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2424 } else {
2425 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2426 }
2427 }
2428
2429
2430 /* Convert a pointer value, signal an exception on a type mismatch */
2431 SWIGRUNTIME void *
2432 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2433 void *result;
2434 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2435 PyErr_Clear();
2436 if (flags & SWIG_POINTER_EXCEPTION) {
2437 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2438 SWIG_Python_ArgFail(argnum);
2439 }
2440 }
2441 return result;
2442 }
2443
2444
2445 #ifdef __cplusplus
2446 #if 0
2447 { /* cc-mode */
2448 #endif
2449 }
2450 #endif
2451
2452
2453
2454 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2455
2456 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2457
2458
2459
2460 /* -------- TYPES TABLE (BEGIN) -------- */
2461
2462 #define SWIGTYPE_p_buffer swig_types[0]
2463 #define SWIGTYPE_p_char swig_types[1]
2464 #define SWIGTYPE_p_form_ops_t swig_types[2]
2465 #define SWIGTYPE_p_int swig_types[3]
2466 #define SWIGTYPE_p_long swig_types[4]
2467 #define SWIGTYPE_p_unsigned_char swig_types[5]
2468 #define SWIGTYPE_p_unsigned_int swig_types[6]
2469 #define SWIGTYPE_p_unsigned_long swig_types[7]
2470 #define SWIGTYPE_p_wxANIHandler swig_types[8]
2471 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[9]
2472 #define SWIGTYPE_p_wxAcceleratorTable swig_types[10]
2473 #define SWIGTYPE_p_wxActivateEvent swig_types[11]
2474 #define SWIGTYPE_p_wxAppTraits swig_types[12]
2475 #define SWIGTYPE_p_wxArrayString swig_types[13]
2476 #define SWIGTYPE_p_wxBMPHandler swig_types[14]
2477 #define SWIGTYPE_p_wxBitmap swig_types[15]
2478 #define SWIGTYPE_p_wxBoxSizer swig_types[16]
2479 #define SWIGTYPE_p_wxButton swig_types[17]
2480 #define SWIGTYPE_p_wxCURHandler swig_types[18]
2481 #define SWIGTYPE_p_wxCaret swig_types[19]
2482 #define SWIGTYPE_p_wxChildFocusEvent swig_types[20]
2483 #define SWIGTYPE_p_wxCloseEvent swig_types[21]
2484 #define SWIGTYPE_p_wxColour swig_types[22]
2485 #define SWIGTYPE_p_wxCommandEvent swig_types[23]
2486 #define SWIGTYPE_p_wxContextMenuEvent swig_types[24]
2487 #define SWIGTYPE_p_wxControl swig_types[25]
2488 #define SWIGTYPE_p_wxControlWithItems swig_types[26]
2489 #define SWIGTYPE_p_wxCursor swig_types[27]
2490 #define SWIGTYPE_p_wxDC swig_types[28]
2491 #define SWIGTYPE_p_wxDateEvent swig_types[29]
2492 #define SWIGTYPE_p_wxDateTime swig_types[30]
2493 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[31]
2494 #define SWIGTYPE_p_wxDropFilesEvent swig_types[32]
2495 #define SWIGTYPE_p_wxDuplexMode swig_types[33]
2496 #define SWIGTYPE_p_wxEraseEvent swig_types[34]
2497 #define SWIGTYPE_p_wxEvent swig_types[35]
2498 #define SWIGTYPE_p_wxEventLoop swig_types[36]
2499 #define SWIGTYPE_p_wxEventLoopActivator swig_types[37]
2500 #define SWIGTYPE_p_wxEvtHandler swig_types[38]
2501 #define SWIGTYPE_p_wxFSFile swig_types[39]
2502 #define SWIGTYPE_p_wxFileSystem swig_types[40]
2503 #define SWIGTYPE_p_wxFileSystemHandler swig_types[41]
2504 #define SWIGTYPE_p_wxFlexGridSizer swig_types[42]
2505 #define SWIGTYPE_p_wxFocusEvent swig_types[43]
2506 #define SWIGTYPE_p_wxFont swig_types[44]
2507 #define SWIGTYPE_p_wxFrame swig_types[45]
2508 #define SWIGTYPE_p_wxGBPosition swig_types[46]
2509 #define SWIGTYPE_p_wxGBSizerItem swig_types[47]
2510 #define SWIGTYPE_p_wxGBSpan swig_types[48]
2511 #define SWIGTYPE_p_wxGIFHandler swig_types[49]
2512 #define SWIGTYPE_p_wxGridBagSizer swig_types[50]
2513 #define SWIGTYPE_p_wxGridSizer swig_types[51]
2514 #define SWIGTYPE_p_wxICOHandler swig_types[52]
2515 #define SWIGTYPE_p_wxIconizeEvent swig_types[53]
2516 #define SWIGTYPE_p_wxIdleEvent swig_types[54]
2517 #define SWIGTYPE_p_wxImage swig_types[55]
2518 #define SWIGTYPE_p_wxImageHandler swig_types[56]
2519 #define SWIGTYPE_p_wxImageHistogram swig_types[57]
2520 #define SWIGTYPE_p_wxImage_HSVValue swig_types[58]
2521 #define SWIGTYPE_p_wxImage_RGBValue swig_types[59]
2522 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[60]
2523 #define SWIGTYPE_p_wxInitDialogEvent swig_types[61]
2524 #define SWIGTYPE_p_wxInputStream swig_types[62]
2525 #define SWIGTYPE_p_wxInternetFSHandler swig_types[63]
2526 #define SWIGTYPE_p_wxItemContainer swig_types[64]
2527 #define SWIGTYPE_p_wxJPEGHandler swig_types[65]
2528 #define SWIGTYPE_p_wxKeyEvent swig_types[66]
2529 #define SWIGTYPE_p_wxLayoutConstraints swig_types[67]
2530 #define SWIGTYPE_p_wxMaximizeEvent swig_types[68]
2531 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[69]
2532 #define SWIGTYPE_p_wxMenu swig_types[70]
2533 #define SWIGTYPE_p_wxMenuBar swig_types[71]
2534 #define SWIGTYPE_p_wxMenuBarBase swig_types[72]
2535 #define SWIGTYPE_p_wxMenuEvent swig_types[73]
2536 #define SWIGTYPE_p_wxMenuItem swig_types[74]
2537 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[75]
2538 #define SWIGTYPE_p_wxMouseEvent swig_types[76]
2539 #define SWIGTYPE_p_wxMoveEvent swig_types[77]
2540 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[78]
2541 #define SWIGTYPE_p_wxNcPaintEvent swig_types[79]
2542 #define SWIGTYPE_p_wxNotifyEvent swig_types[80]
2543 #define SWIGTYPE_p_wxObject swig_types[81]
2544 #define SWIGTYPE_p_wxOutputStream swig_types[82]
2545 #define SWIGTYPE_p_wxPCXHandler swig_types[83]
2546 #define SWIGTYPE_p_wxPNGHandler swig_types[84]
2547 #define SWIGTYPE_p_wxPNMHandler swig_types[85]
2548 #define SWIGTYPE_p_wxPaintEvent swig_types[86]
2549 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[87]
2550 #define SWIGTYPE_p_wxPaperSize swig_types[88]
2551 #define SWIGTYPE_p_wxPoint swig_types[89]
2552 #define SWIGTYPE_p_wxPoint2D swig_types[90]
2553 #define SWIGTYPE_p_wxPropagateOnce swig_types[91]
2554 #define SWIGTYPE_p_wxPropagationDisabler swig_types[92]
2555 #define SWIGTYPE_p_wxPyApp swig_types[93]
2556 #define SWIGTYPE_p_wxPyCommandEvent swig_types[94]
2557 #define SWIGTYPE_p_wxPyDropTarget swig_types[95]
2558 #define SWIGTYPE_p_wxPyEvent swig_types[96]
2559 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[97]
2560 #define SWIGTYPE_p_wxPyImageHandler swig_types[98]
2561 #define SWIGTYPE_p_wxPyInputStream swig_types[99]
2562 #define SWIGTYPE_p_wxPySizer swig_types[100]
2563 #define SWIGTYPE_p_wxPyValidator swig_types[101]
2564 #define SWIGTYPE_p_wxQuantize swig_types[102]
2565 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[103]
2566 #define SWIGTYPE_p_wxRealPoint swig_types[104]
2567 #define SWIGTYPE_p_wxRect swig_types[105]
2568 #define SWIGTYPE_p_wxRegion swig_types[106]
2569 #define SWIGTYPE_p_wxScrollEvent swig_types[107]
2570 #define SWIGTYPE_p_wxScrollWinEvent swig_types[108]
2571 #define SWIGTYPE_p_wxSetCursorEvent swig_types[109]
2572 #define SWIGTYPE_p_wxShowEvent swig_types[110]
2573 #define SWIGTYPE_p_wxSize swig_types[111]
2574 #define SWIGTYPE_p_wxSizeEvent swig_types[112]
2575 #define SWIGTYPE_p_wxSizer swig_types[113]
2576 #define SWIGTYPE_p_wxSizerItem swig_types[114]
2577 #define SWIGTYPE_p_wxStaticBox swig_types[115]
2578 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[116]
2579 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[117]
2580 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[118]
2581 #define SWIGTYPE_p_wxTIFFHandler swig_types[119]
2582 #define SWIGTYPE_p_wxToolTip swig_types[120]
2583 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[121]
2584 #define SWIGTYPE_p_wxValidator swig_types[122]
2585 #define SWIGTYPE_p_wxVisualAttributes swig_types[123]
2586 #define SWIGTYPE_p_wxWindow swig_types[124]
2587 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[125]
2588 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[126]
2589 #define SWIGTYPE_p_wxXPMHandler swig_types[127]
2590 #define SWIGTYPE_p_wxZipFSHandler swig_types[128]
2591 static swig_type_info *swig_types[130];
2592 static swig_module_info swig_module = {swig_types, 129, 0, 0, 0, 0};
2593 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2594 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2595
2596 /* -------- TYPES TABLE (END) -------- */
2597
2598 #if (PY_VERSION_HEX <= 0x02000000)
2599 # if !defined(SWIG_PYTHON_CLASSIC)
2600 # error "This python version requires to use swig with the '-classic' option"
2601 # endif
2602 #endif
2603 #if (PY_VERSION_HEX <= 0x02020000)
2604 # error "This python version requires to use swig with the '-nomodern' option"
2605 #endif
2606 #if (PY_VERSION_HEX <= 0x02020000)
2607 # error "This python version requires to use swig with the '-nomodernargs' option"
2608 #endif
2609 #ifndef METH_O
2610 # error "This python version requires to use swig with the '-nofastunpack' option"
2611 #endif
2612
2613 /*-----------------------------------------------
2614 @(target):= _core_.so
2615 ------------------------------------------------*/
2616 #define SWIG_init init_core_
2617
2618 #define SWIG_name "_core_"
2619
2620 #define SWIGVERSION 0x010329
2621
2622
2623 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2624 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2625
2626
2627 #include <stdexcept>
2628
2629
2630 namespace swig {
2631 class PyObject_ptr {
2632 protected:
2633 PyObject *_obj;
2634
2635 public:
2636 PyObject_ptr() :_obj(0)
2637 {
2638 }
2639
2640 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2641 {
2642 Py_XINCREF(_obj);
2643 }
2644
2645 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2646 {
2647 if (initial_ref) Py_XINCREF(_obj);
2648 }
2649
2650 PyObject_ptr & operator=(const PyObject_ptr& item)
2651 {
2652 Py_XINCREF(item._obj);
2653 Py_XDECREF(_obj);
2654 _obj = item._obj;
2655 return *this;
2656 }
2657
2658 ~PyObject_ptr()
2659 {
2660 Py_XDECREF(_obj);
2661 }
2662
2663 operator PyObject *() const
2664 {
2665 return _obj;
2666 }
2667
2668 PyObject *operator->() const
2669 {
2670 return _obj;
2671 }
2672 };
2673 }
2674
2675
2676 namespace swig {
2677 struct PyObject_var : PyObject_ptr {
2678 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2679
2680 PyObject_var & operator = (PyObject* obj)
2681 {
2682 Py_XDECREF(_obj);
2683 _obj = obj;
2684 return *this;
2685 }
2686 };
2687 }
2688
2689
2690 #include "wx/wxPython/wxPython_int.h"
2691 #include "wx/wxPython/pyclasses.h"
2692
2693
2694 #ifndef wxPyUSE_EXPORT
2695 // Helper functions for dealing with SWIG objects and such. These are
2696 // located here so they know about the SWIG types and functions declared
2697 // in the wrapper code.
2698
2699 #include <wx/hashmap.h>
2700 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
2701
2702
2703 // Maintains a hashmap of className to swig_type_info pointers. Given the
2704 // name of a class either looks up the type info in the cache, or scans the
2705 // SWIG tables for it.
2706 extern PyObject* wxPyPtrTypeMap;
2707 static
2708 swig_type_info* wxPyFindSwigType(const wxChar* className) {
2709
2710 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
2711
2712 if (typeInfoCache == NULL)
2713 typeInfoCache = new wxPyTypeInfoHashMap;
2714
2715 wxString name(className);
2716 swig_type_info* swigType = (*typeInfoCache)[name];
2717
2718 if (! swigType) {
2719 // it wasn't in the cache, so look it up from SWIG
2720 name.Append(wxT(" *"));
2721 swigType = SWIG_TypeQuery(name.mb_str());
2722
2723 // if it still wasn't found, try looking for a mapped name
2724 if (!swigType) {
2725 PyObject* item;
2726 name = className;
2727
2728 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
2729 (char*)(const char*)name.mbc_str())) != NULL) {
2730 name = wxString(PyString_AsString(item), *wxConvCurrent);
2731 name.Append(wxT(" *"));
2732 swigType = SWIG_TypeQuery(name.mb_str());
2733 }
2734 }
2735 if (swigType) {
2736 // and add it to the map if found
2737 (*typeInfoCache)[className] = swigType;
2738 }
2739 }
2740 return swigType;
2741 }
2742
2743
2744 // Check if a class name is a type known to SWIG
2745 bool wxPyCheckSwigType(const wxChar* className) {
2746
2747 swig_type_info* swigType = wxPyFindSwigType(className);
2748 return swigType != NULL;
2749 }
2750
2751
2752 // Given a pointer to a C++ object and a class name, construct a Python proxy
2753 // object for it.
2754 PyObject* wxPyConstructObject(void* ptr,
2755 const wxChar* className,
2756 int setThisOwn) {
2757
2758 swig_type_info* swigType = wxPyFindSwigType(className);
2759 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
2760
2761 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
2762 }
2763
2764
2765 // Extract a pointer to the wrapped C++ object from a Python proxy object.
2766 // Ensures that the proxy object is of the specified (or derived) type. If
2767 // not able to perform the conversion then a Python exception is set and the
2768 // error should be handled properly in the caller. Returns True on success.
2769 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
2770 const wxChar* className) {
2771
2772 swig_type_info* swigType = wxPyFindSwigType(className);
2773 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
2774
2775 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
2776 }
2777
2778
2779
2780 // Make a SWIGified pointer object suitable for a .this attribute
2781 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
2782
2783 PyObject* robj = NULL;
2784
2785 swig_type_info* swigType = wxPyFindSwigType(className);
2786 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyMakeSwigPtr"));
2787
2788 robj = PySwigObject_New(ptr, swigType, 0);
2789 return robj;
2790 }
2791
2792
2793 // Python's PyInstance_Check does not return True for instances of new-style
2794 // classes. This should get close enough for both new and old classes but I
2795 // should re-evaluate the need for doing instance checks...
2796 bool wxPyInstance_Check(PyObject* obj) {
2797 return PyObject_HasAttrString(obj, "__class__") != 0;
2798 }
2799
2800
2801 // This one checks if the object is an instance of a SWIG proxy class (it has
2802 // a .this attribute, and the .this attribute is a PySwigObject.)
2803 bool wxPySwigInstance_Check(PyObject* obj) {
2804 static PyObject* this_str = NULL;
2805 if (this_str == NULL)
2806 this_str = PyString_FromString("this");
2807
2808 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
2809 if (this_attr) {
2810 bool retval = (PySwigObject_Check(this_attr) != 0);
2811 Py_DECREF(this_attr);
2812 return retval;
2813 }
2814
2815 PyErr_Clear();
2816 return false;
2817 }
2818
2819
2820 // Export a C API in a struct. Other modules will be able to load this from
2821 // the wx._core_ module and will then have safe access to these functions,
2822 // even if they are located in another shared library.
2823 static wxPyCoreAPI API = {
2824
2825 wxPyCheckSwigType,
2826 wxPyConstructObject,
2827 wxPyConvertSwigPtr,
2828 wxPyMakeSwigPtr,
2829
2830 wxPyBeginAllowThreads,
2831 wxPyEndAllowThreads,
2832 wxPyBeginBlockThreads,
2833 wxPyEndBlockThreads,
2834
2835 wxPy_ConvertList,
2836
2837 wxString_in_helper,
2838 Py2wxString,
2839 wx2PyString,
2840
2841 byte_LIST_helper,
2842 int_LIST_helper,
2843 long_LIST_helper,
2844 string_LIST_helper,
2845 wxPoint_LIST_helper,
2846 wxBitmap_LIST_helper,
2847 wxString_LIST_helper,
2848 wxAcceleratorEntry_LIST_helper,
2849
2850 wxSize_helper,
2851 wxPoint_helper,
2852 wxRealPoint_helper,
2853 wxRect_helper,
2854 wxColour_helper,
2855 wxPoint2D_helper,
2856
2857 wxPySimple_typecheck,
2858 wxColour_typecheck,
2859
2860 wxPyCBH_setCallbackInfo,
2861 wxPyCBH_findCallback,
2862 wxPyCBH_callCallback,
2863 wxPyCBH_callCallbackObj,
2864 wxPyCBH_delete,
2865
2866 wxPyMake_wxObject,
2867 wxPyMake_wxSizer,
2868 wxPyPtrTypeMap_Add,
2869 wxPy2int_seq_helper,
2870 wxPy4int_seq_helper,
2871 wxArrayString2PyList_helper,
2872 wxArrayInt2PyList_helper,
2873
2874 wxPyClientData_dtor,
2875 wxPyUserData_dtor,
2876 wxPyOORClientData_dtor,
2877
2878 wxPyCBInputStream_create,
2879 wxPyCBInputStream_copy,
2880
2881 wxPyInstance_Check,
2882 wxPySwigInstance_Check,
2883
2884 wxPyCheckForApp
2885
2886 };
2887
2888 #endif
2889
2890
2891 #if !WXWIN_COMPATIBILITY_2_4
2892 #define wxHIDE_READONLY 0
2893 #endif
2894
2895
2896 #define SWIG_From_long PyInt_FromLong
2897
2898
2899 SWIGINTERNINLINE PyObject *
2900 SWIG_From_int (int value)
2901 {
2902 return SWIG_From_long (value);
2903 }
2904
2905 static const wxString wxPyEmptyString(wxEmptyString);
2906 SWIGINTERN wxString wxObject_GetClassName(wxObject *self){
2907 return self->GetClassInfo()->GetClassName();
2908 }
2909 SWIGINTERN void wxObject_Destroy(wxObject *self){
2910 delete self;
2911 }
2912
2913 #ifndef __WXMAC__
2914 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
2915 #endif
2916
2917
2918 #include <limits.h>
2919 #ifndef LLONG_MIN
2920 # define LLONG_MIN LONG_LONG_MIN
2921 #endif
2922 #ifndef LLONG_MAX
2923 # define LLONG_MAX LONG_LONG_MAX
2924 #endif
2925 #ifndef ULLONG_MAX
2926 # define ULLONG_MAX ULONG_LONG_MAX
2927 #endif
2928
2929
2930 SWIGINTERN int
2931 SWIG_AsVal_long (PyObject* obj, long* val)
2932 {
2933 if (PyNumber_Check(obj)) {
2934 if (val) *val = PyInt_AsLong(obj);
2935 return SWIG_OK;
2936 }
2937 return SWIG_TypeError;
2938 }
2939
2940
2941 SWIGINTERN int
2942 SWIG_AsVal_int (PyObject * obj, int *val)
2943 {
2944 long v;
2945 int res = SWIG_AsVal_long (obj, &v);
2946 if (SWIG_IsOK(res)) {
2947 if ((v < INT_MIN || v > INT_MAX)) {
2948 return SWIG_OverflowError;
2949 } else {
2950 if (val) *val = static_cast< int >(v);
2951 }
2952 }
2953 return res;
2954 }
2955
2956 SWIGINTERN bool wxSize___eq__(wxSize *self,PyObject *other){
2957 wxSize temp, *obj = &temp;
2958 if ( other == Py_None ) return false;
2959 if ( ! wxSize_helper(other, &obj) ) {
2960 PyErr_Clear();
2961 return false;
2962 }
2963 return self->operator==(*obj);
2964 }
2965 SWIGINTERN bool wxSize___ne__(wxSize *self,PyObject *other){
2966 wxSize temp, *obj = &temp;
2967 if ( other == Py_None ) return true;
2968 if ( ! wxSize_helper(other, &obj)) {
2969 PyErr_Clear();
2970 return true;
2971 }
2972 return self->operator!=(*obj);
2973 }
2974 SWIGINTERN PyObject *wxSize_Get(wxSize *self){
2975 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2976 PyObject* tup = PyTuple_New(2);
2977 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
2978 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
2979 wxPyEndBlockThreads(blocked);
2980 return tup;
2981 }
2982
2983 SWIGINTERN int
2984 SWIG_AsVal_double (PyObject *obj, double* val)
2985 {
2986 if (PyNumber_Check(obj)) {
2987 if (val) *val = PyFloat_AsDouble(obj);
2988 return SWIG_OK;
2989 }
2990 return SWIG_TypeError;
2991 }
2992
2993
2994 #define SWIG_From_double PyFloat_FromDouble
2995
2996 SWIGINTERN bool wxRealPoint___eq__(wxRealPoint *self,PyObject *other){
2997 wxRealPoint temp, *obj = &temp;
2998 if ( other == Py_None ) return false;
2999 if ( ! wxRealPoint_helper(other, &obj) ) {
3000 PyErr_Clear();
3001 return false;
3002 }
3003 return self->operator==(*obj);
3004 }
3005 SWIGINTERN bool wxRealPoint___ne__(wxRealPoint *self,PyObject *other){
3006 wxRealPoint temp, *obj = &temp;
3007 if ( other == Py_None ) return true;
3008 if ( ! wxRealPoint_helper(other, &obj)) {
3009 PyErr_Clear();
3010 return true;
3011 }
3012 return self->operator!=(*obj);
3013 }
3014 SWIGINTERN void wxRealPoint_Set(wxRealPoint *self,double x,double y){
3015 self->x = x;
3016 self->y = y;
3017 }
3018 SWIGINTERN PyObject *wxRealPoint_Get(wxRealPoint *self){
3019 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3020 PyObject* tup = PyTuple_New(2);
3021 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
3022 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
3023 wxPyEndBlockThreads(blocked);
3024 return tup;
3025 }
3026 SWIGINTERN bool wxPoint___eq__(wxPoint *self,PyObject *other){
3027 wxPoint temp, *obj = &temp;
3028 if ( other == Py_None ) return false;
3029 if ( ! wxPoint_helper(other, &obj) ) {
3030 PyErr_Clear();
3031 return false;
3032 }
3033 return self->operator==(*obj);
3034 }
3035 SWIGINTERN bool wxPoint___ne__(wxPoint *self,PyObject *other){
3036 wxPoint temp, *obj = &temp;
3037 if ( other == Py_None ) return true;
3038 if ( ! wxPoint_helper(other, &obj)) {
3039 PyErr_Clear();
3040 return true;
3041 }
3042 return self->operator!=(*obj);
3043 }
3044 SWIGINTERN void wxPoint_Set(wxPoint *self,long x,long y){
3045 self->x = x;
3046 self->y = y;
3047 }
3048 SWIGINTERN PyObject *wxPoint_Get(wxPoint *self){
3049 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3050 PyObject* tup = PyTuple_New(2);
3051 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3052 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3053 wxPyEndBlockThreads(blocked);
3054 return tup;
3055 }
3056 SWIGINTERN bool wxRect___eq__(wxRect *self,PyObject *other){
3057 wxRect temp, *obj = &temp;
3058 if ( other == Py_None ) return false;
3059 if ( ! wxRect_helper(other, &obj) ) {
3060 PyErr_Clear();
3061 return false;
3062 }
3063 return self->operator==(*obj);
3064 }
3065 SWIGINTERN bool wxRect___ne__(wxRect *self,PyObject *other){
3066 wxRect temp, *obj = &temp;
3067 if ( other == Py_None ) return true;
3068 if ( ! wxRect_helper(other, &obj)) {
3069 PyErr_Clear();
3070 return true;
3071 }
3072 return self->operator!=(*obj);
3073 }
3074 SWIGINTERN void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
3075 self->x = x;
3076 self->y = y;
3077 self->width = width;
3078 self->height = height;
3079 }
3080 SWIGINTERN PyObject *wxRect_Get(wxRect *self){
3081 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3082 PyObject* tup = PyTuple_New(4);
3083 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3084 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3085 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
3086 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
3087 wxPyEndBlockThreads(blocked);
3088 return tup;
3089 }
3090
3091 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
3092 wxRegion reg1(*r1);
3093 wxRegion reg2(*r2);
3094 wxRect dest(0,0,0,0);
3095 PyObject* obj;
3096
3097 reg1.Intersect(reg2);
3098 dest = reg1.GetBox();
3099
3100 if (dest != wxRect(0,0,0,0)) {
3101 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3102 wxRect* newRect = new wxRect(dest);
3103 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
3104 wxPyEndBlockThreads(blocked);
3105 return obj;
3106 }
3107 Py_INCREF(Py_None);
3108 return Py_None;
3109 }
3110
3111 SWIGINTERN bool wxPoint2D___eq__(wxPoint2D *self,PyObject *other){
3112 wxPoint2D temp, *obj = &temp;
3113 if ( other == Py_None ) return false;
3114 if ( ! wxPoint2D_helper(other, &obj) ) {
3115 PyErr_Clear();
3116 return false;
3117 }
3118 return self->operator==(*obj);
3119 }
3120 SWIGINTERN bool wxPoint2D___ne__(wxPoint2D *self,PyObject *other){
3121 wxPoint2D temp, *obj = &temp;
3122 if ( other == Py_None ) return true;
3123 if ( ! wxPoint2D_helper(other, &obj)) {
3124 PyErr_Clear();
3125 return true;
3126 }
3127 return self->operator!=(*obj);
3128 }
3129 SWIGINTERN void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
3130 self->m_x = x;
3131 self->m_y = y;
3132 }
3133 SWIGINTERN PyObject *wxPoint2D_Get(wxPoint2D *self){
3134 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3135 PyObject* tup = PyTuple_New(2);
3136 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3137 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3138 wxPyEndBlockThreads(blocked);
3139 return tup;
3140 }
3141
3142 #include "wx/wxPython/pyistream.h"
3143
3144 SWIGINTERN wxPyInputStream *new_wxPyInputStream(PyObject *p){
3145 wxInputStream* wxis = wxPyCBInputStream::create(p);
3146 if (wxis)
3147 return new wxPyInputStream(wxis);
3148 else
3149 return NULL;
3150 }
3151
3152 SWIGINTERN swig_type_info*
3153 SWIG_pchar_descriptor()
3154 {
3155 static int init = 0;
3156 static swig_type_info* info = 0;
3157 if (!init) {
3158 info = SWIG_TypeQuery("_p_char");
3159 init = 1;
3160 }
3161 return info;
3162 }
3163
3164
3165 SWIGINTERNINLINE PyObject *
3166 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3167 {
3168 if (carray) {
3169 if (size > INT_MAX) {
3170 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3171 return pchar_descriptor ?
3172 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3173 } else {
3174 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3175 }
3176 } else {
3177 return SWIG_Py_Void();
3178 }
3179 }
3180
3181
3182 SWIGINTERNINLINE PyObject *
3183 SWIG_From_char (char c)
3184 {
3185 return SWIG_FromCharPtrAndSize(&c,1);
3186 }
3187
3188
3189 SWIGINTERNINLINE PyObject*
3190 SWIG_From_unsigned_SS_long (unsigned long value)
3191 {
3192 return (value > LONG_MAX) ?
3193 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3194 }
3195
3196
3197 SWIGINTERNINLINE PyObject *
3198 SWIG_From_size_t (size_t value)
3199 {
3200 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3201 }
3202
3203
3204 SWIGINTERN int
3205 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3206 {
3207 if (PyString_Check(obj)) {
3208 char *cstr; int len;
3209 PyString_AsStringAndSize(obj, &cstr, &len);
3210 if (cptr) {
3211 if (alloc) {
3212 /*
3213 In python the user should not be able to modify the inner
3214 string representation. To warranty that, if you define
3215 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3216 buffer is always returned.
3217
3218 The default behavior is just to return the pointer value,
3219 so, be careful.
3220 */
3221 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3222 if (*alloc != SWIG_OLDOBJ)
3223 #else
3224 if (*alloc == SWIG_NEWOBJ)
3225 #endif
3226 {
3227 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3228 *alloc = SWIG_NEWOBJ;
3229 }
3230 else {
3231 *cptr = cstr;
3232 *alloc = SWIG_OLDOBJ;
3233 }
3234 } else {
3235 *cptr = PyString_AsString(obj);
3236 }
3237 }
3238 if (psize) *psize = len + 1;
3239 return SWIG_OK;
3240 } else {
3241 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3242 if (pchar_descriptor) {
3243 void* vptr = 0;
3244 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3245 if (cptr) *cptr = (char *) vptr;
3246 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3247 if (alloc) *alloc = SWIG_OLDOBJ;
3248 return SWIG_OK;
3249 }
3250 }
3251 }
3252 return SWIG_TypeError;
3253 }
3254
3255
3256 SWIGINTERN int
3257 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3258 {
3259 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3260 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3261 if (SWIG_IsOK(res)) {
3262 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3263 if (csize <= size) {
3264 if (val) {
3265 if (csize) memcpy(val, cptr, csize*sizeof(char));
3266 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3267 }
3268 if (alloc == SWIG_NEWOBJ) {
3269 delete[] cptr;
3270 res = SWIG_DelNewMask(res);
3271 }
3272 return res;
3273 }
3274 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3275 }
3276 return SWIG_TypeError;
3277 }
3278
3279
3280 SWIGINTERN int
3281 SWIG_AsVal_char (PyObject * obj, char *val)
3282 {
3283 int res = SWIG_AsCharArray(obj, val, 1);
3284 if (!SWIG_IsOK(res)) {
3285 long v;
3286 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3287 if (SWIG_IsOK(res)) {
3288 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3289 if (val) *val = static_cast< char >(v);
3290 } else {
3291 res = SWIG_OverflowError;
3292 }
3293 }
3294 }
3295 return res;
3296 }
3297
3298 SWIGINTERN void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
3299 // We use only strings for the streams, not unicode
3300 PyObject* str = PyObject_Str(obj);
3301 if (! str) {
3302 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
3303 return;
3304 }
3305 self->Write(PyString_AS_STRING(str),
3306 PyString_GET_SIZE(str));
3307 Py_DECREF(str);
3308 }
3309
3310 #include "wx/wxPython/pyistream.h"
3311
3312
3313 class wxPyFileSystemHandler : public wxFileSystemHandler
3314 {
3315 public:
3316 wxPyFileSystemHandler() : wxFileSystemHandler() {}
3317
3318 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
3319 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
3320 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
3321 DEC_PYCALLBACK_STRING__pure(FindNext);
3322
3323 wxString GetProtocol(const wxString& location) {
3324 return wxFileSystemHandler::GetProtocol(location);
3325 }
3326
3327 wxString GetLeftLocation(const wxString& location) {
3328 return wxFileSystemHandler::GetLeftLocation(location);
3329 }
3330
3331 wxString GetAnchor(const wxString& location) {
3332 return wxFileSystemHandler::GetAnchor(location);
3333 }
3334
3335 wxString GetRightLocation(const wxString& location) {
3336 return wxFileSystemHandler::GetRightLocation(location);
3337 }
3338
3339 wxString GetMimeTypeFromExt(const wxString& location) {
3340 return wxFileSystemHandler::GetMimeTypeFromExt(location);
3341 }
3342
3343 PYPRIVATE;
3344 };
3345
3346
3347 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
3348 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
3349 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
3350 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
3351
3352
3353 SWIGINTERN int
3354 SWIG_AsVal_bool (PyObject *obj, bool *val)
3355 {
3356 if (obj == Py_True) {
3357 if (val) *val = true;
3358 return SWIG_OK;
3359 } else if (obj == Py_False) {
3360 if (val) *val = false;
3361 return SWIG_OK;
3362 } else {
3363 long v = 0;
3364 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3365 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3366 return res;
3367 }
3368 }
3369
3370 SWIGINTERN wxString wxFileSystem_URLToFileName(wxString const &url){
3371 wxFileName fname = wxFileSystem::URLToFileName(url);
3372 return fname.GetFullPath();
3373 }
3374
3375 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
3376 wxImage& image,
3377 long type) {
3378 wxMemoryFSHandler::AddFile(filename, image, type);
3379 }
3380
3381 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
3382 const wxBitmap& bitmap,
3383 long type) {
3384 wxMemoryFSHandler::AddFile(filename, bitmap, type);
3385 }
3386
3387 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
3388 PyObject* data) {
3389 if (! PyString_Check(data)) {
3390 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
3391 "Expected string object"));
3392 return;
3393 }
3394
3395 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3396 void* ptr = (void*)PyString_AsString(data);
3397 size_t size = PyString_Size(data);
3398 wxPyEndBlockThreads(blocked);
3399
3400 wxMemoryFSHandler::AddFile(filename, ptr, size);
3401 }
3402
3403
3404 #include "wx/wxPython/pyistream.h"
3405
3406
3407 SWIGINTERN int
3408 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3409 {
3410 long v = 0;
3411 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3412 return SWIG_TypeError;
3413 }
3414 else if (val)
3415 *val = (unsigned long)v;
3416 return SWIG_OK;
3417 }
3418
3419
3420 SWIGINTERN int
3421 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
3422 {
3423 unsigned long v;
3424 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3425 if (SWIG_IsOK(res)) {
3426 if ((v > UCHAR_MAX)) {
3427 return SWIG_OverflowError;
3428 } else {
3429 if (val) *val = static_cast< unsigned char >(v);
3430 }
3431 }
3432 return res;
3433 }
3434
3435
3436 SWIGINTERNINLINE PyObject *
3437 SWIG_From_unsigned_SS_char (unsigned char value)
3438 {
3439 return SWIG_From_unsigned_SS_long (value);
3440 }
3441
3442 SWIGINTERN unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
3443 wxImageHistogramEntry e = (*self)[key];
3444 return e.value;
3445 }
3446 SWIGINTERN unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
3447 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
3448 wxImageHistogramEntry e = (*self)[key];
3449 return e.value;
3450 }
3451 SWIGINTERN unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
3452 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
3453 colour.Green(),
3454 colour.Blue());
3455 wxImageHistogramEntry e = (*self)[key];
3456 return e.value;
3457 }
3458
3459 typedef unsigned char* buffer;
3460
3461
3462 // Pull the nested class out to the top level for SWIG's sake
3463 #define wxImage_RGBValue wxImage::RGBValue
3464 #define wxImage_HSVValue wxImage::HSVValue
3465
3466 SWIGINTERN wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
3467 if (width > 0 && height > 0)
3468 return new wxImage(width, height, clear);
3469 else
3470 return new wxImage;
3471 }
3472 SWIGINTERN wxImage *new_wxImage(wxBitmap const &bitmap){
3473 return new wxImage(bitmap.ConvertToImage());
3474 }
3475 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
3476 if (DATASIZE != width*height*3) {
3477 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3478 return NULL;
3479 }
3480
3481 // Copy the source data so the wxImage can clean it up later
3482 buffer copy = (buffer)malloc(DATASIZE);
3483 if (copy == NULL) {
3484 wxPyBLOCK_THREADS(PyErr_NoMemory());
3485 return NULL;
3486 }
3487 memcpy(copy, data, DATASIZE);
3488 return new wxImage(width, height, copy, false);
3489 }
3490 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
3491 if (DATASIZE != width*height*3) {
3492 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3493 return NULL;
3494 }
3495 if (ALPHASIZE != width*height) {
3496 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3497 return NULL;
3498 }
3499
3500 // Copy the source data so the wxImage can clean it up later
3501 buffer dcopy = (buffer)malloc(DATASIZE);
3502 if (dcopy == NULL) {
3503 wxPyBLOCK_THREADS(PyErr_NoMemory());
3504 return NULL;
3505 }
3506 memcpy(dcopy, data, DATASIZE);
3507
3508 buffer acopy = (buffer)malloc(ALPHASIZE);
3509 if (acopy == NULL) {
3510 wxPyBLOCK_THREADS(PyErr_NoMemory());
3511 return NULL;
3512 }
3513 memcpy(acopy, alpha, ALPHASIZE);
3514
3515 return new wxImage(width, height, dcopy, acopy, false);
3516 }
3517 SWIGINTERN wxSize wxImage_GetSize(wxImage *self){
3518 wxSize size(self->GetWidth(), self->GetHeight());
3519 return size;
3520 }
3521 SWIGINTERN PyObject *wxImage_GetData(wxImage *self){
3522 buffer data = self->GetData();
3523 int len = self->GetWidth() * self->GetHeight() * 3;
3524 PyObject* rv;
3525 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
3526 return rv;
3527 }
3528 SWIGINTERN void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
3529 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3530 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3531 return;
3532 }
3533 buffer copy = (buffer)malloc(DATASIZE);
3534 if (copy == NULL) {
3535 wxPyBLOCK_THREADS(PyErr_NoMemory());
3536 return;
3537 }
3538 memcpy(copy, data, DATASIZE);
3539 self->SetData(copy, false);
3540 // wxImage takes ownership of copy...
3541 }
3542 SWIGINTERN PyObject *wxImage_GetDataBuffer(wxImage *self){
3543 buffer data = self->GetData();
3544 int len = self->GetWidth() * self->GetHeight() * 3;
3545 PyObject* rv;
3546 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3547 return rv;
3548 }
3549 SWIGINTERN void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
3550 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3551 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3552 return;
3553 }
3554 self->SetData(data, true);
3555 }
3556 SWIGINTERN PyObject *wxImage_GetAlphaData(wxImage *self){
3557 buffer data = self->GetAlpha();
3558 if (! data) {
3559 RETURN_NONE();
3560 } else {
3561 int len = self->GetWidth() * self->GetHeight();
3562 PyObject* rv;
3563 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
3564 return rv;
3565 }
3566 }
3567 SWIGINTERN void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
3568 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3569 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3570 return;
3571 }
3572 buffer acopy = (buffer)malloc(ALPHASIZE);
3573 if (acopy == NULL) {
3574 wxPyBLOCK_THREADS(PyErr_NoMemory());
3575 return;
3576 }
3577 memcpy(acopy, alpha, ALPHASIZE);
3578 self->SetAlpha(acopy, false);
3579 // wxImage takes ownership of acopy...
3580 }
3581 SWIGINTERN PyObject *wxImage_GetAlphaBuffer(wxImage *self){
3582 buffer data = self->GetAlpha();
3583 int len = self->GetWidth() * self->GetHeight();
3584 PyObject* rv;
3585 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3586 return rv;
3587 }
3588 SWIGINTERN void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
3589 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3590 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3591 return;
3592 }
3593 self->SetAlpha(alpha, true);
3594 }
3595 SWIGINTERN PyObject *wxImage_GetHandlers(){
3596 wxList& list = wxImage::GetHandlers();
3597 return wxPy_ConvertList(&list);
3598 }
3599 SWIGINTERN wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
3600 wxBitmap bitmap(*self, depth);
3601 return bitmap;
3602 }
3603 SWIGINTERN wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
3604 wxImage mono = self->ConvertToMono( red, green, blue );
3605 wxBitmap bitmap( mono, 1 );
3606 return bitmap;
3607 }
3608 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
3609 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3610 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3611 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3612 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
3613 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3614 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
3615 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
3616 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
3617 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3618 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3619 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3620 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
3621 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3622 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
3623
3624 #include <wx/quantize.h>
3625
3626 SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
3627 return wxQuantize::Quantize(src, dest,
3628 //NULL, // palette
3629 desiredNoColours,
3630 NULL, // eightBitData
3631 flags);
3632 }
3633 SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
3634 if (PyCallable_Check(func)) {
3635 self->Connect(id, lastId, eventType,
3636 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3637 new wxPyCallback(func));
3638 }
3639 else if (func == Py_None) {
3640 self->Disconnect(id, lastId, eventType,
3641 (wxObjectEventFunction)
3642 &wxPyCallback::EventThunker);
3643 }
3644 else {
3645 wxPyBLOCK_THREADS(
3646 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3647 }
3648 }
3649 SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
3650 return self->Disconnect(id, lastId, eventType,
3651 (wxObjectEventFunction)
3652 &wxPyCallback::EventThunker);
3653 }
3654 SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
3655 if (_self && _self != Py_None) {
3656 self->SetClientObject(new wxPyOORClientData(_self, incref));
3657 }
3658 else {
3659 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3660 if (data) {
3661 self->SetClientObject(NULL); // This will delete it too
3662 }
3663 }
3664 }
3665
3666 #if ! wxUSE_HOTKEY
3667 #define wxEVT_HOTKEY -9999
3668 #endif
3669
3670 SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3671 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3672 if (data) {
3673 Py_INCREF(data->m_obj);
3674 return data->m_obj;
3675 } else {
3676 Py_INCREF(Py_None);
3677 return Py_None;
3678 }
3679 }
3680 SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3681 wxPyClientData* data = new wxPyClientData(clientData);
3682 self->SetClientObject(data);
3683 }
3684 SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
3685 #if wxUSE_UNICODE
3686 return self->GetUnicodeKey();
3687 #else
3688 return 0;
3689 #endif
3690 }
3691
3692 SWIGINTERNINLINE PyObject *
3693 SWIG_From_unsigned_SS_int (unsigned int value)
3694 {
3695 return SWIG_From_unsigned_SS_long (value);
3696 }
3697
3698
3699 SWIGINTERN int
3700 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3701 {
3702 unsigned long v;
3703 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3704 if (SWIG_IsOK(res)) {
3705 if ((v > UINT_MAX)) {
3706 return SWIG_OverflowError;
3707 } else {
3708 if (val) *val = static_cast< unsigned int >(v);
3709 }
3710 }
3711 return res;
3712 }
3713
3714 SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
3715 self->m_size = size;
3716 }
3717 SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
3718 int count = self->GetNumberOfFiles();
3719 wxString* files = self->GetFiles();
3720 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3721 PyObject* list = PyList_New(count);
3722
3723 if (!list) {
3724 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
3725 wxPyEndBlockThreads(blocked);
3726 return NULL;
3727 }
3728
3729 for (int i=0; i<count; i++) {
3730 PyList_SetItem(list, i, wx2PyString(files[i]));
3731 }
3732 wxPyEndBlockThreads(blocked);
3733 return list;
3734 }
3735
3736
3737 SWIGINTERN wxPyApp *new_wxPyApp(){
3738 wxPythonApp = new wxPyApp();
3739 return wxPythonApp;
3740 }
3741 SWIGINTERN int wxPyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
3742
3743 void wxApp_CleanUp() {
3744 __wxPyCleanup();
3745 }
3746
3747
3748 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
3749
3750
3751
3752
3753
3754 SWIGINTERNINLINE PyObject *
3755 SWIG_FromCharPtr(const char *cptr)
3756 {
3757 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3758 }
3759
3760
3761 #if 0 // #ifdef __WXMAC__
3762
3763 // A dummy class that raises an exception if used...
3764 class wxEventLoop
3765 {
3766 public:
3767 wxEventLoop() { wxPyRaiseNotImplemented(); }
3768 int Run() { return 0; }
3769 void Exit(int rc = 0) {}
3770 bool Pending() const { return false; }
3771 bool Dispatch() { return false; }
3772 bool IsRunning() const { return false; }
3773 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3774 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3775 };
3776
3777 #else
3778
3779 #include <wx/evtloop.h>
3780
3781 #endif
3782
3783
3784
3785 static const wxString wxPyPanelNameStr(wxPanelNameStr);
3786 SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3787 SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3788 SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
3789 wxWindowList& list = self->GetChildren();
3790 return wxPy_ConvertList(&list);
3791 }
3792 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3793 #if wxUSE_HOTKEY
3794 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3795 #else
3796 return false;
3797 #endif
3798 }
3799 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3800
3801
3802
3803 return false;
3804
3805 }
3806 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3807 return wxPyGetWinHandle(self);
3808 }
3809 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3810 self->AssociateHandle((WXWidget)handle);
3811 }
3812 SWIGINTERN void wxWindow_DragAcceptFiles(wxWindow *self,bool accept){}
3813
3814 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3815 return wxWindow::FindWindowById(id, parent);
3816 }
3817
3818 wxWindow* wxFindWindowByName( const wxString& name,
3819 const wxWindow *parent = NULL ) {
3820 return wxWindow::FindWindowByName(name, parent);
3821 }
3822
3823 wxWindow* wxFindWindowByLabel( const wxString& label,
3824 const wxWindow *parent = NULL ) {
3825 return wxWindow::FindWindowByLabel(label, parent);
3826 }
3827
3828
3829 #ifdef __WXMSW__
3830 #include <wx/msw/private.h> // to get wxGetWindowId
3831 #endif
3832
3833
3834 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3835 #ifdef __WXMSW__
3836 WXHWND hWnd = (WXHWND)_hWnd;
3837 long id = wxGetWindowId(hWnd);
3838 wxWindow* win = new wxWindow;
3839 if (parent)
3840 parent->AddChild(win);
3841 win->SetEventHandler(win);
3842 win->SetHWND(hWnd);
3843 win->SetId(id);
3844 win->SubclassWin(hWnd);
3845 win->AdoptAttributesFromHWND();
3846 win->SetupColours();
3847 return win;
3848 #else
3849 wxPyRaiseNotImplemented();
3850 return NULL;
3851 #endif
3852 }
3853
3854
3855 PyObject* GetTopLevelWindows() {
3856 return wxPy_ConvertList(&wxTopLevelWindows);
3857 }
3858
3859
3860 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3861 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3862 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3863
3864 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3865
3866
3867 SWIGINTERNINLINE int
3868 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3869 {
3870 unsigned long v;
3871 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3872 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3873 return res;
3874 }
3875
3876 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3877 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3878 wxMenuItemList& list = self->GetMenuItems();
3879 return wxPy_ConvertList(&list);
3880 }
3881 SWIGINTERN void wxMenuItem_SetFont(wxMenuItem *self,wxFont const &font){}
3882 SWIGINTERN wxFont wxMenuItem_GetFont(wxMenuItem *self){ return wxNullFont; }
3883 SWIGINTERN void wxMenuItem_SetTextColour(wxMenuItem *self,wxColour const &colText){}
3884 SWIGINTERN wxColour wxMenuItem_GetTextColour(wxMenuItem *self){ return wxNullColour; }
3885 SWIGINTERN void wxMenuItem_SetBackgroundColour(wxMenuItem *self,wxColour const &colBack){}
3886 SWIGINTERN wxColour wxMenuItem_GetBackgroundColour(wxMenuItem *self){ return wxNullColour; }
3887 SWIGINTERN void wxMenuItem_SetBitmaps(wxMenuItem *self,wxBitmap const &bmpChecked,wxBitmap const &bmpUnchecked=wxNullBitmap){ self->SetBitmap( bmpChecked ); }
3888 SWIGINTERN void wxMenuItem_SetDisabledBitmap(wxMenuItem *self,wxBitmap const &bmpDisabled){}
3889 SWIGINTERN wxBitmap const &wxMenuItem_GetDisabledBitmap(wxMenuItem const *self){ return wxNullBitmap; }
3890 SWIGINTERN void wxMenuItem_SetMarginWidth(wxMenuItem *self,int nWidth){}
3891 SWIGINTERN int wxMenuItem_GetMarginWidth(wxMenuItem *self){ return 0; }
3892 SWIGINTERN int wxMenuItem_GetDefaultMarginWidth(){ return 0; }
3893 SWIGINTERN bool wxMenuItem_IsOwnerDrawn(wxMenuItem *self){ return false; }
3894 SWIGINTERN void wxMenuItem_SetOwnerDrawn(wxMenuItem *self,bool ownerDrawn=true){}
3895 SWIGINTERN void wxMenuItem_ResetOwnerDrawn(wxMenuItem *self){}
3896 static const wxString wxPyControlNameStr(wxControlNameStr);
3897 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
3898 if (clientData) {
3899 wxPyClientData* data = new wxPyClientData(clientData);
3900 return self->Append(item, data);
3901 } else
3902 return self->Append(item);
3903 }
3904 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,unsigned int pos,PyObject *clientData=NULL){
3905 if (clientData) {
3906 wxPyClientData* data = new wxPyClientData(clientData);
3907 return self->Insert(item, pos, data);
3908 } else
3909 return self->Insert(item, pos);
3910 }
3911 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,unsigned int n){
3912 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
3913 if (data) {
3914 Py_INCREF(data->m_obj);
3915 return data->m_obj;
3916 } else {
3917 Py_INCREF(Py_None);
3918 return Py_None;
3919 }
3920 }
3921 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,unsigned int n,PyObject *clientData){
3922 wxPyClientData* data = new wxPyClientData(clientData);
3923 self->SetClientObject(n, data);
3924 }
3925
3926
3927 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
3928 wxPyUserData* data = NULL;
3929 if ( userData ) {
3930 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3931 data = new wxPyUserData(userData);
3932 wxPyEndBlockThreads(blocked);
3933 }
3934 return new wxSizerItem(window, proportion, flag, border, data);
3935 }
3936 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
3937 wxPyUserData* data = NULL;
3938 if ( userData ) {
3939 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3940 data = new wxPyUserData(userData);
3941 wxPyEndBlockThreads(blocked);
3942 }
3943 return new wxSizerItem(width, height, proportion, flag, border, data);
3944 }
3945 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
3946 wxPyUserData* data = NULL;
3947 if ( userData ) {
3948 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3949 data = new wxPyUserData(userData);
3950 wxPyEndBlockThreads(blocked);
3951 }
3952 return new wxSizerItem(sizer, proportion, flag, border, data);
3953 }
3954
3955 #include <float.h>
3956
3957
3958 SWIGINTERN int
3959 SWIG_AsVal_float (PyObject * obj, float *val)
3960 {
3961 double v;
3962 int res = SWIG_AsVal_double (obj, &v);
3963 if (SWIG_IsOK(res)) {
3964 if ((v < -FLT_MAX || v > FLT_MAX)) {
3965 return SWIG_OverflowError;
3966 } else {
3967 if (val) *val = static_cast< float >(v);
3968 }
3969 }
3970 return res;
3971 }
3972
3973
3974 SWIGINTERNINLINE PyObject *
3975 SWIG_From_float (float value)
3976 {
3977 return SWIG_From_double (value);
3978 }
3979
3980 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
3981 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
3982 if (data) {
3983 Py_INCREF(data->m_obj);
3984 return data->m_obj;
3985 } else {
3986 Py_INCREF(Py_None);
3987 return Py_None;
3988 }
3989 }
3990 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
3991 wxPyUserData* data = NULL;
3992 if ( userData ) {
3993 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3994 data = new wxPyUserData(userData);
3995 wxPyEndBlockThreads(blocked);
3996 }
3997 self->SetUserData(data);
3998 }
3999
4000 // Figure out the type of the sizer item
4001
4002 struct wxPySizerItemInfo {
4003 wxPySizerItemInfo()
4004 : window(NULL), sizer(NULL), gotSize(false),
4005 size(wxDefaultSize), gotPos(false), pos(-1)
4006 {}
4007
4008 wxWindow* window;
4009 wxSizer* sizer;
4010 bool gotSize;
4011 wxSize size;
4012 bool gotPos;
4013 int pos;
4014 };
4015
4016 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
4017
4018 wxPySizerItemInfo info;
4019 wxSize size;
4020 wxSize* sizePtr = &size;
4021
4022 // Find out what the type of the item is
4023 // try wxWindow
4024 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
4025 PyErr_Clear();
4026 info.window = NULL;
4027
4028 // try wxSizer
4029 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
4030 PyErr_Clear();
4031 info.sizer = NULL;
4032
4033 // try wxSize or (w,h)
4034 if ( checkSize && wxSize_helper(item, &sizePtr)) {
4035 info.size = *sizePtr;
4036 info.gotSize = true;
4037 }
4038
4039 // or a single int
4040 if (checkIdx && PyInt_Check(item)) {
4041 info.pos = PyInt_AsLong(item);
4042 info.gotPos = true;
4043 }
4044 }
4045 }
4046
4047 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
4048 // no expected type, figure out what kind of error message to generate
4049 if ( !checkSize && !checkIdx )
4050 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
4051 else if ( checkSize && !checkIdx )
4052 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
4053 else if ( !checkSize && checkIdx)
4054 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
4055 else
4056 // can this one happen?
4057 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
4058 }
4059
4060 return info;
4061 }
4062
4063 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
4064 if (!self->GetClientObject())
4065 self->SetClientObject(new wxPyOORClientData(_self));
4066 }
4067 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4068
4069 wxPyUserData* data = NULL;
4070 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4071 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4072 if ( userData && (info.window || info.sizer || info.gotSize) )
4073 data = new wxPyUserData(userData);
4074 if ( info.sizer )
4075 PyObject_SetAttrString(item,"thisown",Py_False);
4076 wxPyEndBlockThreads(blocked);
4077
4078 // Now call the real Add method if a valid item type was found
4079 if ( info.window )
4080 return self->Add(info.window, proportion, flag, border, data);
4081 else if ( info.sizer )
4082 return self->Add(info.sizer, proportion, flag, border, data);
4083 else if (info.gotSize)
4084 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4085 proportion, flag, border, data);
4086 else
4087 return NULL;
4088 }
4089 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4090
4091 wxPyUserData* data = NULL;
4092 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4093 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4094 if ( userData && (info.window || info.sizer || info.gotSize) )
4095 data = new wxPyUserData(userData);
4096 if ( info.sizer )
4097 PyObject_SetAttrString(item,"thisown",Py_False);
4098 wxPyEndBlockThreads(blocked);
4099
4100 // Now call the real Insert method if a valid item type was found
4101 if ( info.window )
4102 return self->Insert(before, info.window, proportion, flag, border, data);
4103 else if ( info.sizer )
4104 return self->Insert(before, info.sizer, proportion, flag, border, data);
4105 else if (info.gotSize)
4106 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4107 proportion, flag, border, data);
4108 else
4109 return NULL;
4110 }
4111 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4112
4113 wxPyUserData* data = NULL;
4114 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4115 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4116 if ( userData && (info.window || info.sizer || info.gotSize) )
4117 data = new wxPyUserData(userData);
4118 if ( info.sizer )
4119 PyObject_SetAttrString(item,"thisown",Py_False);
4120 wxPyEndBlockThreads(blocked);
4121
4122 // Now call the real Prepend method if a valid item type was found
4123 if ( info.window )
4124 return self->Prepend(info.window, proportion, flag, border, data);
4125 else if ( info.sizer )
4126 return self->Prepend(info.sizer, proportion, flag, border, data);
4127 else if (info.gotSize)
4128 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4129 proportion, flag, border, data);
4130 else
4131 return NULL;
4132 }
4133 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4134 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4135 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4136 wxPyEndBlockThreads(blocked);
4137 if ( info.window )
4138 return self->Remove(info.window);
4139 else if ( info.sizer )
4140 return self->Remove(info.sizer);
4141 else if ( info.gotPos )
4142 return self->Remove(info.pos);
4143 else
4144 return false;
4145 }
4146 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4147 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4148 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4149 wxPyEndBlockThreads(blocked);
4150 if ( info.window )
4151 return self->Detach(info.window);
4152 else if ( info.sizer )
4153 return self->Detach(info.sizer);
4154 else if ( info.gotPos )
4155 return self->Detach(info.pos);
4156 else
4157 return false;
4158 }
4159 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
4160 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4161 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4162 wxPyEndBlockThreads(blocked);
4163 if ( info.window )
4164 return self->GetItem(info.window);
4165 else if ( info.sizer )
4166 return self->GetItem(info.sizer);
4167 else if ( info.gotPos )
4168 return self->GetItem(info.pos);
4169 else
4170 return NULL;
4171 }
4172 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4173 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4174 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4175 wxPyEndBlockThreads(blocked);
4176 if ( info.window )
4177 self->SetItemMinSize(info.window, size);
4178 else if ( info.sizer )
4179 self->SetItemMinSize(info.sizer, size);
4180 else if ( info.gotPos )
4181 self->SetItemMinSize(info.pos, size);
4182 }
4183 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4184 wxSizerItemList& list = self->GetChildren();
4185 return wxPy_ConvertList(&list);
4186 }
4187 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4188 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4189 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4190 wxPyEndBlockThreads(blocked);
4191 if ( info.window )
4192 return self->Show(info.window, show, recursive);
4193 else if ( info.sizer )
4194 return self->Show(info.sizer, show, recursive);
4195 else if ( info.gotPos )
4196 return self->Show(info.pos, show);
4197 else
4198 return false;
4199 }
4200 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4201 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4202 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4203 wxPyEndBlockThreads(blocked);
4204 if ( info.window )
4205 return self->IsShown(info.window);
4206 else if ( info.sizer )
4207 return self->IsShown(info.sizer);
4208 else if ( info.gotPos )
4209 return self->IsShown(info.pos);
4210 else
4211 return false;
4212 }
4213
4214 // See pyclasses.h
4215 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4216 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4217 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4218
4219
4220
4221
4222 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4223 {
4224 if (source == Py_None) {
4225 **obj = wxGBPosition(-1,-1);
4226 return true;
4227 }
4228 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4229 }
4230
4231 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4232 {
4233 if (source == Py_None) {
4234 **obj = wxGBSpan(-1,-1);
4235 return true;
4236 }
4237 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4238 }
4239
4240
4241 SWIGINTERN bool wxGBPosition___eq__(wxGBPosition *self,PyObject *other){
4242 wxGBPosition temp, *obj = &temp;
4243 if ( other == Py_None ) return false;
4244 if ( ! wxGBPosition_helper(other, &obj) ) {
4245 PyErr_Clear();
4246 return false;
4247 }
4248 return self->operator==(*obj);
4249 }
4250 SWIGINTERN bool wxGBPosition___ne__(wxGBPosition *self,PyObject *other){
4251 wxGBPosition temp, *obj = &temp;
4252 if ( other == Py_None ) return true;
4253 if ( ! wxGBPosition_helper(other, &obj)) {
4254 PyErr_Clear();
4255 return true;
4256 }
4257 return self->operator!=(*obj);
4258 }
4259 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4260 self->SetRow(row);
4261 self->SetCol(col);
4262 }
4263 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4264 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4265 PyObject* tup = PyTuple_New(2);
4266 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4267 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4268 wxPyEndBlockThreads(blocked);
4269 return tup;
4270 }
4271 SWIGINTERN bool wxGBSpan___eq__(wxGBSpan *self,PyObject *other){
4272 wxGBSpan temp, *obj = &temp;
4273 if ( other == Py_None ) return false;
4274 if ( ! wxGBSpan_helper(other, &obj) ) {
4275 PyErr_Clear();
4276 return false;
4277 }
4278 return self->operator==(*obj);
4279 }
4280 SWIGINTERN bool wxGBSpan___ne__(wxGBSpan *self,PyObject *other){
4281 wxGBSpan temp, *obj = &temp;
4282 if ( other == Py_None ) return true;
4283 if ( ! wxGBSpan_helper(other, &obj)) {
4284 PyErr_Clear();
4285 return true;
4286 }
4287 return self->operator!=(*obj);
4288 }
4289 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4290 self->SetRowspan(rowspan);
4291 self->SetColspan(colspan);
4292 }
4293 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4294 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4295 PyObject* tup = PyTuple_New(2);
4296 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4297 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4298 wxPyEndBlockThreads(blocked);
4299 return tup;
4300 }
4301 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4302 wxPyUserData* data = NULL;
4303 if ( userData ) {
4304 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4305 data = new wxPyUserData(userData);
4306 wxPyEndBlockThreads(blocked);
4307 }
4308 return new wxGBSizerItem(window, pos, span, flag, border, data);
4309 }
4310 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4311 wxPyUserData* data = NULL;
4312 if ( userData ) {
4313 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4314 data = new wxPyUserData(userData);
4315 wxPyEndBlockThreads(blocked);
4316 }
4317 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4318 }
4319 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4320 wxPyUserData* data = NULL;
4321 if ( userData ) {
4322 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4323 data = new wxPyUserData(userData);
4324 wxPyEndBlockThreads(blocked);
4325 }
4326 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4327 }
4328 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4329 int row, col;
4330 self->GetEndPos(row, col);
4331 return wxGBPosition(row, col);
4332 }
4333 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4334
4335 wxPyUserData* data = NULL;
4336 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4337 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4338 if ( userData && (info.window || info.sizer || info.gotSize) )
4339 data = new wxPyUserData(userData);
4340 if ( info.sizer )
4341 PyObject_SetAttrString(item,"thisown",Py_False);
4342 wxPyEndBlockThreads(blocked);
4343
4344 // Now call the real Add method if a valid item type was found
4345 if ( info.window )
4346 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4347 else if ( info.sizer )
4348 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4349 else if (info.gotSize)
4350 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4351 pos, span, flag, border, data);
4352 return NULL;
4353 }
4354
4355
4356 #ifdef __cplusplus
4357 extern "C" {
4358 #endif
4359 SWIGINTERN int EmptyString_set(PyObject *) {
4360 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4361 return 1;
4362 }
4363
4364
4365 SWIGINTERN PyObject *EmptyString_get(void) {
4366 PyObject *pyobj = 0;
4367
4368 {
4369 #if wxUSE_UNICODE
4370 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4371 #else
4372 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4373 #endif
4374 }
4375 return pyobj;
4376 }
4377
4378
4379 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4380 PyObject *resultobj = 0;
4381 wxObject *arg1 = (wxObject *) 0 ;
4382 wxString result;
4383 void *argp1 = 0 ;
4384 int res1 = 0 ;
4385 PyObject *swig_obj[1] ;
4386
4387 if (!args) SWIG_fail;
4388 swig_obj[0] = args;
4389 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4390 if (!SWIG_IsOK(res1)) {
4391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4392 }
4393 arg1 = reinterpret_cast< wxObject * >(argp1);
4394 {
4395 PyThreadState* __tstate = wxPyBeginAllowThreads();
4396 result = wxObject_GetClassName(arg1);
4397 wxPyEndAllowThreads(__tstate);
4398 if (PyErr_Occurred()) SWIG_fail;
4399 }
4400 {
4401 #if wxUSE_UNICODE
4402 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4403 #else
4404 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4405 #endif
4406 }
4407 return resultobj;
4408 fail:
4409 return NULL;
4410 }
4411
4412
4413 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4414 PyObject *resultobj = 0;
4415 wxObject *arg1 = (wxObject *) 0 ;
4416 void *argp1 = 0 ;
4417 int res1 = 0 ;
4418 PyObject *swig_obj[1] ;
4419
4420 if (!args) SWIG_fail;
4421 swig_obj[0] = args;
4422 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4423 if (!SWIG_IsOK(res1)) {
4424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4425 }
4426 arg1 = reinterpret_cast< wxObject * >(argp1);
4427 {
4428 PyThreadState* __tstate = wxPyBeginAllowThreads();
4429 wxObject_Destroy(arg1);
4430 wxPyEndAllowThreads(__tstate);
4431 if (PyErr_Occurred()) SWIG_fail;
4432 }
4433 resultobj = SWIG_Py_Void();
4434 return resultobj;
4435 fail:
4436 return NULL;
4437 }
4438
4439
4440 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4441 PyObject *obj;
4442 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4443 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4444 return SWIG_Py_Void();
4445 }
4446
4447 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4448 PyObject *resultobj = 0;
4449 wxSize *arg1 = (wxSize *) 0 ;
4450 int arg2 ;
4451 void *argp1 = 0 ;
4452 int res1 = 0 ;
4453 int val2 ;
4454 int ecode2 = 0 ;
4455 PyObject *swig_obj[2] ;
4456
4457 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4458 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4459 if (!SWIG_IsOK(res1)) {
4460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4461 }
4462 arg1 = reinterpret_cast< wxSize * >(argp1);
4463 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4464 if (!SWIG_IsOK(ecode2)) {
4465 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4466 }
4467 arg2 = static_cast< int >(val2);
4468 if (arg1) (arg1)->x = arg2;
4469
4470 resultobj = SWIG_Py_Void();
4471 return resultobj;
4472 fail:
4473 return NULL;
4474 }
4475
4476
4477 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4478 PyObject *resultobj = 0;
4479 wxSize *arg1 = (wxSize *) 0 ;
4480 int result;
4481 void *argp1 = 0 ;
4482 int res1 = 0 ;
4483 PyObject *swig_obj[1] ;
4484
4485 if (!args) SWIG_fail;
4486 swig_obj[0] = args;
4487 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4488 if (!SWIG_IsOK(res1)) {
4489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4490 }
4491 arg1 = reinterpret_cast< wxSize * >(argp1);
4492 result = (int) ((arg1)->x);
4493 resultobj = SWIG_From_int(static_cast< int >(result));
4494 return resultobj;
4495 fail:
4496 return NULL;
4497 }
4498
4499
4500 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4501 PyObject *resultobj = 0;
4502 wxSize *arg1 = (wxSize *) 0 ;
4503 int arg2 ;
4504 void *argp1 = 0 ;
4505 int res1 = 0 ;
4506 int val2 ;
4507 int ecode2 = 0 ;
4508 PyObject *swig_obj[2] ;
4509
4510 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4511 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4512 if (!SWIG_IsOK(res1)) {
4513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4514 }
4515 arg1 = reinterpret_cast< wxSize * >(argp1);
4516 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4517 if (!SWIG_IsOK(ecode2)) {
4518 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4519 }
4520 arg2 = static_cast< int >(val2);
4521 if (arg1) (arg1)->y = arg2;
4522
4523 resultobj = SWIG_Py_Void();
4524 return resultobj;
4525 fail:
4526 return NULL;
4527 }
4528
4529
4530 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4531 PyObject *resultobj = 0;
4532 wxSize *arg1 = (wxSize *) 0 ;
4533 int result;
4534 void *argp1 = 0 ;
4535 int res1 = 0 ;
4536 PyObject *swig_obj[1] ;
4537
4538 if (!args) SWIG_fail;
4539 swig_obj[0] = args;
4540 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4541 if (!SWIG_IsOK(res1)) {
4542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4543 }
4544 arg1 = reinterpret_cast< wxSize * >(argp1);
4545 result = (int) ((arg1)->y);
4546 resultobj = SWIG_From_int(static_cast< int >(result));
4547 return resultobj;
4548 fail:
4549 return NULL;
4550 }
4551
4552
4553 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4554 PyObject *resultobj = 0;
4555 int arg1 = (int) 0 ;
4556 int arg2 = (int) 0 ;
4557 wxSize *result = 0 ;
4558 int val1 ;
4559 int ecode1 = 0 ;
4560 int val2 ;
4561 int ecode2 = 0 ;
4562 PyObject * obj0 = 0 ;
4563 PyObject * obj1 = 0 ;
4564 char * kwnames[] = {
4565 (char *) "w",(char *) "h", NULL
4566 };
4567
4568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4569 if (obj0) {
4570 ecode1 = SWIG_AsVal_int(obj0, &val1);
4571 if (!SWIG_IsOK(ecode1)) {
4572 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4573 }
4574 arg1 = static_cast< int >(val1);
4575 }
4576 if (obj1) {
4577 ecode2 = SWIG_AsVal_int(obj1, &val2);
4578 if (!SWIG_IsOK(ecode2)) {
4579 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4580 }
4581 arg2 = static_cast< int >(val2);
4582 }
4583 {
4584 PyThreadState* __tstate = wxPyBeginAllowThreads();
4585 result = (wxSize *)new wxSize(arg1,arg2);
4586 wxPyEndAllowThreads(__tstate);
4587 if (PyErr_Occurred()) SWIG_fail;
4588 }
4589 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4590 return resultobj;
4591 fail:
4592 return NULL;
4593 }
4594
4595
4596 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4597 PyObject *resultobj = 0;
4598 wxSize *arg1 = (wxSize *) 0 ;
4599 void *argp1 = 0 ;
4600 int res1 = 0 ;
4601 PyObject *swig_obj[1] ;
4602
4603 if (!args) SWIG_fail;
4604 swig_obj[0] = args;
4605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4606 if (!SWIG_IsOK(res1)) {
4607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4608 }
4609 arg1 = reinterpret_cast< wxSize * >(argp1);
4610 {
4611 PyThreadState* __tstate = wxPyBeginAllowThreads();
4612 delete arg1;
4613
4614 wxPyEndAllowThreads(__tstate);
4615 if (PyErr_Occurred()) SWIG_fail;
4616 }
4617 resultobj = SWIG_Py_Void();
4618 return resultobj;
4619 fail:
4620 return NULL;
4621 }
4622
4623
4624 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4625 PyObject *resultobj = 0;
4626 wxSize *arg1 = (wxSize *) 0 ;
4627 PyObject *arg2 = (PyObject *) 0 ;
4628 bool result;
4629 void *argp1 = 0 ;
4630 int res1 = 0 ;
4631 PyObject * obj0 = 0 ;
4632 PyObject * obj1 = 0 ;
4633 char * kwnames[] = {
4634 (char *) "self",(char *) "other", NULL
4635 };
4636
4637 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4638 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4639 if (!SWIG_IsOK(res1)) {
4640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4641 }
4642 arg1 = reinterpret_cast< wxSize * >(argp1);
4643 arg2 = obj1;
4644 {
4645 result = (bool)wxSize___eq__(arg1,arg2);
4646 if (PyErr_Occurred()) SWIG_fail;
4647 }
4648 {
4649 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4650 }
4651 return resultobj;
4652 fail:
4653 return NULL;
4654 }
4655
4656
4657 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4658 PyObject *resultobj = 0;
4659 wxSize *arg1 = (wxSize *) 0 ;
4660 PyObject *arg2 = (PyObject *) 0 ;
4661 bool result;
4662 void *argp1 = 0 ;
4663 int res1 = 0 ;
4664 PyObject * obj0 = 0 ;
4665 PyObject * obj1 = 0 ;
4666 char * kwnames[] = {
4667 (char *) "self",(char *) "other", NULL
4668 };
4669
4670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4671 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4672 if (!SWIG_IsOK(res1)) {
4673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4674 }
4675 arg1 = reinterpret_cast< wxSize * >(argp1);
4676 arg2 = obj1;
4677 {
4678 result = (bool)wxSize___ne__(arg1,arg2);
4679 if (PyErr_Occurred()) SWIG_fail;
4680 }
4681 {
4682 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4683 }
4684 return resultobj;
4685 fail:
4686 return NULL;
4687 }
4688
4689
4690 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4691 PyObject *resultobj = 0;
4692 wxSize *arg1 = (wxSize *) 0 ;
4693 wxSize *arg2 = 0 ;
4694 wxSize result;
4695 void *argp1 = 0 ;
4696 int res1 = 0 ;
4697 wxSize temp2 ;
4698 PyObject * obj0 = 0 ;
4699 PyObject * obj1 = 0 ;
4700 char * kwnames[] = {
4701 (char *) "self",(char *) "sz", NULL
4702 };
4703
4704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4705 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4706 if (!SWIG_IsOK(res1)) {
4707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4708 }
4709 arg1 = reinterpret_cast< wxSize * >(argp1);
4710 {
4711 arg2 = &temp2;
4712 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4713 }
4714 {
4715 PyThreadState* __tstate = wxPyBeginAllowThreads();
4716 result = (arg1)->operator +((wxSize const &)*arg2);
4717 wxPyEndAllowThreads(__tstate);
4718 if (PyErr_Occurred()) SWIG_fail;
4719 }
4720 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4721 return resultobj;
4722 fail:
4723 return NULL;
4724 }
4725
4726
4727 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4728 PyObject *resultobj = 0;
4729 wxSize *arg1 = (wxSize *) 0 ;
4730 wxSize *arg2 = 0 ;
4731 wxSize result;
4732 void *argp1 = 0 ;
4733 int res1 = 0 ;
4734 wxSize temp2 ;
4735 PyObject * obj0 = 0 ;
4736 PyObject * obj1 = 0 ;
4737 char * kwnames[] = {
4738 (char *) "self",(char *) "sz", NULL
4739 };
4740
4741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4743 if (!SWIG_IsOK(res1)) {
4744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4745 }
4746 arg1 = reinterpret_cast< wxSize * >(argp1);
4747 {
4748 arg2 = &temp2;
4749 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4750 }
4751 {
4752 PyThreadState* __tstate = wxPyBeginAllowThreads();
4753 result = (arg1)->operator -((wxSize const &)*arg2);
4754 wxPyEndAllowThreads(__tstate);
4755 if (PyErr_Occurred()) SWIG_fail;
4756 }
4757 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4758 return resultobj;
4759 fail:
4760 return NULL;
4761 }
4762
4763
4764 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4765 PyObject *resultobj = 0;
4766 wxSize *arg1 = (wxSize *) 0 ;
4767 wxSize *arg2 = 0 ;
4768 void *argp1 = 0 ;
4769 int res1 = 0 ;
4770 wxSize temp2 ;
4771 PyObject * obj0 = 0 ;
4772 PyObject * obj1 = 0 ;
4773 char * kwnames[] = {
4774 (char *) "self",(char *) "sz", NULL
4775 };
4776
4777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4778 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4779 if (!SWIG_IsOK(res1)) {
4780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4781 }
4782 arg1 = reinterpret_cast< wxSize * >(argp1);
4783 {
4784 arg2 = &temp2;
4785 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4786 }
4787 {
4788 PyThreadState* __tstate = wxPyBeginAllowThreads();
4789 (arg1)->IncTo((wxSize const &)*arg2);
4790 wxPyEndAllowThreads(__tstate);
4791 if (PyErr_Occurred()) SWIG_fail;
4792 }
4793 resultobj = SWIG_Py_Void();
4794 return resultobj;
4795 fail:
4796 return NULL;
4797 }
4798
4799
4800 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4801 PyObject *resultobj = 0;
4802 wxSize *arg1 = (wxSize *) 0 ;
4803 wxSize *arg2 = 0 ;
4804 void *argp1 = 0 ;
4805 int res1 = 0 ;
4806 wxSize temp2 ;
4807 PyObject * obj0 = 0 ;
4808 PyObject * obj1 = 0 ;
4809 char * kwnames[] = {
4810 (char *) "self",(char *) "sz", NULL
4811 };
4812
4813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
4814 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4815 if (!SWIG_IsOK(res1)) {
4816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
4817 }
4818 arg1 = reinterpret_cast< wxSize * >(argp1);
4819 {
4820 arg2 = &temp2;
4821 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4822 }
4823 {
4824 PyThreadState* __tstate = wxPyBeginAllowThreads();
4825 (arg1)->DecTo((wxSize const &)*arg2);
4826 wxPyEndAllowThreads(__tstate);
4827 if (PyErr_Occurred()) SWIG_fail;
4828 }
4829 resultobj = SWIG_Py_Void();
4830 return resultobj;
4831 fail:
4832 return NULL;
4833 }
4834
4835
4836 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4837 PyObject *resultobj = 0;
4838 wxSize *arg1 = (wxSize *) 0 ;
4839 int arg2 ;
4840 int arg3 ;
4841 void *argp1 = 0 ;
4842 int res1 = 0 ;
4843 int val2 ;
4844 int ecode2 = 0 ;
4845 int val3 ;
4846 int ecode3 = 0 ;
4847 PyObject * obj0 = 0 ;
4848 PyObject * obj1 = 0 ;
4849 PyObject * obj2 = 0 ;
4850 char * kwnames[] = {
4851 (char *) "self",(char *) "w",(char *) "h", NULL
4852 };
4853
4854 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4855 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4856 if (!SWIG_IsOK(res1)) {
4857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
4858 }
4859 arg1 = reinterpret_cast< wxSize * >(argp1);
4860 ecode2 = SWIG_AsVal_int(obj1, &val2);
4861 if (!SWIG_IsOK(ecode2)) {
4862 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
4863 }
4864 arg2 = static_cast< int >(val2);
4865 ecode3 = SWIG_AsVal_int(obj2, &val3);
4866 if (!SWIG_IsOK(ecode3)) {
4867 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
4868 }
4869 arg3 = static_cast< int >(val3);
4870 {
4871 PyThreadState* __tstate = wxPyBeginAllowThreads();
4872 (arg1)->Set(arg2,arg3);
4873 wxPyEndAllowThreads(__tstate);
4874 if (PyErr_Occurred()) SWIG_fail;
4875 }
4876 resultobj = SWIG_Py_Void();
4877 return resultobj;
4878 fail:
4879 return NULL;
4880 }
4881
4882
4883 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4884 PyObject *resultobj = 0;
4885 wxSize *arg1 = (wxSize *) 0 ;
4886 int arg2 ;
4887 void *argp1 = 0 ;
4888 int res1 = 0 ;
4889 int val2 ;
4890 int ecode2 = 0 ;
4891 PyObject * obj0 = 0 ;
4892 PyObject * obj1 = 0 ;
4893 char * kwnames[] = {
4894 (char *) "self",(char *) "w", NULL
4895 };
4896
4897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
4898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4899 if (!SWIG_IsOK(res1)) {
4900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
4901 }
4902 arg1 = reinterpret_cast< wxSize * >(argp1);
4903 ecode2 = SWIG_AsVal_int(obj1, &val2);
4904 if (!SWIG_IsOK(ecode2)) {
4905 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
4906 }
4907 arg2 = static_cast< int >(val2);
4908 {
4909 PyThreadState* __tstate = wxPyBeginAllowThreads();
4910 (arg1)->SetWidth(arg2);
4911 wxPyEndAllowThreads(__tstate);
4912 if (PyErr_Occurred()) SWIG_fail;
4913 }
4914 resultobj = SWIG_Py_Void();
4915 return resultobj;
4916 fail:
4917 return NULL;
4918 }
4919
4920
4921 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4922 PyObject *resultobj = 0;
4923 wxSize *arg1 = (wxSize *) 0 ;
4924 int arg2 ;
4925 void *argp1 = 0 ;
4926 int res1 = 0 ;
4927 int val2 ;
4928 int ecode2 = 0 ;
4929 PyObject * obj0 = 0 ;
4930 PyObject * obj1 = 0 ;
4931 char * kwnames[] = {
4932 (char *) "self",(char *) "h", NULL
4933 };
4934
4935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
4936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4937 if (!SWIG_IsOK(res1)) {
4938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
4939 }
4940 arg1 = reinterpret_cast< wxSize * >(argp1);
4941 ecode2 = SWIG_AsVal_int(obj1, &val2);
4942 if (!SWIG_IsOK(ecode2)) {
4943 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
4944 }
4945 arg2 = static_cast< int >(val2);
4946 {
4947 PyThreadState* __tstate = wxPyBeginAllowThreads();
4948 (arg1)->SetHeight(arg2);
4949 wxPyEndAllowThreads(__tstate);
4950 if (PyErr_Occurred()) SWIG_fail;
4951 }
4952 resultobj = SWIG_Py_Void();
4953 return resultobj;
4954 fail:
4955 return NULL;
4956 }
4957
4958
4959 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4960 PyObject *resultobj = 0;
4961 wxSize *arg1 = (wxSize *) 0 ;
4962 int result;
4963 void *argp1 = 0 ;
4964 int res1 = 0 ;
4965 PyObject *swig_obj[1] ;
4966
4967 if (!args) SWIG_fail;
4968 swig_obj[0] = args;
4969 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4970 if (!SWIG_IsOK(res1)) {
4971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
4972 }
4973 arg1 = reinterpret_cast< wxSize * >(argp1);
4974 {
4975 PyThreadState* __tstate = wxPyBeginAllowThreads();
4976 result = (int)((wxSize const *)arg1)->GetWidth();
4977 wxPyEndAllowThreads(__tstate);
4978 if (PyErr_Occurred()) SWIG_fail;
4979 }
4980 resultobj = SWIG_From_int(static_cast< int >(result));
4981 return resultobj;
4982 fail:
4983 return NULL;
4984 }
4985
4986
4987 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4988 PyObject *resultobj = 0;
4989 wxSize *arg1 = (wxSize *) 0 ;
4990 int result;
4991 void *argp1 = 0 ;
4992 int res1 = 0 ;
4993 PyObject *swig_obj[1] ;
4994
4995 if (!args) SWIG_fail;
4996 swig_obj[0] = args;
4997 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4998 if (!SWIG_IsOK(res1)) {
4999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
5000 }
5001 arg1 = reinterpret_cast< wxSize * >(argp1);
5002 {
5003 PyThreadState* __tstate = wxPyBeginAllowThreads();
5004 result = (int)((wxSize const *)arg1)->GetHeight();
5005 wxPyEndAllowThreads(__tstate);
5006 if (PyErr_Occurred()) SWIG_fail;
5007 }
5008 resultobj = SWIG_From_int(static_cast< int >(result));
5009 return resultobj;
5010 fail:
5011 return NULL;
5012 }
5013
5014
5015 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5016 PyObject *resultobj = 0;
5017 wxSize *arg1 = (wxSize *) 0 ;
5018 bool result;
5019 void *argp1 = 0 ;
5020 int res1 = 0 ;
5021 PyObject *swig_obj[1] ;
5022
5023 if (!args) SWIG_fail;
5024 swig_obj[0] = args;
5025 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5026 if (!SWIG_IsOK(res1)) {
5027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
5028 }
5029 arg1 = reinterpret_cast< wxSize * >(argp1);
5030 {
5031 PyThreadState* __tstate = wxPyBeginAllowThreads();
5032 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
5033 wxPyEndAllowThreads(__tstate);
5034 if (PyErr_Occurred()) SWIG_fail;
5035 }
5036 {
5037 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5038 }
5039 return resultobj;
5040 fail:
5041 return NULL;
5042 }
5043
5044
5045 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5046 PyObject *resultobj = 0;
5047 wxSize *arg1 = (wxSize *) 0 ;
5048 wxSize *arg2 = 0 ;
5049 void *argp1 = 0 ;
5050 int res1 = 0 ;
5051 wxSize temp2 ;
5052 PyObject * obj0 = 0 ;
5053 PyObject * obj1 = 0 ;
5054 char * kwnames[] = {
5055 (char *) "self",(char *) "size", NULL
5056 };
5057
5058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
5059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5060 if (!SWIG_IsOK(res1)) {
5061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
5062 }
5063 arg1 = reinterpret_cast< wxSize * >(argp1);
5064 {
5065 arg2 = &temp2;
5066 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5067 }
5068 {
5069 PyThreadState* __tstate = wxPyBeginAllowThreads();
5070 (arg1)->SetDefaults((wxSize const &)*arg2);
5071 wxPyEndAllowThreads(__tstate);
5072 if (PyErr_Occurred()) SWIG_fail;
5073 }
5074 resultobj = SWIG_Py_Void();
5075 return resultobj;
5076 fail:
5077 return NULL;
5078 }
5079
5080
5081 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5082 PyObject *resultobj = 0;
5083 wxSize *arg1 = (wxSize *) 0 ;
5084 PyObject *result = 0 ;
5085 void *argp1 = 0 ;
5086 int res1 = 0 ;
5087 PyObject *swig_obj[1] ;
5088
5089 if (!args) SWIG_fail;
5090 swig_obj[0] = args;
5091 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5092 if (!SWIG_IsOK(res1)) {
5093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
5094 }
5095 arg1 = reinterpret_cast< wxSize * >(argp1);
5096 {
5097 PyThreadState* __tstate = wxPyBeginAllowThreads();
5098 result = (PyObject *)wxSize_Get(arg1);
5099 wxPyEndAllowThreads(__tstate);
5100 if (PyErr_Occurred()) SWIG_fail;
5101 }
5102 resultobj = result;
5103 return resultobj;
5104 fail:
5105 return NULL;
5106 }
5107
5108
5109 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5110 PyObject *obj;
5111 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5112 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5113 return SWIG_Py_Void();
5114 }
5115
5116 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5117 return SWIG_Python_InitShadowInstance(args);
5118 }
5119
5120 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5121 PyObject *resultobj = 0;
5122 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5123 double arg2 ;
5124 void *argp1 = 0 ;
5125 int res1 = 0 ;
5126 double val2 ;
5127 int ecode2 = 0 ;
5128 PyObject *swig_obj[2] ;
5129
5130 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5132 if (!SWIG_IsOK(res1)) {
5133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5134 }
5135 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5136 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5137 if (!SWIG_IsOK(ecode2)) {
5138 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5139 }
5140 arg2 = static_cast< double >(val2);
5141 if (arg1) (arg1)->x = arg2;
5142
5143 resultobj = SWIG_Py_Void();
5144 return resultobj;
5145 fail:
5146 return NULL;
5147 }
5148
5149
5150 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5151 PyObject *resultobj = 0;
5152 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5153 double result;
5154 void *argp1 = 0 ;
5155 int res1 = 0 ;
5156 PyObject *swig_obj[1] ;
5157
5158 if (!args) SWIG_fail;
5159 swig_obj[0] = args;
5160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5161 if (!SWIG_IsOK(res1)) {
5162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5163 }
5164 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5165 result = (double) ((arg1)->x);
5166 resultobj = SWIG_From_double(static_cast< double >(result));
5167 return resultobj;
5168 fail:
5169 return NULL;
5170 }
5171
5172
5173 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5174 PyObject *resultobj = 0;
5175 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5176 double arg2 ;
5177 void *argp1 = 0 ;
5178 int res1 = 0 ;
5179 double val2 ;
5180 int ecode2 = 0 ;
5181 PyObject *swig_obj[2] ;
5182
5183 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5184 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5185 if (!SWIG_IsOK(res1)) {
5186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5187 }
5188 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5189 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5190 if (!SWIG_IsOK(ecode2)) {
5191 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5192 }
5193 arg2 = static_cast< double >(val2);
5194 if (arg1) (arg1)->y = arg2;
5195
5196 resultobj = SWIG_Py_Void();
5197 return resultobj;
5198 fail:
5199 return NULL;
5200 }
5201
5202
5203 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5204 PyObject *resultobj = 0;
5205 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5206 double result;
5207 void *argp1 = 0 ;
5208 int res1 = 0 ;
5209 PyObject *swig_obj[1] ;
5210
5211 if (!args) SWIG_fail;
5212 swig_obj[0] = args;
5213 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5214 if (!SWIG_IsOK(res1)) {
5215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5216 }
5217 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5218 result = (double) ((arg1)->y);
5219 resultobj = SWIG_From_double(static_cast< double >(result));
5220 return resultobj;
5221 fail:
5222 return NULL;
5223 }
5224
5225
5226 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5227 PyObject *resultobj = 0;
5228 double arg1 = (double) 0.0 ;
5229 double arg2 = (double) 0.0 ;
5230 wxRealPoint *result = 0 ;
5231 double val1 ;
5232 int ecode1 = 0 ;
5233 double val2 ;
5234 int ecode2 = 0 ;
5235 PyObject * obj0 = 0 ;
5236 PyObject * obj1 = 0 ;
5237 char * kwnames[] = {
5238 (char *) "x",(char *) "y", NULL
5239 };
5240
5241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5242 if (obj0) {
5243 ecode1 = SWIG_AsVal_double(obj0, &val1);
5244 if (!SWIG_IsOK(ecode1)) {
5245 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5246 }
5247 arg1 = static_cast< double >(val1);
5248 }
5249 if (obj1) {
5250 ecode2 = SWIG_AsVal_double(obj1, &val2);
5251 if (!SWIG_IsOK(ecode2)) {
5252 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5253 }
5254 arg2 = static_cast< double >(val2);
5255 }
5256 {
5257 PyThreadState* __tstate = wxPyBeginAllowThreads();
5258 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5259 wxPyEndAllowThreads(__tstate);
5260 if (PyErr_Occurred()) SWIG_fail;
5261 }
5262 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5263 return resultobj;
5264 fail:
5265 return NULL;
5266 }
5267
5268
5269 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5270 PyObject *resultobj = 0;
5271 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5272 void *argp1 = 0 ;
5273 int res1 = 0 ;
5274 PyObject *swig_obj[1] ;
5275
5276 if (!args) SWIG_fail;
5277 swig_obj[0] = args;
5278 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5279 if (!SWIG_IsOK(res1)) {
5280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5281 }
5282 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5283 {
5284 PyThreadState* __tstate = wxPyBeginAllowThreads();
5285 delete arg1;
5286
5287 wxPyEndAllowThreads(__tstate);
5288 if (PyErr_Occurred()) SWIG_fail;
5289 }
5290 resultobj = SWIG_Py_Void();
5291 return resultobj;
5292 fail:
5293 return NULL;
5294 }
5295
5296
5297 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5298 PyObject *resultobj = 0;
5299 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5300 PyObject *arg2 = (PyObject *) 0 ;
5301 bool result;
5302 void *argp1 = 0 ;
5303 int res1 = 0 ;
5304 PyObject * obj0 = 0 ;
5305 PyObject * obj1 = 0 ;
5306 char * kwnames[] = {
5307 (char *) "self",(char *) "other", NULL
5308 };
5309
5310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5311 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5312 if (!SWIG_IsOK(res1)) {
5313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5314 }
5315 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5316 arg2 = obj1;
5317 {
5318 result = (bool)wxRealPoint___eq__(arg1,arg2);
5319 if (PyErr_Occurred()) SWIG_fail;
5320 }
5321 {
5322 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5323 }
5324 return resultobj;
5325 fail:
5326 return NULL;
5327 }
5328
5329
5330 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5331 PyObject *resultobj = 0;
5332 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5333 PyObject *arg2 = (PyObject *) 0 ;
5334 bool result;
5335 void *argp1 = 0 ;
5336 int res1 = 0 ;
5337 PyObject * obj0 = 0 ;
5338 PyObject * obj1 = 0 ;
5339 char * kwnames[] = {
5340 (char *) "self",(char *) "other", NULL
5341 };
5342
5343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5344 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5345 if (!SWIG_IsOK(res1)) {
5346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5347 }
5348 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5349 arg2 = obj1;
5350 {
5351 result = (bool)wxRealPoint___ne__(arg1,arg2);
5352 if (PyErr_Occurred()) SWIG_fail;
5353 }
5354 {
5355 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5356 }
5357 return resultobj;
5358 fail:
5359 return NULL;
5360 }
5361
5362
5363 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5364 PyObject *resultobj = 0;
5365 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5366 wxRealPoint *arg2 = 0 ;
5367 wxRealPoint result;
5368 void *argp1 = 0 ;
5369 int res1 = 0 ;
5370 wxRealPoint temp2 ;
5371 PyObject * obj0 = 0 ;
5372 PyObject * obj1 = 0 ;
5373 char * kwnames[] = {
5374 (char *) "self",(char *) "pt", NULL
5375 };
5376
5377 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5378 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5379 if (!SWIG_IsOK(res1)) {
5380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5381 }
5382 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5383 {
5384 arg2 = &temp2;
5385 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5386 }
5387 {
5388 PyThreadState* __tstate = wxPyBeginAllowThreads();
5389 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5390 wxPyEndAllowThreads(__tstate);
5391 if (PyErr_Occurred()) SWIG_fail;
5392 }
5393 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5394 return resultobj;
5395 fail:
5396 return NULL;
5397 }
5398
5399
5400 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5401 PyObject *resultobj = 0;
5402 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5403 wxRealPoint *arg2 = 0 ;
5404 wxRealPoint result;
5405 void *argp1 = 0 ;
5406 int res1 = 0 ;
5407 wxRealPoint temp2 ;
5408 PyObject * obj0 = 0 ;
5409 PyObject * obj1 = 0 ;
5410 char * kwnames[] = {
5411 (char *) "self",(char *) "pt", NULL
5412 };
5413
5414 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5415 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5416 if (!SWIG_IsOK(res1)) {
5417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5418 }
5419 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5420 {
5421 arg2 = &temp2;
5422 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5423 }
5424 {
5425 PyThreadState* __tstate = wxPyBeginAllowThreads();
5426 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5427 wxPyEndAllowThreads(__tstate);
5428 if (PyErr_Occurred()) SWIG_fail;
5429 }
5430 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5431 return resultobj;
5432 fail:
5433 return NULL;
5434 }
5435
5436
5437 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5438 PyObject *resultobj = 0;
5439 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5440 double arg2 ;
5441 double arg3 ;
5442 void *argp1 = 0 ;
5443 int res1 = 0 ;
5444 double val2 ;
5445 int ecode2 = 0 ;
5446 double val3 ;
5447 int ecode3 = 0 ;
5448 PyObject * obj0 = 0 ;
5449 PyObject * obj1 = 0 ;
5450 PyObject * obj2 = 0 ;
5451 char * kwnames[] = {
5452 (char *) "self",(char *) "x",(char *) "y", NULL
5453 };
5454
5455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5456 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5457 if (!SWIG_IsOK(res1)) {
5458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5459 }
5460 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5461 ecode2 = SWIG_AsVal_double(obj1, &val2);
5462 if (!SWIG_IsOK(ecode2)) {
5463 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5464 }
5465 arg2 = static_cast< double >(val2);
5466 ecode3 = SWIG_AsVal_double(obj2, &val3);
5467 if (!SWIG_IsOK(ecode3)) {
5468 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5469 }
5470 arg3 = static_cast< double >(val3);
5471 {
5472 PyThreadState* __tstate = wxPyBeginAllowThreads();
5473 wxRealPoint_Set(arg1,arg2,arg3);
5474 wxPyEndAllowThreads(__tstate);
5475 if (PyErr_Occurred()) SWIG_fail;
5476 }
5477 resultobj = SWIG_Py_Void();
5478 return resultobj;
5479 fail:
5480 return NULL;
5481 }
5482
5483
5484 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5485 PyObject *resultobj = 0;
5486 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5487 PyObject *result = 0 ;
5488 void *argp1 = 0 ;
5489 int res1 = 0 ;
5490 PyObject *swig_obj[1] ;
5491
5492 if (!args) SWIG_fail;
5493 swig_obj[0] = args;
5494 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5495 if (!SWIG_IsOK(res1)) {
5496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5497 }
5498 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5499 {
5500 PyThreadState* __tstate = wxPyBeginAllowThreads();
5501 result = (PyObject *)wxRealPoint_Get(arg1);
5502 wxPyEndAllowThreads(__tstate);
5503 if (PyErr_Occurred()) SWIG_fail;
5504 }
5505 resultobj = result;
5506 return resultobj;
5507 fail:
5508 return NULL;
5509 }
5510
5511
5512 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5513 PyObject *obj;
5514 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5515 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5516 return SWIG_Py_Void();
5517 }
5518
5519 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5520 return SWIG_Python_InitShadowInstance(args);
5521 }
5522
5523 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5524 PyObject *resultobj = 0;
5525 wxPoint *arg1 = (wxPoint *) 0 ;
5526 int arg2 ;
5527 void *argp1 = 0 ;
5528 int res1 = 0 ;
5529 int val2 ;
5530 int ecode2 = 0 ;
5531 PyObject *swig_obj[2] ;
5532
5533 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5535 if (!SWIG_IsOK(res1)) {
5536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5537 }
5538 arg1 = reinterpret_cast< wxPoint * >(argp1);
5539 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5540 if (!SWIG_IsOK(ecode2)) {
5541 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5542 }
5543 arg2 = static_cast< int >(val2);
5544 if (arg1) (arg1)->x = arg2;
5545
5546 resultobj = SWIG_Py_Void();
5547 return resultobj;
5548 fail:
5549 return NULL;
5550 }
5551
5552
5553 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5554 PyObject *resultobj = 0;
5555 wxPoint *arg1 = (wxPoint *) 0 ;
5556 int result;
5557 void *argp1 = 0 ;
5558 int res1 = 0 ;
5559 PyObject *swig_obj[1] ;
5560
5561 if (!args) SWIG_fail;
5562 swig_obj[0] = args;
5563 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5564 if (!SWIG_IsOK(res1)) {
5565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5566 }
5567 arg1 = reinterpret_cast< wxPoint * >(argp1);
5568 result = (int) ((arg1)->x);
5569 resultobj = SWIG_From_int(static_cast< int >(result));
5570 return resultobj;
5571 fail:
5572 return NULL;
5573 }
5574
5575
5576 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5577 PyObject *resultobj = 0;
5578 wxPoint *arg1 = (wxPoint *) 0 ;
5579 int arg2 ;
5580 void *argp1 = 0 ;
5581 int res1 = 0 ;
5582 int val2 ;
5583 int ecode2 = 0 ;
5584 PyObject *swig_obj[2] ;
5585
5586 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5587 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5588 if (!SWIG_IsOK(res1)) {
5589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5590 }
5591 arg1 = reinterpret_cast< wxPoint * >(argp1);
5592 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5593 if (!SWIG_IsOK(ecode2)) {
5594 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5595 }
5596 arg2 = static_cast< int >(val2);
5597 if (arg1) (arg1)->y = arg2;
5598
5599 resultobj = SWIG_Py_Void();
5600 return resultobj;
5601 fail:
5602 return NULL;
5603 }
5604
5605
5606 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5607 PyObject *resultobj = 0;
5608 wxPoint *arg1 = (wxPoint *) 0 ;
5609 int result;
5610 void *argp1 = 0 ;
5611 int res1 = 0 ;
5612 PyObject *swig_obj[1] ;
5613
5614 if (!args) SWIG_fail;
5615 swig_obj[0] = args;
5616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5617 if (!SWIG_IsOK(res1)) {
5618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5619 }
5620 arg1 = reinterpret_cast< wxPoint * >(argp1);
5621 result = (int) ((arg1)->y);
5622 resultobj = SWIG_From_int(static_cast< int >(result));
5623 return resultobj;
5624 fail:
5625 return NULL;
5626 }
5627
5628
5629 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5630 PyObject *resultobj = 0;
5631 int arg1 = (int) 0 ;
5632 int arg2 = (int) 0 ;
5633 wxPoint *result = 0 ;
5634 int val1 ;
5635 int ecode1 = 0 ;
5636 int val2 ;
5637 int ecode2 = 0 ;
5638 PyObject * obj0 = 0 ;
5639 PyObject * obj1 = 0 ;
5640 char * kwnames[] = {
5641 (char *) "x",(char *) "y", NULL
5642 };
5643
5644 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5645 if (obj0) {
5646 ecode1 = SWIG_AsVal_int(obj0, &val1);
5647 if (!SWIG_IsOK(ecode1)) {
5648 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5649 }
5650 arg1 = static_cast< int >(val1);
5651 }
5652 if (obj1) {
5653 ecode2 = SWIG_AsVal_int(obj1, &val2);
5654 if (!SWIG_IsOK(ecode2)) {
5655 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5656 }
5657 arg2 = static_cast< int >(val2);
5658 }
5659 {
5660 PyThreadState* __tstate = wxPyBeginAllowThreads();
5661 result = (wxPoint *)new wxPoint(arg1,arg2);
5662 wxPyEndAllowThreads(__tstate);
5663 if (PyErr_Occurred()) SWIG_fail;
5664 }
5665 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5666 return resultobj;
5667 fail:
5668 return NULL;
5669 }
5670
5671
5672 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5673 PyObject *resultobj = 0;
5674 wxPoint *arg1 = (wxPoint *) 0 ;
5675 void *argp1 = 0 ;
5676 int res1 = 0 ;
5677 PyObject *swig_obj[1] ;
5678
5679 if (!args) SWIG_fail;
5680 swig_obj[0] = args;
5681 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5682 if (!SWIG_IsOK(res1)) {
5683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5684 }
5685 arg1 = reinterpret_cast< wxPoint * >(argp1);
5686 {
5687 PyThreadState* __tstate = wxPyBeginAllowThreads();
5688 delete arg1;
5689
5690 wxPyEndAllowThreads(__tstate);
5691 if (PyErr_Occurred()) SWIG_fail;
5692 }
5693 resultobj = SWIG_Py_Void();
5694 return resultobj;
5695 fail:
5696 return NULL;
5697 }
5698
5699
5700 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5701 PyObject *resultobj = 0;
5702 wxPoint *arg1 = (wxPoint *) 0 ;
5703 PyObject *arg2 = (PyObject *) 0 ;
5704 bool result;
5705 void *argp1 = 0 ;
5706 int res1 = 0 ;
5707 PyObject * obj0 = 0 ;
5708 PyObject * obj1 = 0 ;
5709 char * kwnames[] = {
5710 (char *) "self",(char *) "other", NULL
5711 };
5712
5713 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5714 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5715 if (!SWIG_IsOK(res1)) {
5716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
5717 }
5718 arg1 = reinterpret_cast< wxPoint * >(argp1);
5719 arg2 = obj1;
5720 {
5721 result = (bool)wxPoint___eq__(arg1,arg2);
5722 if (PyErr_Occurred()) SWIG_fail;
5723 }
5724 {
5725 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5726 }
5727 return resultobj;
5728 fail:
5729 return NULL;
5730 }
5731
5732
5733 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5734 PyObject *resultobj = 0;
5735 wxPoint *arg1 = (wxPoint *) 0 ;
5736 PyObject *arg2 = (PyObject *) 0 ;
5737 bool result;
5738 void *argp1 = 0 ;
5739 int res1 = 0 ;
5740 PyObject * obj0 = 0 ;
5741 PyObject * obj1 = 0 ;
5742 char * kwnames[] = {
5743 (char *) "self",(char *) "other", NULL
5744 };
5745
5746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5747 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5748 if (!SWIG_IsOK(res1)) {
5749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
5750 }
5751 arg1 = reinterpret_cast< wxPoint * >(argp1);
5752 arg2 = obj1;
5753 {
5754 result = (bool)wxPoint___ne__(arg1,arg2);
5755 if (PyErr_Occurred()) SWIG_fail;
5756 }
5757 {
5758 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5759 }
5760 return resultobj;
5761 fail:
5762 return NULL;
5763 }
5764
5765
5766 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5767 PyObject *resultobj = 0;
5768 wxPoint *arg1 = (wxPoint *) 0 ;
5769 wxPoint *arg2 = 0 ;
5770 wxPoint result;
5771 void *argp1 = 0 ;
5772 int res1 = 0 ;
5773 wxPoint temp2 ;
5774 PyObject * obj0 = 0 ;
5775 PyObject * obj1 = 0 ;
5776 char * kwnames[] = {
5777 (char *) "self",(char *) "pt", NULL
5778 };
5779
5780 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5781 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5782 if (!SWIG_IsOK(res1)) {
5783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
5784 }
5785 arg1 = reinterpret_cast< wxPoint * >(argp1);
5786 {
5787 arg2 = &temp2;
5788 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5789 }
5790 {
5791 PyThreadState* __tstate = wxPyBeginAllowThreads();
5792 result = (arg1)->operator +((wxPoint const &)*arg2);
5793 wxPyEndAllowThreads(__tstate);
5794 if (PyErr_Occurred()) SWIG_fail;
5795 }
5796 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5797 return resultobj;
5798 fail:
5799 return NULL;
5800 }
5801
5802
5803 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5804 PyObject *resultobj = 0;
5805 wxPoint *arg1 = (wxPoint *) 0 ;
5806 wxPoint *arg2 = 0 ;
5807 wxPoint result;
5808 void *argp1 = 0 ;
5809 int res1 = 0 ;
5810 wxPoint temp2 ;
5811 PyObject * obj0 = 0 ;
5812 PyObject * obj1 = 0 ;
5813 char * kwnames[] = {
5814 (char *) "self",(char *) "pt", NULL
5815 };
5816
5817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5818 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5819 if (!SWIG_IsOK(res1)) {
5820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5821 }
5822 arg1 = reinterpret_cast< wxPoint * >(argp1);
5823 {
5824 arg2 = &temp2;
5825 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5826 }
5827 {
5828 PyThreadState* __tstate = wxPyBeginAllowThreads();
5829 result = (arg1)->operator -((wxPoint const &)*arg2);
5830 wxPyEndAllowThreads(__tstate);
5831 if (PyErr_Occurred()) SWIG_fail;
5832 }
5833 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5834 return resultobj;
5835 fail:
5836 return NULL;
5837 }
5838
5839
5840 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5841 PyObject *resultobj = 0;
5842 wxPoint *arg1 = (wxPoint *) 0 ;
5843 wxPoint *arg2 = 0 ;
5844 wxPoint *result = 0 ;
5845 void *argp1 = 0 ;
5846 int res1 = 0 ;
5847 wxPoint temp2 ;
5848 PyObject * obj0 = 0 ;
5849 PyObject * obj1 = 0 ;
5850 char * kwnames[] = {
5851 (char *) "self",(char *) "pt", NULL
5852 };
5853
5854 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
5855 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5856 if (!SWIG_IsOK(res1)) {
5857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
5858 }
5859 arg1 = reinterpret_cast< wxPoint * >(argp1);
5860 {
5861 arg2 = &temp2;
5862 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5863 }
5864 {
5865 PyThreadState* __tstate = wxPyBeginAllowThreads();
5866 {
5867 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
5868 result = (wxPoint *) &_result_ref;
5869 }
5870 wxPyEndAllowThreads(__tstate);
5871 if (PyErr_Occurred()) SWIG_fail;
5872 }
5873 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5874 return resultobj;
5875 fail:
5876 return NULL;
5877 }
5878
5879
5880 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5881 PyObject *resultobj = 0;
5882 wxPoint *arg1 = (wxPoint *) 0 ;
5883 wxPoint *arg2 = 0 ;
5884 wxPoint *result = 0 ;
5885 void *argp1 = 0 ;
5886 int res1 = 0 ;
5887 wxPoint temp2 ;
5888 PyObject * obj0 = 0 ;
5889 PyObject * obj1 = 0 ;
5890 char * kwnames[] = {
5891 (char *) "self",(char *) "pt", NULL
5892 };
5893
5894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
5895 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5896 if (!SWIG_IsOK(res1)) {
5897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5898 }
5899 arg1 = reinterpret_cast< wxPoint * >(argp1);
5900 {
5901 arg2 = &temp2;
5902 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5903 }
5904 {
5905 PyThreadState* __tstate = wxPyBeginAllowThreads();
5906 {
5907 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
5908 result = (wxPoint *) &_result_ref;
5909 }
5910 wxPyEndAllowThreads(__tstate);
5911 if (PyErr_Occurred()) SWIG_fail;
5912 }
5913 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5914 return resultobj;
5915 fail:
5916 return NULL;
5917 }
5918
5919
5920 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5921 PyObject *resultobj = 0;
5922 wxPoint *arg1 = (wxPoint *) 0 ;
5923 long arg2 ;
5924 long arg3 ;
5925 void *argp1 = 0 ;
5926 int res1 = 0 ;
5927 long val2 ;
5928 int ecode2 = 0 ;
5929 long val3 ;
5930 int ecode3 = 0 ;
5931 PyObject * obj0 = 0 ;
5932 PyObject * obj1 = 0 ;
5933 PyObject * obj2 = 0 ;
5934 char * kwnames[] = {
5935 (char *) "self",(char *) "x",(char *) "y", NULL
5936 };
5937
5938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5939 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5940 if (!SWIG_IsOK(res1)) {
5941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
5942 }
5943 arg1 = reinterpret_cast< wxPoint * >(argp1);
5944 ecode2 = SWIG_AsVal_long(obj1, &val2);
5945 if (!SWIG_IsOK(ecode2)) {
5946 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
5947 }
5948 arg2 = static_cast< long >(val2);
5949 ecode3 = SWIG_AsVal_long(obj2, &val3);
5950 if (!SWIG_IsOK(ecode3)) {
5951 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
5952 }
5953 arg3 = static_cast< long >(val3);
5954 {
5955 PyThreadState* __tstate = wxPyBeginAllowThreads();
5956 wxPoint_Set(arg1,arg2,arg3);
5957 wxPyEndAllowThreads(__tstate);
5958 if (PyErr_Occurred()) SWIG_fail;
5959 }
5960 resultobj = SWIG_Py_Void();
5961 return resultobj;
5962 fail:
5963 return NULL;
5964 }
5965
5966
5967 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5968 PyObject *resultobj = 0;
5969 wxPoint *arg1 = (wxPoint *) 0 ;
5970 PyObject *result = 0 ;
5971 void *argp1 = 0 ;
5972 int res1 = 0 ;
5973 PyObject *swig_obj[1] ;
5974
5975 if (!args) SWIG_fail;
5976 swig_obj[0] = args;
5977 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5978 if (!SWIG_IsOK(res1)) {
5979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
5980 }
5981 arg1 = reinterpret_cast< wxPoint * >(argp1);
5982 {
5983 PyThreadState* __tstate = wxPyBeginAllowThreads();
5984 result = (PyObject *)wxPoint_Get(arg1);
5985 wxPyEndAllowThreads(__tstate);
5986 if (PyErr_Occurred()) SWIG_fail;
5987 }
5988 resultobj = result;
5989 return resultobj;
5990 fail:
5991 return NULL;
5992 }
5993
5994
5995 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5996 PyObject *obj;
5997 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5998 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
5999 return SWIG_Py_Void();
6000 }
6001
6002 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6003 return SWIG_Python_InitShadowInstance(args);
6004 }
6005
6006 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6007 PyObject *resultobj = 0;
6008 int arg1 = (int) 0 ;
6009 int arg2 = (int) 0 ;
6010 int arg3 = (int) 0 ;
6011 int arg4 = (int) 0 ;
6012 wxRect *result = 0 ;
6013 int val1 ;
6014 int ecode1 = 0 ;
6015 int val2 ;
6016 int ecode2 = 0 ;
6017 int val3 ;
6018 int ecode3 = 0 ;
6019 int val4 ;
6020 int ecode4 = 0 ;
6021 PyObject * obj0 = 0 ;
6022 PyObject * obj1 = 0 ;
6023 PyObject * obj2 = 0 ;
6024 PyObject * obj3 = 0 ;
6025 char * kwnames[] = {
6026 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6027 };
6028
6029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6030 if (obj0) {
6031 ecode1 = SWIG_AsVal_int(obj0, &val1);
6032 if (!SWIG_IsOK(ecode1)) {
6033 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
6034 }
6035 arg1 = static_cast< int >(val1);
6036 }
6037 if (obj1) {
6038 ecode2 = SWIG_AsVal_int(obj1, &val2);
6039 if (!SWIG_IsOK(ecode2)) {
6040 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
6041 }
6042 arg2 = static_cast< int >(val2);
6043 }
6044 if (obj2) {
6045 ecode3 = SWIG_AsVal_int(obj2, &val3);
6046 if (!SWIG_IsOK(ecode3)) {
6047 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
6048 }
6049 arg3 = static_cast< int >(val3);
6050 }
6051 if (obj3) {
6052 ecode4 = SWIG_AsVal_int(obj3, &val4);
6053 if (!SWIG_IsOK(ecode4)) {
6054 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
6055 }
6056 arg4 = static_cast< int >(val4);
6057 }
6058 {
6059 PyThreadState* __tstate = wxPyBeginAllowThreads();
6060 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
6061 wxPyEndAllowThreads(__tstate);
6062 if (PyErr_Occurred()) SWIG_fail;
6063 }
6064 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
6065 return resultobj;
6066 fail:
6067 return NULL;
6068 }
6069
6070
6071 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6072 PyObject *resultobj = 0;
6073 wxPoint *arg1 = 0 ;
6074 wxPoint *arg2 = 0 ;
6075 wxRect *result = 0 ;
6076 wxPoint temp1 ;
6077 wxPoint temp2 ;
6078 PyObject * obj0 = 0 ;
6079 PyObject * obj1 = 0 ;
6080 char * kwnames[] = {
6081 (char *) "topLeft",(char *) "bottomRight", NULL
6082 };
6083
6084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
6085 {
6086 arg1 = &temp1;
6087 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6088 }
6089 {
6090 arg2 = &temp2;
6091 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6092 }
6093 {
6094 PyThreadState* __tstate = wxPyBeginAllowThreads();
6095 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6096 wxPyEndAllowThreads(__tstate);
6097 if (PyErr_Occurred()) SWIG_fail;
6098 }
6099 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6100 return resultobj;
6101 fail:
6102 return NULL;
6103 }
6104
6105
6106 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6107 PyObject *resultobj = 0;
6108 wxPoint *arg1 = 0 ;
6109 wxSize *arg2 = 0 ;
6110 wxRect *result = 0 ;
6111 wxPoint temp1 ;
6112 wxSize temp2 ;
6113 PyObject * obj0 = 0 ;
6114 PyObject * obj1 = 0 ;
6115 char * kwnames[] = {
6116 (char *) "pos",(char *) "size", NULL
6117 };
6118
6119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6120 {
6121 arg1 = &temp1;
6122 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6123 }
6124 {
6125 arg2 = &temp2;
6126 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6127 }
6128 {
6129 PyThreadState* __tstate = wxPyBeginAllowThreads();
6130 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6131 wxPyEndAllowThreads(__tstate);
6132 if (PyErr_Occurred()) SWIG_fail;
6133 }
6134 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6135 return resultobj;
6136 fail:
6137 return NULL;
6138 }
6139
6140
6141 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6142 PyObject *resultobj = 0;
6143 wxSize *arg1 = 0 ;
6144 wxRect *result = 0 ;
6145 wxSize temp1 ;
6146 PyObject * obj0 = 0 ;
6147 char * kwnames[] = {
6148 (char *) "size", NULL
6149 };
6150
6151 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6152 {
6153 arg1 = &temp1;
6154 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6155 }
6156 {
6157 PyThreadState* __tstate = wxPyBeginAllowThreads();
6158 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6159 wxPyEndAllowThreads(__tstate);
6160 if (PyErr_Occurred()) SWIG_fail;
6161 }
6162 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6163 return resultobj;
6164 fail:
6165 return NULL;
6166 }
6167
6168
6169 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6170 PyObject *resultobj = 0;
6171 wxRect *arg1 = (wxRect *) 0 ;
6172 void *argp1 = 0 ;
6173 int res1 = 0 ;
6174 PyObject *swig_obj[1] ;
6175
6176 if (!args) SWIG_fail;
6177 swig_obj[0] = args;
6178 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6179 if (!SWIG_IsOK(res1)) {
6180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6181 }
6182 arg1 = reinterpret_cast< wxRect * >(argp1);
6183 {
6184 PyThreadState* __tstate = wxPyBeginAllowThreads();
6185 delete arg1;
6186
6187 wxPyEndAllowThreads(__tstate);
6188 if (PyErr_Occurred()) SWIG_fail;
6189 }
6190 resultobj = SWIG_Py_Void();
6191 return resultobj;
6192 fail:
6193 return NULL;
6194 }
6195
6196
6197 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6198 PyObject *resultobj = 0;
6199 wxRect *arg1 = (wxRect *) 0 ;
6200 int result;
6201 void *argp1 = 0 ;
6202 int res1 = 0 ;
6203 PyObject *swig_obj[1] ;
6204
6205 if (!args) SWIG_fail;
6206 swig_obj[0] = args;
6207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6208 if (!SWIG_IsOK(res1)) {
6209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6210 }
6211 arg1 = reinterpret_cast< wxRect * >(argp1);
6212 {
6213 PyThreadState* __tstate = wxPyBeginAllowThreads();
6214 result = (int)((wxRect const *)arg1)->GetX();
6215 wxPyEndAllowThreads(__tstate);
6216 if (PyErr_Occurred()) SWIG_fail;
6217 }
6218 resultobj = SWIG_From_int(static_cast< int >(result));
6219 return resultobj;
6220 fail:
6221 return NULL;
6222 }
6223
6224
6225 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6226 PyObject *resultobj = 0;
6227 wxRect *arg1 = (wxRect *) 0 ;
6228 int arg2 ;
6229 void *argp1 = 0 ;
6230 int res1 = 0 ;
6231 int val2 ;
6232 int ecode2 = 0 ;
6233 PyObject * obj0 = 0 ;
6234 PyObject * obj1 = 0 ;
6235 char * kwnames[] = {
6236 (char *) "self",(char *) "x", NULL
6237 };
6238
6239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6240 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6241 if (!SWIG_IsOK(res1)) {
6242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6243 }
6244 arg1 = reinterpret_cast< wxRect * >(argp1);
6245 ecode2 = SWIG_AsVal_int(obj1, &val2);
6246 if (!SWIG_IsOK(ecode2)) {
6247 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6248 }
6249 arg2 = static_cast< int >(val2);
6250 {
6251 PyThreadState* __tstate = wxPyBeginAllowThreads();
6252 (arg1)->SetX(arg2);
6253 wxPyEndAllowThreads(__tstate);
6254 if (PyErr_Occurred()) SWIG_fail;
6255 }
6256 resultobj = SWIG_Py_Void();
6257 return resultobj;
6258 fail:
6259 return NULL;
6260 }
6261
6262
6263 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6264 PyObject *resultobj = 0;
6265 wxRect *arg1 = (wxRect *) 0 ;
6266 int result;
6267 void *argp1 = 0 ;
6268 int res1 = 0 ;
6269 PyObject *swig_obj[1] ;
6270
6271 if (!args) SWIG_fail;
6272 swig_obj[0] = args;
6273 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6274 if (!SWIG_IsOK(res1)) {
6275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6276 }
6277 arg1 = reinterpret_cast< wxRect * >(argp1);
6278 {
6279 PyThreadState* __tstate = wxPyBeginAllowThreads();
6280 result = (int)(arg1)->GetY();
6281 wxPyEndAllowThreads(__tstate);
6282 if (PyErr_Occurred()) SWIG_fail;
6283 }
6284 resultobj = SWIG_From_int(static_cast< int >(result));
6285 return resultobj;
6286 fail:
6287 return NULL;
6288 }
6289
6290
6291 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6292 PyObject *resultobj = 0;
6293 wxRect *arg1 = (wxRect *) 0 ;
6294 int arg2 ;
6295 void *argp1 = 0 ;
6296 int res1 = 0 ;
6297 int val2 ;
6298 int ecode2 = 0 ;
6299 PyObject * obj0 = 0 ;
6300 PyObject * obj1 = 0 ;
6301 char * kwnames[] = {
6302 (char *) "self",(char *) "y", NULL
6303 };
6304
6305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6306 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6307 if (!SWIG_IsOK(res1)) {
6308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6309 }
6310 arg1 = reinterpret_cast< wxRect * >(argp1);
6311 ecode2 = SWIG_AsVal_int(obj1, &val2);
6312 if (!SWIG_IsOK(ecode2)) {
6313 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6314 }
6315 arg2 = static_cast< int >(val2);
6316 {
6317 PyThreadState* __tstate = wxPyBeginAllowThreads();
6318 (arg1)->SetY(arg2);
6319 wxPyEndAllowThreads(__tstate);
6320 if (PyErr_Occurred()) SWIG_fail;
6321 }
6322 resultobj = SWIG_Py_Void();
6323 return resultobj;
6324 fail:
6325 return NULL;
6326 }
6327
6328
6329 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6330 PyObject *resultobj = 0;
6331 wxRect *arg1 = (wxRect *) 0 ;
6332 int result;
6333 void *argp1 = 0 ;
6334 int res1 = 0 ;
6335 PyObject *swig_obj[1] ;
6336
6337 if (!args) SWIG_fail;
6338 swig_obj[0] = args;
6339 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6340 if (!SWIG_IsOK(res1)) {
6341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6342 }
6343 arg1 = reinterpret_cast< wxRect * >(argp1);
6344 {
6345 PyThreadState* __tstate = wxPyBeginAllowThreads();
6346 result = (int)((wxRect const *)arg1)->GetWidth();
6347 wxPyEndAllowThreads(__tstate);
6348 if (PyErr_Occurred()) SWIG_fail;
6349 }
6350 resultobj = SWIG_From_int(static_cast< int >(result));
6351 return resultobj;
6352 fail:
6353 return NULL;
6354 }
6355
6356
6357 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6358 PyObject *resultobj = 0;
6359 wxRect *arg1 = (wxRect *) 0 ;
6360 int arg2 ;
6361 void *argp1 = 0 ;
6362 int res1 = 0 ;
6363 int val2 ;
6364 int ecode2 = 0 ;
6365 PyObject * obj0 = 0 ;
6366 PyObject * obj1 = 0 ;
6367 char * kwnames[] = {
6368 (char *) "self",(char *) "w", NULL
6369 };
6370
6371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6372 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6373 if (!SWIG_IsOK(res1)) {
6374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6375 }
6376 arg1 = reinterpret_cast< wxRect * >(argp1);
6377 ecode2 = SWIG_AsVal_int(obj1, &val2);
6378 if (!SWIG_IsOK(ecode2)) {
6379 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6380 }
6381 arg2 = static_cast< int >(val2);
6382 {
6383 PyThreadState* __tstate = wxPyBeginAllowThreads();
6384 (arg1)->SetWidth(arg2);
6385 wxPyEndAllowThreads(__tstate);
6386 if (PyErr_Occurred()) SWIG_fail;
6387 }
6388 resultobj = SWIG_Py_Void();
6389 return resultobj;
6390 fail:
6391 return NULL;
6392 }
6393
6394
6395 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6396 PyObject *resultobj = 0;
6397 wxRect *arg1 = (wxRect *) 0 ;
6398 int result;
6399 void *argp1 = 0 ;
6400 int res1 = 0 ;
6401 PyObject *swig_obj[1] ;
6402
6403 if (!args) SWIG_fail;
6404 swig_obj[0] = args;
6405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6406 if (!SWIG_IsOK(res1)) {
6407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6408 }
6409 arg1 = reinterpret_cast< wxRect * >(argp1);
6410 {
6411 PyThreadState* __tstate = wxPyBeginAllowThreads();
6412 result = (int)((wxRect const *)arg1)->GetHeight();
6413 wxPyEndAllowThreads(__tstate);
6414 if (PyErr_Occurred()) SWIG_fail;
6415 }
6416 resultobj = SWIG_From_int(static_cast< int >(result));
6417 return resultobj;
6418 fail:
6419 return NULL;
6420 }
6421
6422
6423 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6424 PyObject *resultobj = 0;
6425 wxRect *arg1 = (wxRect *) 0 ;
6426 int arg2 ;
6427 void *argp1 = 0 ;
6428 int res1 = 0 ;
6429 int val2 ;
6430 int ecode2 = 0 ;
6431 PyObject * obj0 = 0 ;
6432 PyObject * obj1 = 0 ;
6433 char * kwnames[] = {
6434 (char *) "self",(char *) "h", NULL
6435 };
6436
6437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6438 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6439 if (!SWIG_IsOK(res1)) {
6440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6441 }
6442 arg1 = reinterpret_cast< wxRect * >(argp1);
6443 ecode2 = SWIG_AsVal_int(obj1, &val2);
6444 if (!SWIG_IsOK(ecode2)) {
6445 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6446 }
6447 arg2 = static_cast< int >(val2);
6448 {
6449 PyThreadState* __tstate = wxPyBeginAllowThreads();
6450 (arg1)->SetHeight(arg2);
6451 wxPyEndAllowThreads(__tstate);
6452 if (PyErr_Occurred()) SWIG_fail;
6453 }
6454 resultobj = SWIG_Py_Void();
6455 return resultobj;
6456 fail:
6457 return NULL;
6458 }
6459
6460
6461 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6462 PyObject *resultobj = 0;
6463 wxRect *arg1 = (wxRect *) 0 ;
6464 wxPoint result;
6465 void *argp1 = 0 ;
6466 int res1 = 0 ;
6467 PyObject *swig_obj[1] ;
6468
6469 if (!args) SWIG_fail;
6470 swig_obj[0] = args;
6471 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6472 if (!SWIG_IsOK(res1)) {
6473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6474 }
6475 arg1 = reinterpret_cast< wxRect * >(argp1);
6476 {
6477 PyThreadState* __tstate = wxPyBeginAllowThreads();
6478 result = ((wxRect const *)arg1)->GetPosition();
6479 wxPyEndAllowThreads(__tstate);
6480 if (PyErr_Occurred()) SWIG_fail;
6481 }
6482 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6483 return resultobj;
6484 fail:
6485 return NULL;
6486 }
6487
6488
6489 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6490 PyObject *resultobj = 0;
6491 wxRect *arg1 = (wxRect *) 0 ;
6492 wxPoint *arg2 = 0 ;
6493 void *argp1 = 0 ;
6494 int res1 = 0 ;
6495 wxPoint temp2 ;
6496 PyObject * obj0 = 0 ;
6497 PyObject * obj1 = 0 ;
6498 char * kwnames[] = {
6499 (char *) "self",(char *) "p", NULL
6500 };
6501
6502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6503 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6504 if (!SWIG_IsOK(res1)) {
6505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6506 }
6507 arg1 = reinterpret_cast< wxRect * >(argp1);
6508 {
6509 arg2 = &temp2;
6510 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6511 }
6512 {
6513 PyThreadState* __tstate = wxPyBeginAllowThreads();
6514 (arg1)->SetPosition((wxPoint const &)*arg2);
6515 wxPyEndAllowThreads(__tstate);
6516 if (PyErr_Occurred()) SWIG_fail;
6517 }
6518 resultobj = SWIG_Py_Void();
6519 return resultobj;
6520 fail:
6521 return NULL;
6522 }
6523
6524
6525 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6526 PyObject *resultobj = 0;
6527 wxRect *arg1 = (wxRect *) 0 ;
6528 wxSize result;
6529 void *argp1 = 0 ;
6530 int res1 = 0 ;
6531 PyObject *swig_obj[1] ;
6532
6533 if (!args) SWIG_fail;
6534 swig_obj[0] = args;
6535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6536 if (!SWIG_IsOK(res1)) {
6537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6538 }
6539 arg1 = reinterpret_cast< wxRect * >(argp1);
6540 {
6541 PyThreadState* __tstate = wxPyBeginAllowThreads();
6542 result = ((wxRect const *)arg1)->GetSize();
6543 wxPyEndAllowThreads(__tstate);
6544 if (PyErr_Occurred()) SWIG_fail;
6545 }
6546 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6547 return resultobj;
6548 fail:
6549 return NULL;
6550 }
6551
6552
6553 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6554 PyObject *resultobj = 0;
6555 wxRect *arg1 = (wxRect *) 0 ;
6556 wxSize *arg2 = 0 ;
6557 void *argp1 = 0 ;
6558 int res1 = 0 ;
6559 wxSize temp2 ;
6560 PyObject * obj0 = 0 ;
6561 PyObject * obj1 = 0 ;
6562 char * kwnames[] = {
6563 (char *) "self",(char *) "s", NULL
6564 };
6565
6566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6567 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6568 if (!SWIG_IsOK(res1)) {
6569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6570 }
6571 arg1 = reinterpret_cast< wxRect * >(argp1);
6572 {
6573 arg2 = &temp2;
6574 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6575 }
6576 {
6577 PyThreadState* __tstate = wxPyBeginAllowThreads();
6578 (arg1)->SetSize((wxSize const &)*arg2);
6579 wxPyEndAllowThreads(__tstate);
6580 if (PyErr_Occurred()) SWIG_fail;
6581 }
6582 resultobj = SWIG_Py_Void();
6583 return resultobj;
6584 fail:
6585 return NULL;
6586 }
6587
6588
6589 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6590 PyObject *resultobj = 0;
6591 wxRect *arg1 = (wxRect *) 0 ;
6592 bool result;
6593 void *argp1 = 0 ;
6594 int res1 = 0 ;
6595 PyObject *swig_obj[1] ;
6596
6597 if (!args) SWIG_fail;
6598 swig_obj[0] = args;
6599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6600 if (!SWIG_IsOK(res1)) {
6601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6602 }
6603 arg1 = reinterpret_cast< wxRect * >(argp1);
6604 {
6605 PyThreadState* __tstate = wxPyBeginAllowThreads();
6606 result = (bool)((wxRect const *)arg1)->IsEmpty();
6607 wxPyEndAllowThreads(__tstate);
6608 if (PyErr_Occurred()) SWIG_fail;
6609 }
6610 {
6611 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6612 }
6613 return resultobj;
6614 fail:
6615 return NULL;
6616 }
6617
6618
6619 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6620 PyObject *resultobj = 0;
6621 wxRect *arg1 = (wxRect *) 0 ;
6622 wxPoint result;
6623 void *argp1 = 0 ;
6624 int res1 = 0 ;
6625 PyObject *swig_obj[1] ;
6626
6627 if (!args) SWIG_fail;
6628 swig_obj[0] = args;
6629 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6630 if (!SWIG_IsOK(res1)) {
6631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6632 }
6633 arg1 = reinterpret_cast< wxRect * >(argp1);
6634 {
6635 PyThreadState* __tstate = wxPyBeginAllowThreads();
6636 result = ((wxRect const *)arg1)->GetTopLeft();
6637 wxPyEndAllowThreads(__tstate);
6638 if (PyErr_Occurred()) SWIG_fail;
6639 }
6640 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6641 return resultobj;
6642 fail:
6643 return NULL;
6644 }
6645
6646
6647 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6648 PyObject *resultobj = 0;
6649 wxRect *arg1 = (wxRect *) 0 ;
6650 wxPoint *arg2 = 0 ;
6651 void *argp1 = 0 ;
6652 int res1 = 0 ;
6653 wxPoint temp2 ;
6654 PyObject * obj0 = 0 ;
6655 PyObject * obj1 = 0 ;
6656 char * kwnames[] = {
6657 (char *) "self",(char *) "p", NULL
6658 };
6659
6660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6662 if (!SWIG_IsOK(res1)) {
6663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6664 }
6665 arg1 = reinterpret_cast< wxRect * >(argp1);
6666 {
6667 arg2 = &temp2;
6668 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6669 }
6670 {
6671 PyThreadState* __tstate = wxPyBeginAllowThreads();
6672 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6673 wxPyEndAllowThreads(__tstate);
6674 if (PyErr_Occurred()) SWIG_fail;
6675 }
6676 resultobj = SWIG_Py_Void();
6677 return resultobj;
6678 fail:
6679 return NULL;
6680 }
6681
6682
6683 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6684 PyObject *resultobj = 0;
6685 wxRect *arg1 = (wxRect *) 0 ;
6686 wxPoint result;
6687 void *argp1 = 0 ;
6688 int res1 = 0 ;
6689 PyObject *swig_obj[1] ;
6690
6691 if (!args) SWIG_fail;
6692 swig_obj[0] = args;
6693 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6694 if (!SWIG_IsOK(res1)) {
6695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6696 }
6697 arg1 = reinterpret_cast< wxRect * >(argp1);
6698 {
6699 PyThreadState* __tstate = wxPyBeginAllowThreads();
6700 result = ((wxRect const *)arg1)->GetBottomRight();
6701 wxPyEndAllowThreads(__tstate);
6702 if (PyErr_Occurred()) SWIG_fail;
6703 }
6704 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6705 return resultobj;
6706 fail:
6707 return NULL;
6708 }
6709
6710
6711 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6712 PyObject *resultobj = 0;
6713 wxRect *arg1 = (wxRect *) 0 ;
6714 wxPoint *arg2 = 0 ;
6715 void *argp1 = 0 ;
6716 int res1 = 0 ;
6717 wxPoint temp2 ;
6718 PyObject * obj0 = 0 ;
6719 PyObject * obj1 = 0 ;
6720 char * kwnames[] = {
6721 (char *) "self",(char *) "p", NULL
6722 };
6723
6724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6726 if (!SWIG_IsOK(res1)) {
6727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6728 }
6729 arg1 = reinterpret_cast< wxRect * >(argp1);
6730 {
6731 arg2 = &temp2;
6732 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6733 }
6734 {
6735 PyThreadState* __tstate = wxPyBeginAllowThreads();
6736 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6737 wxPyEndAllowThreads(__tstate);
6738 if (PyErr_Occurred()) SWIG_fail;
6739 }
6740 resultobj = SWIG_Py_Void();
6741 return resultobj;
6742 fail:
6743 return NULL;
6744 }
6745
6746
6747 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6748 PyObject *resultobj = 0;
6749 wxRect *arg1 = (wxRect *) 0 ;
6750 int result;
6751 void *argp1 = 0 ;
6752 int res1 = 0 ;
6753 PyObject *swig_obj[1] ;
6754
6755 if (!args) SWIG_fail;
6756 swig_obj[0] = args;
6757 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6758 if (!SWIG_IsOK(res1)) {
6759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6760 }
6761 arg1 = reinterpret_cast< wxRect * >(argp1);
6762 {
6763 PyThreadState* __tstate = wxPyBeginAllowThreads();
6764 result = (int)((wxRect const *)arg1)->GetLeft();
6765 wxPyEndAllowThreads(__tstate);
6766 if (PyErr_Occurred()) SWIG_fail;
6767 }
6768 resultobj = SWIG_From_int(static_cast< int >(result));
6769 return resultobj;
6770 fail:
6771 return NULL;
6772 }
6773
6774
6775 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6776 PyObject *resultobj = 0;
6777 wxRect *arg1 = (wxRect *) 0 ;
6778 int result;
6779 void *argp1 = 0 ;
6780 int res1 = 0 ;
6781 PyObject *swig_obj[1] ;
6782
6783 if (!args) SWIG_fail;
6784 swig_obj[0] = args;
6785 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6786 if (!SWIG_IsOK(res1)) {
6787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
6788 }
6789 arg1 = reinterpret_cast< wxRect * >(argp1);
6790 {
6791 PyThreadState* __tstate = wxPyBeginAllowThreads();
6792 result = (int)((wxRect const *)arg1)->GetTop();
6793 wxPyEndAllowThreads(__tstate);
6794 if (PyErr_Occurred()) SWIG_fail;
6795 }
6796 resultobj = SWIG_From_int(static_cast< int >(result));
6797 return resultobj;
6798 fail:
6799 return NULL;
6800 }
6801
6802
6803 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6804 PyObject *resultobj = 0;
6805 wxRect *arg1 = (wxRect *) 0 ;
6806 int result;
6807 void *argp1 = 0 ;
6808 int res1 = 0 ;
6809 PyObject *swig_obj[1] ;
6810
6811 if (!args) SWIG_fail;
6812 swig_obj[0] = args;
6813 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6814 if (!SWIG_IsOK(res1)) {
6815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
6816 }
6817 arg1 = reinterpret_cast< wxRect * >(argp1);
6818 {
6819 PyThreadState* __tstate = wxPyBeginAllowThreads();
6820 result = (int)((wxRect const *)arg1)->GetBottom();
6821 wxPyEndAllowThreads(__tstate);
6822 if (PyErr_Occurred()) SWIG_fail;
6823 }
6824 resultobj = SWIG_From_int(static_cast< int >(result));
6825 return resultobj;
6826 fail:
6827 return NULL;
6828 }
6829
6830
6831 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6832 PyObject *resultobj = 0;
6833 wxRect *arg1 = (wxRect *) 0 ;
6834 int result;
6835 void *argp1 = 0 ;
6836 int res1 = 0 ;
6837 PyObject *swig_obj[1] ;
6838
6839 if (!args) SWIG_fail;
6840 swig_obj[0] = args;
6841 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6842 if (!SWIG_IsOK(res1)) {
6843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6844 }
6845 arg1 = reinterpret_cast< wxRect * >(argp1);
6846 {
6847 PyThreadState* __tstate = wxPyBeginAllowThreads();
6848 result = (int)((wxRect const *)arg1)->GetRight();
6849 wxPyEndAllowThreads(__tstate);
6850 if (PyErr_Occurred()) SWIG_fail;
6851 }
6852 resultobj = SWIG_From_int(static_cast< int >(result));
6853 return resultobj;
6854 fail:
6855 return NULL;
6856 }
6857
6858
6859 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6860 PyObject *resultobj = 0;
6861 wxRect *arg1 = (wxRect *) 0 ;
6862 int arg2 ;
6863 void *argp1 = 0 ;
6864 int res1 = 0 ;
6865 int val2 ;
6866 int ecode2 = 0 ;
6867 PyObject * obj0 = 0 ;
6868 PyObject * obj1 = 0 ;
6869 char * kwnames[] = {
6870 (char *) "self",(char *) "left", NULL
6871 };
6872
6873 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6874 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6875 if (!SWIG_IsOK(res1)) {
6876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6877 }
6878 arg1 = reinterpret_cast< wxRect * >(argp1);
6879 ecode2 = SWIG_AsVal_int(obj1, &val2);
6880 if (!SWIG_IsOK(ecode2)) {
6881 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
6882 }
6883 arg2 = static_cast< int >(val2);
6884 {
6885 PyThreadState* __tstate = wxPyBeginAllowThreads();
6886 (arg1)->SetLeft(arg2);
6887 wxPyEndAllowThreads(__tstate);
6888 if (PyErr_Occurred()) SWIG_fail;
6889 }
6890 resultobj = SWIG_Py_Void();
6891 return resultobj;
6892 fail:
6893 return NULL;
6894 }
6895
6896
6897 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6898 PyObject *resultobj = 0;
6899 wxRect *arg1 = (wxRect *) 0 ;
6900 int arg2 ;
6901 void *argp1 = 0 ;
6902 int res1 = 0 ;
6903 int val2 ;
6904 int ecode2 = 0 ;
6905 PyObject * obj0 = 0 ;
6906 PyObject * obj1 = 0 ;
6907 char * kwnames[] = {
6908 (char *) "self",(char *) "right", NULL
6909 };
6910
6911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
6912 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6913 if (!SWIG_IsOK(res1)) {
6914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
6915 }
6916 arg1 = reinterpret_cast< wxRect * >(argp1);
6917 ecode2 = SWIG_AsVal_int(obj1, &val2);
6918 if (!SWIG_IsOK(ecode2)) {
6919 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
6920 }
6921 arg2 = static_cast< int >(val2);
6922 {
6923 PyThreadState* __tstate = wxPyBeginAllowThreads();
6924 (arg1)->SetRight(arg2);
6925 wxPyEndAllowThreads(__tstate);
6926 if (PyErr_Occurred()) SWIG_fail;
6927 }
6928 resultobj = SWIG_Py_Void();
6929 return resultobj;
6930 fail:
6931 return NULL;
6932 }
6933
6934
6935 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6936 PyObject *resultobj = 0;
6937 wxRect *arg1 = (wxRect *) 0 ;
6938 int arg2 ;
6939 void *argp1 = 0 ;
6940 int res1 = 0 ;
6941 int val2 ;
6942 int ecode2 = 0 ;
6943 PyObject * obj0 = 0 ;
6944 PyObject * obj1 = 0 ;
6945 char * kwnames[] = {
6946 (char *) "self",(char *) "top", NULL
6947 };
6948
6949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
6950 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6951 if (!SWIG_IsOK(res1)) {
6952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
6953 }
6954 arg1 = reinterpret_cast< wxRect * >(argp1);
6955 ecode2 = SWIG_AsVal_int(obj1, &val2);
6956 if (!SWIG_IsOK(ecode2)) {
6957 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
6958 }
6959 arg2 = static_cast< int >(val2);
6960 {
6961 PyThreadState* __tstate = wxPyBeginAllowThreads();
6962 (arg1)->SetTop(arg2);
6963 wxPyEndAllowThreads(__tstate);
6964 if (PyErr_Occurred()) SWIG_fail;
6965 }
6966 resultobj = SWIG_Py_Void();
6967 return resultobj;
6968 fail:
6969 return NULL;
6970 }
6971
6972
6973 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6974 PyObject *resultobj = 0;
6975 wxRect *arg1 = (wxRect *) 0 ;
6976 int arg2 ;
6977 void *argp1 = 0 ;
6978 int res1 = 0 ;
6979 int val2 ;
6980 int ecode2 = 0 ;
6981 PyObject * obj0 = 0 ;
6982 PyObject * obj1 = 0 ;
6983 char * kwnames[] = {
6984 (char *) "self",(char *) "bottom", NULL
6985 };
6986
6987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
6988 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6989 if (!SWIG_IsOK(res1)) {
6990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
6991 }
6992 arg1 = reinterpret_cast< wxRect * >(argp1);
6993 ecode2 = SWIG_AsVal_int(obj1, &val2);
6994 if (!SWIG_IsOK(ecode2)) {
6995 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
6996 }
6997 arg2 = static_cast< int >(val2);
6998 {
6999 PyThreadState* __tstate = wxPyBeginAllowThreads();
7000 (arg1)->SetBottom(arg2);
7001 wxPyEndAllowThreads(__tstate);
7002 if (PyErr_Occurred()) SWIG_fail;
7003 }
7004 resultobj = SWIG_Py_Void();
7005 return resultobj;
7006 fail:
7007 return NULL;
7008 }
7009
7010
7011 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7012 PyObject *resultobj = 0;
7013 wxRect *arg1 = (wxRect *) 0 ;
7014 int arg2 ;
7015 int arg3 ;
7016 wxRect *result = 0 ;
7017 void *argp1 = 0 ;
7018 int res1 = 0 ;
7019 int val2 ;
7020 int ecode2 = 0 ;
7021 int val3 ;
7022 int ecode3 = 0 ;
7023 PyObject * obj0 = 0 ;
7024 PyObject * obj1 = 0 ;
7025 PyObject * obj2 = 0 ;
7026 char * kwnames[] = {
7027 (char *) "self",(char *) "dx",(char *) "dy", NULL
7028 };
7029
7030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7031 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7032 if (!SWIG_IsOK(res1)) {
7033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
7034 }
7035 arg1 = reinterpret_cast< wxRect * >(argp1);
7036 ecode2 = SWIG_AsVal_int(obj1, &val2);
7037 if (!SWIG_IsOK(ecode2)) {
7038 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
7039 }
7040 arg2 = static_cast< int >(val2);
7041 ecode3 = SWIG_AsVal_int(obj2, &val3);
7042 if (!SWIG_IsOK(ecode3)) {
7043 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
7044 }
7045 arg3 = static_cast< int >(val3);
7046 {
7047 PyThreadState* __tstate = wxPyBeginAllowThreads();
7048 {
7049 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
7050 result = (wxRect *) &_result_ref;
7051 }
7052 wxPyEndAllowThreads(__tstate);
7053 if (PyErr_Occurred()) SWIG_fail;
7054 }
7055 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7056 return resultobj;
7057 fail:
7058 return NULL;
7059 }
7060
7061
7062 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7063 PyObject *resultobj = 0;
7064 wxRect *arg1 = (wxRect *) 0 ;
7065 int arg2 ;
7066 int arg3 ;
7067 wxRect *result = 0 ;
7068 void *argp1 = 0 ;
7069 int res1 = 0 ;
7070 int val2 ;
7071 int ecode2 = 0 ;
7072 int val3 ;
7073 int ecode3 = 0 ;
7074 PyObject * obj0 = 0 ;
7075 PyObject * obj1 = 0 ;
7076 PyObject * obj2 = 0 ;
7077 char * kwnames[] = {
7078 (char *) "self",(char *) "dx",(char *) "dy", NULL
7079 };
7080
7081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7082 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7083 if (!SWIG_IsOK(res1)) {
7084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
7085 }
7086 arg1 = reinterpret_cast< wxRect * >(argp1);
7087 ecode2 = SWIG_AsVal_int(obj1, &val2);
7088 if (!SWIG_IsOK(ecode2)) {
7089 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7090 }
7091 arg2 = static_cast< int >(val2);
7092 ecode3 = SWIG_AsVal_int(obj2, &val3);
7093 if (!SWIG_IsOK(ecode3)) {
7094 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7095 }
7096 arg3 = static_cast< int >(val3);
7097 {
7098 PyThreadState* __tstate = wxPyBeginAllowThreads();
7099 {
7100 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7101 result = (wxRect *) &_result_ref;
7102 }
7103 wxPyEndAllowThreads(__tstate);
7104 if (PyErr_Occurred()) SWIG_fail;
7105 }
7106 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7107 return resultobj;
7108 fail:
7109 return NULL;
7110 }
7111
7112
7113 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7114 PyObject *resultobj = 0;
7115 wxRect *arg1 = (wxRect *) 0 ;
7116 int arg2 ;
7117 int arg3 ;
7118 void *argp1 = 0 ;
7119 int res1 = 0 ;
7120 int val2 ;
7121 int ecode2 = 0 ;
7122 int val3 ;
7123 int ecode3 = 0 ;
7124 PyObject * obj0 = 0 ;
7125 PyObject * obj1 = 0 ;
7126 PyObject * obj2 = 0 ;
7127 char * kwnames[] = {
7128 (char *) "self",(char *) "dx",(char *) "dy", NULL
7129 };
7130
7131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7132 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7133 if (!SWIG_IsOK(res1)) {
7134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7135 }
7136 arg1 = reinterpret_cast< wxRect * >(argp1);
7137 ecode2 = SWIG_AsVal_int(obj1, &val2);
7138 if (!SWIG_IsOK(ecode2)) {
7139 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7140 }
7141 arg2 = static_cast< int >(val2);
7142 ecode3 = SWIG_AsVal_int(obj2, &val3);
7143 if (!SWIG_IsOK(ecode3)) {
7144 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7145 }
7146 arg3 = static_cast< int >(val3);
7147 {
7148 PyThreadState* __tstate = wxPyBeginAllowThreads();
7149 (arg1)->Offset(arg2,arg3);
7150 wxPyEndAllowThreads(__tstate);
7151 if (PyErr_Occurred()) SWIG_fail;
7152 }
7153 resultobj = SWIG_Py_Void();
7154 return resultobj;
7155 fail:
7156 return NULL;
7157 }
7158
7159
7160 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7161 PyObject *resultobj = 0;
7162 wxRect *arg1 = (wxRect *) 0 ;
7163 wxPoint *arg2 = 0 ;
7164 void *argp1 = 0 ;
7165 int res1 = 0 ;
7166 wxPoint temp2 ;
7167 PyObject * obj0 = 0 ;
7168 PyObject * obj1 = 0 ;
7169 char * kwnames[] = {
7170 (char *) "self",(char *) "pt", NULL
7171 };
7172
7173 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7174 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7175 if (!SWIG_IsOK(res1)) {
7176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7177 }
7178 arg1 = reinterpret_cast< wxRect * >(argp1);
7179 {
7180 arg2 = &temp2;
7181 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7182 }
7183 {
7184 PyThreadState* __tstate = wxPyBeginAllowThreads();
7185 (arg1)->Offset((wxPoint const &)*arg2);
7186 wxPyEndAllowThreads(__tstate);
7187 if (PyErr_Occurred()) SWIG_fail;
7188 }
7189 resultobj = SWIG_Py_Void();
7190 return resultobj;
7191 fail:
7192 return NULL;
7193 }
7194
7195
7196 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7197 PyObject *resultobj = 0;
7198 wxRect *arg1 = (wxRect *) 0 ;
7199 wxRect *arg2 = 0 ;
7200 wxRect result;
7201 void *argp1 = 0 ;
7202 int res1 = 0 ;
7203 wxRect temp2 ;
7204 PyObject * obj0 = 0 ;
7205 PyObject * obj1 = 0 ;
7206 char * kwnames[] = {
7207 (char *) "self",(char *) "rect", NULL
7208 };
7209
7210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7211 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7212 if (!SWIG_IsOK(res1)) {
7213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7214 }
7215 arg1 = reinterpret_cast< wxRect * >(argp1);
7216 {
7217 arg2 = &temp2;
7218 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7219 }
7220 {
7221 PyThreadState* __tstate = wxPyBeginAllowThreads();
7222 result = (arg1)->Intersect((wxRect const &)*arg2);
7223 wxPyEndAllowThreads(__tstate);
7224 if (PyErr_Occurred()) SWIG_fail;
7225 }
7226 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7227 return resultobj;
7228 fail:
7229 return NULL;
7230 }
7231
7232
7233 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7234 PyObject *resultobj = 0;
7235 wxRect *arg1 = (wxRect *) 0 ;
7236 wxRect *arg2 = 0 ;
7237 wxRect result;
7238 void *argp1 = 0 ;
7239 int res1 = 0 ;
7240 wxRect temp2 ;
7241 PyObject * obj0 = 0 ;
7242 PyObject * obj1 = 0 ;
7243 char * kwnames[] = {
7244 (char *) "self",(char *) "rect", NULL
7245 };
7246
7247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7248 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7249 if (!SWIG_IsOK(res1)) {
7250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7251 }
7252 arg1 = reinterpret_cast< wxRect * >(argp1);
7253 {
7254 arg2 = &temp2;
7255 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7256 }
7257 {
7258 PyThreadState* __tstate = wxPyBeginAllowThreads();
7259 result = (arg1)->Union((wxRect const &)*arg2);
7260 wxPyEndAllowThreads(__tstate);
7261 if (PyErr_Occurred()) SWIG_fail;
7262 }
7263 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7264 return resultobj;
7265 fail:
7266 return NULL;
7267 }
7268
7269
7270 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7271 PyObject *resultobj = 0;
7272 wxRect *arg1 = (wxRect *) 0 ;
7273 wxRect *arg2 = 0 ;
7274 wxRect result;
7275 void *argp1 = 0 ;
7276 int res1 = 0 ;
7277 wxRect temp2 ;
7278 PyObject * obj0 = 0 ;
7279 PyObject * obj1 = 0 ;
7280 char * kwnames[] = {
7281 (char *) "self",(char *) "rect", NULL
7282 };
7283
7284 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7285 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7286 if (!SWIG_IsOK(res1)) {
7287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7288 }
7289 arg1 = reinterpret_cast< wxRect * >(argp1);
7290 {
7291 arg2 = &temp2;
7292 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7293 }
7294 {
7295 PyThreadState* __tstate = wxPyBeginAllowThreads();
7296 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7297 wxPyEndAllowThreads(__tstate);
7298 if (PyErr_Occurred()) SWIG_fail;
7299 }
7300 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7301 return resultobj;
7302 fail:
7303 return NULL;
7304 }
7305
7306
7307 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7308 PyObject *resultobj = 0;
7309 wxRect *arg1 = (wxRect *) 0 ;
7310 wxRect *arg2 = 0 ;
7311 wxRect *result = 0 ;
7312 void *argp1 = 0 ;
7313 int res1 = 0 ;
7314 wxRect temp2 ;
7315 PyObject * obj0 = 0 ;
7316 PyObject * obj1 = 0 ;
7317 char * kwnames[] = {
7318 (char *) "self",(char *) "rect", NULL
7319 };
7320
7321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7322 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7323 if (!SWIG_IsOK(res1)) {
7324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7325 }
7326 arg1 = reinterpret_cast< wxRect * >(argp1);
7327 {
7328 arg2 = &temp2;
7329 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7330 }
7331 {
7332 PyThreadState* __tstate = wxPyBeginAllowThreads();
7333 {
7334 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7335 result = (wxRect *) &_result_ref;
7336 }
7337 wxPyEndAllowThreads(__tstate);
7338 if (PyErr_Occurred()) SWIG_fail;
7339 }
7340 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7341 return resultobj;
7342 fail:
7343 return NULL;
7344 }
7345
7346
7347 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7348 PyObject *resultobj = 0;
7349 wxRect *arg1 = (wxRect *) 0 ;
7350 PyObject *arg2 = (PyObject *) 0 ;
7351 bool result;
7352 void *argp1 = 0 ;
7353 int res1 = 0 ;
7354 PyObject * obj0 = 0 ;
7355 PyObject * obj1 = 0 ;
7356 char * kwnames[] = {
7357 (char *) "self",(char *) "other", NULL
7358 };
7359
7360 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7361 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7362 if (!SWIG_IsOK(res1)) {
7363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect *""'");
7364 }
7365 arg1 = reinterpret_cast< wxRect * >(argp1);
7366 arg2 = obj1;
7367 {
7368 result = (bool)wxRect___eq__(arg1,arg2);
7369 if (PyErr_Occurred()) SWIG_fail;
7370 }
7371 {
7372 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7373 }
7374 return resultobj;
7375 fail:
7376 return NULL;
7377 }
7378
7379
7380 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7381 PyObject *resultobj = 0;
7382 wxRect *arg1 = (wxRect *) 0 ;
7383 PyObject *arg2 = (PyObject *) 0 ;
7384 bool result;
7385 void *argp1 = 0 ;
7386 int res1 = 0 ;
7387 PyObject * obj0 = 0 ;
7388 PyObject * obj1 = 0 ;
7389 char * kwnames[] = {
7390 (char *) "self",(char *) "other", NULL
7391 };
7392
7393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7394 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7395 if (!SWIG_IsOK(res1)) {
7396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect *""'");
7397 }
7398 arg1 = reinterpret_cast< wxRect * >(argp1);
7399 arg2 = obj1;
7400 {
7401 result = (bool)wxRect___ne__(arg1,arg2);
7402 if (PyErr_Occurred()) SWIG_fail;
7403 }
7404 {
7405 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7406 }
7407 return resultobj;
7408 fail:
7409 return NULL;
7410 }
7411
7412
7413 SWIGINTERN PyObject *_wrap_Rect_InsideXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7414 PyObject *resultobj = 0;
7415 wxRect *arg1 = (wxRect *) 0 ;
7416 int arg2 ;
7417 int arg3 ;
7418 bool result;
7419 void *argp1 = 0 ;
7420 int res1 = 0 ;
7421 int val2 ;
7422 int ecode2 = 0 ;
7423 int val3 ;
7424 int ecode3 = 0 ;
7425 PyObject * obj0 = 0 ;
7426 PyObject * obj1 = 0 ;
7427 PyObject * obj2 = 0 ;
7428 char * kwnames[] = {
7429 (char *) "self",(char *) "x",(char *) "y", NULL
7430 };
7431
7432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7433 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7434 if (!SWIG_IsOK(res1)) {
7435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_InsideXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7436 }
7437 arg1 = reinterpret_cast< wxRect * >(argp1);
7438 ecode2 = SWIG_AsVal_int(obj1, &val2);
7439 if (!SWIG_IsOK(ecode2)) {
7440 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_InsideXY" "', expected argument " "2"" of type '" "int""'");
7441 }
7442 arg2 = static_cast< int >(val2);
7443 ecode3 = SWIG_AsVal_int(obj2, &val3);
7444 if (!SWIG_IsOK(ecode3)) {
7445 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_InsideXY" "', expected argument " "3"" of type '" "int""'");
7446 }
7447 arg3 = static_cast< int >(val3);
7448 {
7449 PyThreadState* __tstate = wxPyBeginAllowThreads();
7450 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
7451 wxPyEndAllowThreads(__tstate);
7452 if (PyErr_Occurred()) SWIG_fail;
7453 }
7454 {
7455 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7456 }
7457 return resultobj;
7458 fail:
7459 return NULL;
7460 }
7461
7462
7463 SWIGINTERN PyObject *_wrap_Rect_Inside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7464 PyObject *resultobj = 0;
7465 wxRect *arg1 = (wxRect *) 0 ;
7466 wxPoint *arg2 = 0 ;
7467 bool result;
7468 void *argp1 = 0 ;
7469 int res1 = 0 ;
7470 wxPoint temp2 ;
7471 PyObject * obj0 = 0 ;
7472 PyObject * obj1 = 0 ;
7473 char * kwnames[] = {
7474 (char *) "self",(char *) "pt", NULL
7475 };
7476
7477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) SWIG_fail;
7478 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7479 if (!SWIG_IsOK(res1)) {
7480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inside" "', expected argument " "1"" of type '" "wxRect const *""'");
7481 }
7482 arg1 = reinterpret_cast< wxRect * >(argp1);
7483 {
7484 arg2 = &temp2;
7485 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7486 }
7487 {
7488 PyThreadState* __tstate = wxPyBeginAllowThreads();
7489 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
7490 wxPyEndAllowThreads(__tstate);
7491 if (PyErr_Occurred()) SWIG_fail;
7492 }
7493 {
7494 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7495 }
7496 return resultobj;
7497 fail:
7498 return NULL;
7499 }
7500
7501
7502 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7503 PyObject *resultobj = 0;
7504 wxRect *arg1 = (wxRect *) 0 ;
7505 wxRect *arg2 = 0 ;
7506 bool result;
7507 void *argp1 = 0 ;
7508 int res1 = 0 ;
7509 wxRect temp2 ;
7510 PyObject * obj0 = 0 ;
7511 PyObject * obj1 = 0 ;
7512 char * kwnames[] = {
7513 (char *) "self",(char *) "rect", NULL
7514 };
7515
7516 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7517 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7518 if (!SWIG_IsOK(res1)) {
7519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7520 }
7521 arg1 = reinterpret_cast< wxRect * >(argp1);
7522 {
7523 arg2 = &temp2;
7524 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7525 }
7526 {
7527 PyThreadState* __tstate = wxPyBeginAllowThreads();
7528 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7529 wxPyEndAllowThreads(__tstate);
7530 if (PyErr_Occurred()) SWIG_fail;
7531 }
7532 {
7533 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7534 }
7535 return resultobj;
7536 fail:
7537 return NULL;
7538 }
7539
7540
7541 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7542 PyObject *resultobj = 0;
7543 wxRect *arg1 = (wxRect *) 0 ;
7544 wxRect *arg2 = 0 ;
7545 int arg3 = (int) wxBOTH ;
7546 wxRect result;
7547 void *argp1 = 0 ;
7548 int res1 = 0 ;
7549 wxRect temp2 ;
7550 int val3 ;
7551 int ecode3 = 0 ;
7552 PyObject * obj0 = 0 ;
7553 PyObject * obj1 = 0 ;
7554 PyObject * obj2 = 0 ;
7555 char * kwnames[] = {
7556 (char *) "self",(char *) "r",(char *) "dir", NULL
7557 };
7558
7559 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7560 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7561 if (!SWIG_IsOK(res1)) {
7562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7563 }
7564 arg1 = reinterpret_cast< wxRect * >(argp1);
7565 {
7566 arg2 = &temp2;
7567 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7568 }
7569 if (obj2) {
7570 ecode3 = SWIG_AsVal_int(obj2, &val3);
7571 if (!SWIG_IsOK(ecode3)) {
7572 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7573 }
7574 arg3 = static_cast< int >(val3);
7575 }
7576 {
7577 PyThreadState* __tstate = wxPyBeginAllowThreads();
7578 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7579 wxPyEndAllowThreads(__tstate);
7580 if (PyErr_Occurred()) SWIG_fail;
7581 }
7582 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7583 return resultobj;
7584 fail:
7585 return NULL;
7586 }
7587
7588
7589 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7590 PyObject *resultobj = 0;
7591 wxRect *arg1 = (wxRect *) 0 ;
7592 int arg2 ;
7593 void *argp1 = 0 ;
7594 int res1 = 0 ;
7595 int val2 ;
7596 int ecode2 = 0 ;
7597 PyObject *swig_obj[2] ;
7598
7599 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7600 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7601 if (!SWIG_IsOK(res1)) {
7602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7603 }
7604 arg1 = reinterpret_cast< wxRect * >(argp1);
7605 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7606 if (!SWIG_IsOK(ecode2)) {
7607 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7608 }
7609 arg2 = static_cast< int >(val2);
7610 if (arg1) (arg1)->x = arg2;
7611
7612 resultobj = SWIG_Py_Void();
7613 return resultobj;
7614 fail:
7615 return NULL;
7616 }
7617
7618
7619 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7620 PyObject *resultobj = 0;
7621 wxRect *arg1 = (wxRect *) 0 ;
7622 int result;
7623 void *argp1 = 0 ;
7624 int res1 = 0 ;
7625 PyObject *swig_obj[1] ;
7626
7627 if (!args) SWIG_fail;
7628 swig_obj[0] = args;
7629 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7630 if (!SWIG_IsOK(res1)) {
7631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7632 }
7633 arg1 = reinterpret_cast< wxRect * >(argp1);
7634 result = (int) ((arg1)->x);
7635 resultobj = SWIG_From_int(static_cast< int >(result));
7636 return resultobj;
7637 fail:
7638 return NULL;
7639 }
7640
7641
7642 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7643 PyObject *resultobj = 0;
7644 wxRect *arg1 = (wxRect *) 0 ;
7645 int arg2 ;
7646 void *argp1 = 0 ;
7647 int res1 = 0 ;
7648 int val2 ;
7649 int ecode2 = 0 ;
7650 PyObject *swig_obj[2] ;
7651
7652 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7653 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7654 if (!SWIG_IsOK(res1)) {
7655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
7656 }
7657 arg1 = reinterpret_cast< wxRect * >(argp1);
7658 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7659 if (!SWIG_IsOK(ecode2)) {
7660 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
7661 }
7662 arg2 = static_cast< int >(val2);
7663 if (arg1) (arg1)->y = arg2;
7664
7665 resultobj = SWIG_Py_Void();
7666 return resultobj;
7667 fail:
7668 return NULL;
7669 }
7670
7671
7672 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7673 PyObject *resultobj = 0;
7674 wxRect *arg1 = (wxRect *) 0 ;
7675 int result;
7676 void *argp1 = 0 ;
7677 int res1 = 0 ;
7678 PyObject *swig_obj[1] ;
7679
7680 if (!args) SWIG_fail;
7681 swig_obj[0] = args;
7682 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7683 if (!SWIG_IsOK(res1)) {
7684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
7685 }
7686 arg1 = reinterpret_cast< wxRect * >(argp1);
7687 result = (int) ((arg1)->y);
7688 resultobj = SWIG_From_int(static_cast< int >(result));
7689 return resultobj;
7690 fail:
7691 return NULL;
7692 }
7693
7694
7695 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7696 PyObject *resultobj = 0;
7697 wxRect *arg1 = (wxRect *) 0 ;
7698 int arg2 ;
7699 void *argp1 = 0 ;
7700 int res1 = 0 ;
7701 int val2 ;
7702 int ecode2 = 0 ;
7703 PyObject *swig_obj[2] ;
7704
7705 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
7706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7707 if (!SWIG_IsOK(res1)) {
7708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
7709 }
7710 arg1 = reinterpret_cast< wxRect * >(argp1);
7711 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7712 if (!SWIG_IsOK(ecode2)) {
7713 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
7714 }
7715 arg2 = static_cast< int >(val2);
7716 if (arg1) (arg1)->width = arg2;
7717
7718 resultobj = SWIG_Py_Void();
7719 return resultobj;
7720 fail:
7721 return NULL;
7722 }
7723
7724
7725 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7726 PyObject *resultobj = 0;
7727 wxRect *arg1 = (wxRect *) 0 ;
7728 int result;
7729 void *argp1 = 0 ;
7730 int res1 = 0 ;
7731 PyObject *swig_obj[1] ;
7732
7733 if (!args) SWIG_fail;
7734 swig_obj[0] = args;
7735 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7736 if (!SWIG_IsOK(res1)) {
7737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
7738 }
7739 arg1 = reinterpret_cast< wxRect * >(argp1);
7740 result = (int) ((arg1)->width);
7741 resultobj = SWIG_From_int(static_cast< int >(result));
7742 return resultobj;
7743 fail:
7744 return NULL;
7745 }
7746
7747
7748 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7749 PyObject *resultobj = 0;
7750 wxRect *arg1 = (wxRect *) 0 ;
7751 int arg2 ;
7752 void *argp1 = 0 ;
7753 int res1 = 0 ;
7754 int val2 ;
7755 int ecode2 = 0 ;
7756 PyObject *swig_obj[2] ;
7757
7758 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
7759 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7760 if (!SWIG_IsOK(res1)) {
7761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
7762 }
7763 arg1 = reinterpret_cast< wxRect * >(argp1);
7764 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7765 if (!SWIG_IsOK(ecode2)) {
7766 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
7767 }
7768 arg2 = static_cast< int >(val2);
7769 if (arg1) (arg1)->height = arg2;
7770
7771 resultobj = SWIG_Py_Void();
7772 return resultobj;
7773 fail:
7774 return NULL;
7775 }
7776
7777
7778 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7779 PyObject *resultobj = 0;
7780 wxRect *arg1 = (wxRect *) 0 ;
7781 int result;
7782 void *argp1 = 0 ;
7783 int res1 = 0 ;
7784 PyObject *swig_obj[1] ;
7785
7786 if (!args) SWIG_fail;
7787 swig_obj[0] = args;
7788 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7789 if (!SWIG_IsOK(res1)) {
7790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
7791 }
7792 arg1 = reinterpret_cast< wxRect * >(argp1);
7793 result = (int) ((arg1)->height);
7794 resultobj = SWIG_From_int(static_cast< int >(result));
7795 return resultobj;
7796 fail:
7797 return NULL;
7798 }
7799
7800
7801 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7802 PyObject *resultobj = 0;
7803 wxRect *arg1 = (wxRect *) 0 ;
7804 int arg2 = (int) 0 ;
7805 int arg3 = (int) 0 ;
7806 int arg4 = (int) 0 ;
7807 int arg5 = (int) 0 ;
7808 void *argp1 = 0 ;
7809 int res1 = 0 ;
7810 int val2 ;
7811 int ecode2 = 0 ;
7812 int val3 ;
7813 int ecode3 = 0 ;
7814 int val4 ;
7815 int ecode4 = 0 ;
7816 int val5 ;
7817 int ecode5 = 0 ;
7818 PyObject * obj0 = 0 ;
7819 PyObject * obj1 = 0 ;
7820 PyObject * obj2 = 0 ;
7821 PyObject * obj3 = 0 ;
7822 PyObject * obj4 = 0 ;
7823 char * kwnames[] = {
7824 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7825 };
7826
7827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
7828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7829 if (!SWIG_IsOK(res1)) {
7830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
7831 }
7832 arg1 = reinterpret_cast< wxRect * >(argp1);
7833 if (obj1) {
7834 ecode2 = SWIG_AsVal_int(obj1, &val2);
7835 if (!SWIG_IsOK(ecode2)) {
7836 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
7837 }
7838 arg2 = static_cast< int >(val2);
7839 }
7840 if (obj2) {
7841 ecode3 = SWIG_AsVal_int(obj2, &val3);
7842 if (!SWIG_IsOK(ecode3)) {
7843 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
7844 }
7845 arg3 = static_cast< int >(val3);
7846 }
7847 if (obj3) {
7848 ecode4 = SWIG_AsVal_int(obj3, &val4);
7849 if (!SWIG_IsOK(ecode4)) {
7850 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
7851 }
7852 arg4 = static_cast< int >(val4);
7853 }
7854 if (obj4) {
7855 ecode5 = SWIG_AsVal_int(obj4, &val5);
7856 if (!SWIG_IsOK(ecode5)) {
7857 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
7858 }
7859 arg5 = static_cast< int >(val5);
7860 }
7861 {
7862 PyThreadState* __tstate = wxPyBeginAllowThreads();
7863 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
7864 wxPyEndAllowThreads(__tstate);
7865 if (PyErr_Occurred()) SWIG_fail;
7866 }
7867 resultobj = SWIG_Py_Void();
7868 return resultobj;
7869 fail:
7870 return NULL;
7871 }
7872
7873
7874 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7875 PyObject *resultobj = 0;
7876 wxRect *arg1 = (wxRect *) 0 ;
7877 PyObject *result = 0 ;
7878 void *argp1 = 0 ;
7879 int res1 = 0 ;
7880 PyObject *swig_obj[1] ;
7881
7882 if (!args) SWIG_fail;
7883 swig_obj[0] = args;
7884 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7885 if (!SWIG_IsOK(res1)) {
7886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
7887 }
7888 arg1 = reinterpret_cast< wxRect * >(argp1);
7889 {
7890 PyThreadState* __tstate = wxPyBeginAllowThreads();
7891 result = (PyObject *)wxRect_Get(arg1);
7892 wxPyEndAllowThreads(__tstate);
7893 if (PyErr_Occurred()) SWIG_fail;
7894 }
7895 resultobj = result;
7896 return resultobj;
7897 fail:
7898 return NULL;
7899 }
7900
7901
7902 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7903 PyObject *obj;
7904 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7905 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
7906 return SWIG_Py_Void();
7907 }
7908
7909 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7910 return SWIG_Python_InitShadowInstance(args);
7911 }
7912
7913 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7914 PyObject *resultobj = 0;
7915 wxRect *arg1 = (wxRect *) 0 ;
7916 wxRect *arg2 = (wxRect *) 0 ;
7917 PyObject *result = 0 ;
7918 void *argp1 = 0 ;
7919 int res1 = 0 ;
7920 void *argp2 = 0 ;
7921 int res2 = 0 ;
7922 PyObject * obj0 = 0 ;
7923 PyObject * obj1 = 0 ;
7924 char * kwnames[] = {
7925 (char *) "r1",(char *) "r2", NULL
7926 };
7927
7928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
7929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7930 if (!SWIG_IsOK(res1)) {
7931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
7932 }
7933 arg1 = reinterpret_cast< wxRect * >(argp1);
7934 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
7935 if (!SWIG_IsOK(res2)) {
7936 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
7937 }
7938 arg2 = reinterpret_cast< wxRect * >(argp2);
7939 {
7940 if (!wxPyCheckForApp()) SWIG_fail;
7941 PyThreadState* __tstate = wxPyBeginAllowThreads();
7942 result = (PyObject *)wxIntersectRect(arg1,arg2);
7943 wxPyEndAllowThreads(__tstate);
7944 if (PyErr_Occurred()) SWIG_fail;
7945 }
7946 resultobj = result;
7947 return resultobj;
7948 fail:
7949 return NULL;
7950 }
7951
7952
7953 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7954 PyObject *resultobj = 0;
7955 double arg1 = (double) 0.0 ;
7956 double arg2 = (double) 0.0 ;
7957 wxPoint2D *result = 0 ;
7958 double val1 ;
7959 int ecode1 = 0 ;
7960 double val2 ;
7961 int ecode2 = 0 ;
7962 PyObject * obj0 = 0 ;
7963 PyObject * obj1 = 0 ;
7964 char * kwnames[] = {
7965 (char *) "x",(char *) "y", NULL
7966 };
7967
7968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
7969 if (obj0) {
7970 ecode1 = SWIG_AsVal_double(obj0, &val1);
7971 if (!SWIG_IsOK(ecode1)) {
7972 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
7973 }
7974 arg1 = static_cast< double >(val1);
7975 }
7976 if (obj1) {
7977 ecode2 = SWIG_AsVal_double(obj1, &val2);
7978 if (!SWIG_IsOK(ecode2)) {
7979 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
7980 }
7981 arg2 = static_cast< double >(val2);
7982 }
7983 {
7984 PyThreadState* __tstate = wxPyBeginAllowThreads();
7985 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
7986 wxPyEndAllowThreads(__tstate);
7987 if (PyErr_Occurred()) SWIG_fail;
7988 }
7989 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
7990 return resultobj;
7991 fail:
7992 return NULL;
7993 }
7994
7995
7996 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7997 PyObject *resultobj = 0;
7998 wxPoint2D *arg1 = 0 ;
7999 wxPoint2D *result = 0 ;
8000 wxPoint2D temp1 ;
8001 PyObject * obj0 = 0 ;
8002 char * kwnames[] = {
8003 (char *) "pt", NULL
8004 };
8005
8006 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
8007 {
8008 arg1 = &temp1;
8009 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
8010 }
8011 {
8012 PyThreadState* __tstate = wxPyBeginAllowThreads();
8013 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
8014 wxPyEndAllowThreads(__tstate);
8015 if (PyErr_Occurred()) SWIG_fail;
8016 }
8017 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8018 return resultobj;
8019 fail:
8020 return NULL;
8021 }
8022
8023
8024 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8025 PyObject *resultobj = 0;
8026 wxPoint *arg1 = 0 ;
8027 wxPoint2D *result = 0 ;
8028 wxPoint temp1 ;
8029 PyObject * obj0 = 0 ;
8030 char * kwnames[] = {
8031 (char *) "pt", NULL
8032 };
8033
8034 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
8035 {
8036 arg1 = &temp1;
8037 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
8038 }
8039 {
8040 PyThreadState* __tstate = wxPyBeginAllowThreads();
8041 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
8042 wxPyEndAllowThreads(__tstate);
8043 if (PyErr_Occurred()) SWIG_fail;
8044 }
8045 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8046 return resultobj;
8047 fail:
8048 return NULL;
8049 }
8050
8051
8052 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8053 PyObject *resultobj = 0;
8054 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8055 int *arg2 = (int *) 0 ;
8056 int *arg3 = (int *) 0 ;
8057 void *argp1 = 0 ;
8058 int res1 = 0 ;
8059 int temp2 ;
8060 int res2 = SWIG_TMPOBJ ;
8061 int temp3 ;
8062 int res3 = SWIG_TMPOBJ ;
8063 PyObject *swig_obj[1] ;
8064
8065 arg2 = &temp2;
8066 arg3 = &temp3;
8067 if (!args) SWIG_fail;
8068 swig_obj[0] = args;
8069 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8070 if (!SWIG_IsOK(res1)) {
8071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8072 }
8073 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8074 {
8075 PyThreadState* __tstate = wxPyBeginAllowThreads();
8076 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8077 wxPyEndAllowThreads(__tstate);
8078 if (PyErr_Occurred()) SWIG_fail;
8079 }
8080 resultobj = SWIG_Py_Void();
8081 if (SWIG_IsTmpObj(res2)) {
8082 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8083 } else {
8084 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8085 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8086 }
8087 if (SWIG_IsTmpObj(res3)) {
8088 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8089 } else {
8090 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8091 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8092 }
8093 return resultobj;
8094 fail:
8095 return NULL;
8096 }
8097
8098
8099 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8100 PyObject *resultobj = 0;
8101 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8102 int *arg2 = (int *) 0 ;
8103 int *arg3 = (int *) 0 ;
8104 void *argp1 = 0 ;
8105 int res1 = 0 ;
8106 int temp2 ;
8107 int res2 = SWIG_TMPOBJ ;
8108 int temp3 ;
8109 int res3 = SWIG_TMPOBJ ;
8110 PyObject *swig_obj[1] ;
8111
8112 arg2 = &temp2;
8113 arg3 = &temp3;
8114 if (!args) SWIG_fail;
8115 swig_obj[0] = args;
8116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8117 if (!SWIG_IsOK(res1)) {
8118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8119 }
8120 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8121 {
8122 PyThreadState* __tstate = wxPyBeginAllowThreads();
8123 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8124 wxPyEndAllowThreads(__tstate);
8125 if (PyErr_Occurred()) SWIG_fail;
8126 }
8127 resultobj = SWIG_Py_Void();
8128 if (SWIG_IsTmpObj(res2)) {
8129 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8130 } else {
8131 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8132 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8133 }
8134 if (SWIG_IsTmpObj(res3)) {
8135 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8136 } else {
8137 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8138 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8139 }
8140 return resultobj;
8141 fail:
8142 return NULL;
8143 }
8144
8145
8146 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8147 PyObject *resultobj = 0;
8148 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8149 double result;
8150 void *argp1 = 0 ;
8151 int res1 = 0 ;
8152 PyObject *swig_obj[1] ;
8153
8154 if (!args) SWIG_fail;
8155 swig_obj[0] = args;
8156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8157 if (!SWIG_IsOK(res1)) {
8158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8159 }
8160 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8161 {
8162 PyThreadState* __tstate = wxPyBeginAllowThreads();
8163 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8164 wxPyEndAllowThreads(__tstate);
8165 if (PyErr_Occurred()) SWIG_fail;
8166 }
8167 resultobj = SWIG_From_double(static_cast< double >(result));
8168 return resultobj;
8169 fail:
8170 return NULL;
8171 }
8172
8173
8174 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8175 PyObject *resultobj = 0;
8176 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8177 double result;
8178 void *argp1 = 0 ;
8179 int res1 = 0 ;
8180 PyObject *swig_obj[1] ;
8181
8182 if (!args) SWIG_fail;
8183 swig_obj[0] = args;
8184 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8185 if (!SWIG_IsOK(res1)) {
8186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8187 }
8188 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8189 {
8190 PyThreadState* __tstate = wxPyBeginAllowThreads();
8191 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8192 wxPyEndAllowThreads(__tstate);
8193 if (PyErr_Occurred()) SWIG_fail;
8194 }
8195 resultobj = SWIG_From_double(static_cast< double >(result));
8196 return resultobj;
8197 fail:
8198 return NULL;
8199 }
8200
8201
8202 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8203 PyObject *resultobj = 0;
8204 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8205 double arg2 ;
8206 void *argp1 = 0 ;
8207 int res1 = 0 ;
8208 double val2 ;
8209 int ecode2 = 0 ;
8210 PyObject * obj0 = 0 ;
8211 PyObject * obj1 = 0 ;
8212 char * kwnames[] = {
8213 (char *) "self",(char *) "length", NULL
8214 };
8215
8216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8217 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8218 if (!SWIG_IsOK(res1)) {
8219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8220 }
8221 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8222 ecode2 = SWIG_AsVal_double(obj1, &val2);
8223 if (!SWIG_IsOK(ecode2)) {
8224 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8225 }
8226 arg2 = static_cast< double >(val2);
8227 {
8228 PyThreadState* __tstate = wxPyBeginAllowThreads();
8229 (arg1)->SetVectorLength(arg2);
8230 wxPyEndAllowThreads(__tstate);
8231 if (PyErr_Occurred()) SWIG_fail;
8232 }
8233 resultobj = SWIG_Py_Void();
8234 return resultobj;
8235 fail:
8236 return NULL;
8237 }
8238
8239
8240 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8241 PyObject *resultobj = 0;
8242 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8243 double arg2 ;
8244 void *argp1 = 0 ;
8245 int res1 = 0 ;
8246 double val2 ;
8247 int ecode2 = 0 ;
8248 PyObject * obj0 = 0 ;
8249 PyObject * obj1 = 0 ;
8250 char * kwnames[] = {
8251 (char *) "self",(char *) "degrees", NULL
8252 };
8253
8254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8255 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8256 if (!SWIG_IsOK(res1)) {
8257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8258 }
8259 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8260 ecode2 = SWIG_AsVal_double(obj1, &val2);
8261 if (!SWIG_IsOK(ecode2)) {
8262 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8263 }
8264 arg2 = static_cast< double >(val2);
8265 {
8266 PyThreadState* __tstate = wxPyBeginAllowThreads();
8267 (arg1)->SetVectorAngle(arg2);
8268 wxPyEndAllowThreads(__tstate);
8269 if (PyErr_Occurred()) SWIG_fail;
8270 }
8271 resultobj = SWIG_Py_Void();
8272 return resultobj;
8273 fail:
8274 return NULL;
8275 }
8276
8277
8278 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8279 PyObject *resultobj = 0;
8280 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8281 wxPoint2D *arg2 = 0 ;
8282 double result;
8283 void *argp1 = 0 ;
8284 int res1 = 0 ;
8285 wxPoint2D temp2 ;
8286 PyObject * obj0 = 0 ;
8287 PyObject * obj1 = 0 ;
8288 char * kwnames[] = {
8289 (char *) "self",(char *) "pt", NULL
8290 };
8291
8292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8293 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8294 if (!SWIG_IsOK(res1)) {
8295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8296 }
8297 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8298 {
8299 arg2 = &temp2;
8300 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8301 }
8302 {
8303 PyThreadState* __tstate = wxPyBeginAllowThreads();
8304 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8305 wxPyEndAllowThreads(__tstate);
8306 if (PyErr_Occurred()) SWIG_fail;
8307 }
8308 resultobj = SWIG_From_double(static_cast< double >(result));
8309 return resultobj;
8310 fail:
8311 return NULL;
8312 }
8313
8314
8315 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8316 PyObject *resultobj = 0;
8317 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8318 wxPoint2D *arg2 = 0 ;
8319 double result;
8320 void *argp1 = 0 ;
8321 int res1 = 0 ;
8322 wxPoint2D temp2 ;
8323 PyObject * obj0 = 0 ;
8324 PyObject * obj1 = 0 ;
8325 char * kwnames[] = {
8326 (char *) "self",(char *) "pt", NULL
8327 };
8328
8329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8330 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8331 if (!SWIG_IsOK(res1)) {
8332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8333 }
8334 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8335 {
8336 arg2 = &temp2;
8337 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8338 }
8339 {
8340 PyThreadState* __tstate = wxPyBeginAllowThreads();
8341 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8342 wxPyEndAllowThreads(__tstate);
8343 if (PyErr_Occurred()) SWIG_fail;
8344 }
8345 resultobj = SWIG_From_double(static_cast< double >(result));
8346 return resultobj;
8347 fail:
8348 return NULL;
8349 }
8350
8351
8352 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8353 PyObject *resultobj = 0;
8354 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8355 wxPoint2D *arg2 = 0 ;
8356 double result;
8357 void *argp1 = 0 ;
8358 int res1 = 0 ;
8359 wxPoint2D temp2 ;
8360 PyObject * obj0 = 0 ;
8361 PyObject * obj1 = 0 ;
8362 char * kwnames[] = {
8363 (char *) "self",(char *) "vec", NULL
8364 };
8365
8366 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8367 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8368 if (!SWIG_IsOK(res1)) {
8369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8370 }
8371 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8372 {
8373 arg2 = &temp2;
8374 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8375 }
8376 {
8377 PyThreadState* __tstate = wxPyBeginAllowThreads();
8378 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8379 wxPyEndAllowThreads(__tstate);
8380 if (PyErr_Occurred()) SWIG_fail;
8381 }
8382 resultobj = SWIG_From_double(static_cast< double >(result));
8383 return resultobj;
8384 fail:
8385 return NULL;
8386 }
8387
8388
8389 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8390 PyObject *resultobj = 0;
8391 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8392 wxPoint2D *arg2 = 0 ;
8393 double result;
8394 void *argp1 = 0 ;
8395 int res1 = 0 ;
8396 wxPoint2D temp2 ;
8397 PyObject * obj0 = 0 ;
8398 PyObject * obj1 = 0 ;
8399 char * kwnames[] = {
8400 (char *) "self",(char *) "vec", NULL
8401 };
8402
8403 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8404 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8405 if (!SWIG_IsOK(res1)) {
8406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8407 }
8408 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8409 {
8410 arg2 = &temp2;
8411 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8412 }
8413 {
8414 PyThreadState* __tstate = wxPyBeginAllowThreads();
8415 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8416 wxPyEndAllowThreads(__tstate);
8417 if (PyErr_Occurred()) SWIG_fail;
8418 }
8419 resultobj = SWIG_From_double(static_cast< double >(result));
8420 return resultobj;
8421 fail:
8422 return NULL;
8423 }
8424
8425
8426 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8427 PyObject *resultobj = 0;
8428 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8429 wxPoint2D result;
8430 void *argp1 = 0 ;
8431 int res1 = 0 ;
8432 PyObject *swig_obj[1] ;
8433
8434 if (!args) SWIG_fail;
8435 swig_obj[0] = args;
8436 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8437 if (!SWIG_IsOK(res1)) {
8438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8439 }
8440 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8441 {
8442 PyThreadState* __tstate = wxPyBeginAllowThreads();
8443 result = (arg1)->operator -();
8444 wxPyEndAllowThreads(__tstate);
8445 if (PyErr_Occurred()) SWIG_fail;
8446 }
8447 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8448 return resultobj;
8449 fail:
8450 return NULL;
8451 }
8452
8453
8454 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8455 PyObject *resultobj = 0;
8456 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8457 wxPoint2D *arg2 = 0 ;
8458 wxPoint2D *result = 0 ;
8459 void *argp1 = 0 ;
8460 int res1 = 0 ;
8461 wxPoint2D temp2 ;
8462 PyObject * obj0 = 0 ;
8463 PyObject * obj1 = 0 ;
8464 char * kwnames[] = {
8465 (char *) "self",(char *) "pt", NULL
8466 };
8467
8468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8469 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8470 if (!SWIG_IsOK(res1)) {
8471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8472 }
8473 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8474 {
8475 arg2 = &temp2;
8476 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8477 }
8478 {
8479 PyThreadState* __tstate = wxPyBeginAllowThreads();
8480 {
8481 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8482 result = (wxPoint2D *) &_result_ref;
8483 }
8484 wxPyEndAllowThreads(__tstate);
8485 if (PyErr_Occurred()) SWIG_fail;
8486 }
8487 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8488 return resultobj;
8489 fail:
8490 return NULL;
8491 }
8492
8493
8494 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8495 PyObject *resultobj = 0;
8496 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8497 wxPoint2D *arg2 = 0 ;
8498 wxPoint2D *result = 0 ;
8499 void *argp1 = 0 ;
8500 int res1 = 0 ;
8501 wxPoint2D temp2 ;
8502 PyObject * obj0 = 0 ;
8503 PyObject * obj1 = 0 ;
8504 char * kwnames[] = {
8505 (char *) "self",(char *) "pt", NULL
8506 };
8507
8508 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8509 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8510 if (!SWIG_IsOK(res1)) {
8511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8512 }
8513 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8514 {
8515 arg2 = &temp2;
8516 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8517 }
8518 {
8519 PyThreadState* __tstate = wxPyBeginAllowThreads();
8520 {
8521 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8522 result = (wxPoint2D *) &_result_ref;
8523 }
8524 wxPyEndAllowThreads(__tstate);
8525 if (PyErr_Occurred()) SWIG_fail;
8526 }
8527 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8528 return resultobj;
8529 fail:
8530 return NULL;
8531 }
8532
8533
8534 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8535 PyObject *resultobj = 0;
8536 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8537 wxPoint2D *arg2 = 0 ;
8538 wxPoint2D *result = 0 ;
8539 void *argp1 = 0 ;
8540 int res1 = 0 ;
8541 wxPoint2D temp2 ;
8542 PyObject * obj0 = 0 ;
8543 PyObject * obj1 = 0 ;
8544 char * kwnames[] = {
8545 (char *) "self",(char *) "pt", NULL
8546 };
8547
8548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8549 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8550 if (!SWIG_IsOK(res1)) {
8551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8552 }
8553 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8554 {
8555 arg2 = &temp2;
8556 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8557 }
8558 {
8559 PyThreadState* __tstate = wxPyBeginAllowThreads();
8560 {
8561 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8562 result = (wxPoint2D *) &_result_ref;
8563 }
8564 wxPyEndAllowThreads(__tstate);
8565 if (PyErr_Occurred()) SWIG_fail;
8566 }
8567 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8568 return resultobj;
8569 fail:
8570 return NULL;
8571 }
8572
8573
8574 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8575 PyObject *resultobj = 0;
8576 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8577 wxPoint2D *arg2 = 0 ;
8578 wxPoint2D *result = 0 ;
8579 void *argp1 = 0 ;
8580 int res1 = 0 ;
8581 wxPoint2D temp2 ;
8582 PyObject * obj0 = 0 ;
8583 PyObject * obj1 = 0 ;
8584 char * kwnames[] = {
8585 (char *) "self",(char *) "pt", NULL
8586 };
8587
8588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8590 if (!SWIG_IsOK(res1)) {
8591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8592 }
8593 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8594 {
8595 arg2 = &temp2;
8596 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8597 }
8598 {
8599 PyThreadState* __tstate = wxPyBeginAllowThreads();
8600 {
8601 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8602 result = (wxPoint2D *) &_result_ref;
8603 }
8604 wxPyEndAllowThreads(__tstate);
8605 if (PyErr_Occurred()) SWIG_fail;
8606 }
8607 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8608 return resultobj;
8609 fail:
8610 return NULL;
8611 }
8612
8613
8614 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8615 PyObject *resultobj = 0;
8616 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8617 PyObject *arg2 = (PyObject *) 0 ;
8618 bool result;
8619 void *argp1 = 0 ;
8620 int res1 = 0 ;
8621 PyObject * obj0 = 0 ;
8622 PyObject * obj1 = 0 ;
8623 char * kwnames[] = {
8624 (char *) "self",(char *) "other", NULL
8625 };
8626
8627 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8628 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8629 if (!SWIG_IsOK(res1)) {
8630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8631 }
8632 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8633 arg2 = obj1;
8634 {
8635 result = (bool)wxPoint2D___eq__(arg1,arg2);
8636 if (PyErr_Occurred()) SWIG_fail;
8637 }
8638 {
8639 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8640 }
8641 return resultobj;
8642 fail:
8643 return NULL;
8644 }
8645
8646
8647 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8648 PyObject *resultobj = 0;
8649 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8650 PyObject *arg2 = (PyObject *) 0 ;
8651 bool result;
8652 void *argp1 = 0 ;
8653 int res1 = 0 ;
8654 PyObject * obj0 = 0 ;
8655 PyObject * obj1 = 0 ;
8656 char * kwnames[] = {
8657 (char *) "self",(char *) "other", NULL
8658 };
8659
8660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
8661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8662 if (!SWIG_IsOK(res1)) {
8663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8664 }
8665 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8666 arg2 = obj1;
8667 {
8668 result = (bool)wxPoint2D___ne__(arg1,arg2);
8669 if (PyErr_Occurred()) SWIG_fail;
8670 }
8671 {
8672 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8673 }
8674 return resultobj;
8675 fail:
8676 return NULL;
8677 }
8678
8679
8680 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8681 PyObject *resultobj = 0;
8682 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8683 double arg2 ;
8684 void *argp1 = 0 ;
8685 int res1 = 0 ;
8686 double val2 ;
8687 int ecode2 = 0 ;
8688 PyObject *swig_obj[2] ;
8689
8690 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
8691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8692 if (!SWIG_IsOK(res1)) {
8693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8694 }
8695 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8696 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8697 if (!SWIG_IsOK(ecode2)) {
8698 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
8699 }
8700 arg2 = static_cast< double >(val2);
8701 if (arg1) (arg1)->m_x = arg2;
8702
8703 resultobj = SWIG_Py_Void();
8704 return resultobj;
8705 fail:
8706 return NULL;
8707 }
8708
8709
8710 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8711 PyObject *resultobj = 0;
8712 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8713 double result;
8714 void *argp1 = 0 ;
8715 int res1 = 0 ;
8716 PyObject *swig_obj[1] ;
8717
8718 if (!args) SWIG_fail;
8719 swig_obj[0] = args;
8720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8721 if (!SWIG_IsOK(res1)) {
8722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8723 }
8724 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8725 result = (double) ((arg1)->m_x);
8726 resultobj = SWIG_From_double(static_cast< double >(result));
8727 return resultobj;
8728 fail:
8729 return NULL;
8730 }
8731
8732
8733 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8734 PyObject *resultobj = 0;
8735 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8736 double arg2 ;
8737 void *argp1 = 0 ;
8738 int res1 = 0 ;
8739 double val2 ;
8740 int ecode2 = 0 ;
8741 PyObject *swig_obj[2] ;
8742
8743 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
8744 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8745 if (!SWIG_IsOK(res1)) {
8746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8747 }
8748 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8749 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8750 if (!SWIG_IsOK(ecode2)) {
8751 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
8752 }
8753 arg2 = static_cast< double >(val2);
8754 if (arg1) (arg1)->m_y = arg2;
8755
8756 resultobj = SWIG_Py_Void();
8757 return resultobj;
8758 fail:
8759 return NULL;
8760 }
8761
8762
8763 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8764 PyObject *resultobj = 0;
8765 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8766 double result;
8767 void *argp1 = 0 ;
8768 int res1 = 0 ;
8769 PyObject *swig_obj[1] ;
8770
8771 if (!args) SWIG_fail;
8772 swig_obj[0] = args;
8773 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8774 if (!SWIG_IsOK(res1)) {
8775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8776 }
8777 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8778 result = (double) ((arg1)->m_y);
8779 resultobj = SWIG_From_double(static_cast< double >(result));
8780 return resultobj;
8781 fail:
8782 return NULL;
8783 }
8784
8785
8786 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8787 PyObject *resultobj = 0;
8788 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8789 double arg2 = (double) 0 ;
8790 double arg3 = (double) 0 ;
8791 void *argp1 = 0 ;
8792 int res1 = 0 ;
8793 double val2 ;
8794 int ecode2 = 0 ;
8795 double val3 ;
8796 int ecode3 = 0 ;
8797 PyObject * obj0 = 0 ;
8798 PyObject * obj1 = 0 ;
8799 PyObject * obj2 = 0 ;
8800 char * kwnames[] = {
8801 (char *) "self",(char *) "x",(char *) "y", NULL
8802 };
8803
8804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8805 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8806 if (!SWIG_IsOK(res1)) {
8807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8808 }
8809 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8810 if (obj1) {
8811 ecode2 = SWIG_AsVal_double(obj1, &val2);
8812 if (!SWIG_IsOK(ecode2)) {
8813 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
8814 }
8815 arg2 = static_cast< double >(val2);
8816 }
8817 if (obj2) {
8818 ecode3 = SWIG_AsVal_double(obj2, &val3);
8819 if (!SWIG_IsOK(ecode3)) {
8820 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
8821 }
8822 arg3 = static_cast< double >(val3);
8823 }
8824 {
8825 PyThreadState* __tstate = wxPyBeginAllowThreads();
8826 wxPoint2D_Set(arg1,arg2,arg3);
8827 wxPyEndAllowThreads(__tstate);
8828 if (PyErr_Occurred()) SWIG_fail;
8829 }
8830 resultobj = SWIG_Py_Void();
8831 return resultobj;
8832 fail:
8833 return NULL;
8834 }
8835
8836
8837 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8838 PyObject *resultobj = 0;
8839 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8840 PyObject *result = 0 ;
8841 void *argp1 = 0 ;
8842 int res1 = 0 ;
8843 PyObject *swig_obj[1] ;
8844
8845 if (!args) SWIG_fail;
8846 swig_obj[0] = args;
8847 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8848 if (!SWIG_IsOK(res1)) {
8849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8850 }
8851 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8852 {
8853 PyThreadState* __tstate = wxPyBeginAllowThreads();
8854 result = (PyObject *)wxPoint2D_Get(arg1);
8855 wxPyEndAllowThreads(__tstate);
8856 if (PyErr_Occurred()) SWIG_fail;
8857 }
8858 resultobj = result;
8859 return resultobj;
8860 fail:
8861 return NULL;
8862 }
8863
8864
8865 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8866 PyObject *obj;
8867 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8868 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
8869 return SWIG_Py_Void();
8870 }
8871
8872 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8873 return SWIG_Python_InitShadowInstance(args);
8874 }
8875
8876 SWIGINTERN int DefaultPosition_set(PyObject *) {
8877 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
8878 return 1;
8879 }
8880
8881
8882 SWIGINTERN PyObject *DefaultPosition_get(void) {
8883 PyObject *pyobj = 0;
8884
8885 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
8886 return pyobj;
8887 }
8888
8889
8890 SWIGINTERN int DefaultSize_set(PyObject *) {
8891 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
8892 return 1;
8893 }
8894
8895
8896 SWIGINTERN PyObject *DefaultSize_get(void) {
8897 PyObject *pyobj = 0;
8898
8899 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
8900 return pyobj;
8901 }
8902
8903
8904 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8905 PyObject *resultobj = 0;
8906 PyObject *arg1 = (PyObject *) 0 ;
8907 wxPyInputStream *result = 0 ;
8908 PyObject * obj0 = 0 ;
8909 char * kwnames[] = {
8910 (char *) "p", NULL
8911 };
8912
8913 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
8914 arg1 = obj0;
8915 {
8916 PyThreadState* __tstate = wxPyBeginAllowThreads();
8917 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
8918 wxPyEndAllowThreads(__tstate);
8919 if (PyErr_Occurred()) SWIG_fail;
8920 }
8921 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
8922 return resultobj;
8923 fail:
8924 return NULL;
8925 }
8926
8927
8928 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8929 PyObject *resultobj = 0;
8930 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8931 void *argp1 = 0 ;
8932 int res1 = 0 ;
8933 PyObject *swig_obj[1] ;
8934
8935 if (!args) SWIG_fail;
8936 swig_obj[0] = args;
8937 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
8938 if (!SWIG_IsOK(res1)) {
8939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8940 }
8941 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8942 {
8943 PyThreadState* __tstate = wxPyBeginAllowThreads();
8944 delete arg1;
8945
8946 wxPyEndAllowThreads(__tstate);
8947 if (PyErr_Occurred()) SWIG_fail;
8948 }
8949 resultobj = SWIG_Py_Void();
8950 return resultobj;
8951 fail:
8952 return NULL;
8953 }
8954
8955
8956 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8957 PyObject *resultobj = 0;
8958 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8959 void *argp1 = 0 ;
8960 int res1 = 0 ;
8961 PyObject *swig_obj[1] ;
8962
8963 if (!args) SWIG_fail;
8964 swig_obj[0] = args;
8965 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
8966 if (!SWIG_IsOK(res1)) {
8967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8968 }
8969 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8970 {
8971 PyThreadState* __tstate = wxPyBeginAllowThreads();
8972 (arg1)->close();
8973 wxPyEndAllowThreads(__tstate);
8974 if (PyErr_Occurred()) SWIG_fail;
8975 }
8976 resultobj = SWIG_Py_Void();
8977 return resultobj;
8978 fail:
8979 return NULL;
8980 }
8981
8982
8983 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8984 PyObject *resultobj = 0;
8985 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8986 void *argp1 = 0 ;
8987 int res1 = 0 ;
8988 PyObject *swig_obj[1] ;
8989
8990 if (!args) SWIG_fail;
8991 swig_obj[0] = args;
8992 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
8993 if (!SWIG_IsOK(res1)) {
8994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8995 }
8996 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8997 {
8998 PyThreadState* __tstate = wxPyBeginAllowThreads();
8999 (arg1)->flush();
9000 wxPyEndAllowThreads(__tstate);
9001 if (PyErr_Occurred()) SWIG_fail;
9002 }
9003 resultobj = SWIG_Py_Void();
9004 return resultobj;
9005 fail:
9006 return NULL;
9007 }
9008
9009
9010 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9011 PyObject *resultobj = 0;
9012 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9013 bool result;
9014 void *argp1 = 0 ;
9015 int res1 = 0 ;
9016 PyObject *swig_obj[1] ;
9017
9018 if (!args) SWIG_fail;
9019 swig_obj[0] = args;
9020 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9021 if (!SWIG_IsOK(res1)) {
9022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9023 }
9024 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9025 {
9026 PyThreadState* __tstate = wxPyBeginAllowThreads();
9027 result = (bool)(arg1)->eof();
9028 wxPyEndAllowThreads(__tstate);
9029 if (PyErr_Occurred()) SWIG_fail;
9030 }
9031 {
9032 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9033 }
9034 return resultobj;
9035 fail:
9036 return NULL;
9037 }
9038
9039
9040 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9041 PyObject *resultobj = 0;
9042 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9043 int arg2 = (int) -1 ;
9044 PyObject *result = 0 ;
9045 void *argp1 = 0 ;
9046 int res1 = 0 ;
9047 int val2 ;
9048 int ecode2 = 0 ;
9049 PyObject * obj0 = 0 ;
9050 PyObject * obj1 = 0 ;
9051 char * kwnames[] = {
9052 (char *) "self",(char *) "size", NULL
9053 };
9054
9055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
9056 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9057 if (!SWIG_IsOK(res1)) {
9058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9059 }
9060 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9061 if (obj1) {
9062 ecode2 = SWIG_AsVal_int(obj1, &val2);
9063 if (!SWIG_IsOK(ecode2)) {
9064 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
9065 }
9066 arg2 = static_cast< int >(val2);
9067 }
9068 {
9069 PyThreadState* __tstate = wxPyBeginAllowThreads();
9070 result = (PyObject *)(arg1)->read(arg2);
9071 wxPyEndAllowThreads(__tstate);
9072 if (PyErr_Occurred()) SWIG_fail;
9073 }
9074 resultobj = result;
9075 return resultobj;
9076 fail:
9077 return NULL;
9078 }
9079
9080
9081 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9082 PyObject *resultobj = 0;
9083 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9084 int arg2 = (int) -1 ;
9085 PyObject *result = 0 ;
9086 void *argp1 = 0 ;
9087 int res1 = 0 ;
9088 int val2 ;
9089 int ecode2 = 0 ;
9090 PyObject * obj0 = 0 ;
9091 PyObject * obj1 = 0 ;
9092 char * kwnames[] = {
9093 (char *) "self",(char *) "size", NULL
9094 };
9095
9096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
9097 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9098 if (!SWIG_IsOK(res1)) {
9099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9100 }
9101 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9102 if (obj1) {
9103 ecode2 = SWIG_AsVal_int(obj1, &val2);
9104 if (!SWIG_IsOK(ecode2)) {
9105 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
9106 }
9107 arg2 = static_cast< int >(val2);
9108 }
9109 {
9110 PyThreadState* __tstate = wxPyBeginAllowThreads();
9111 result = (PyObject *)(arg1)->readline(arg2);
9112 wxPyEndAllowThreads(__tstate);
9113 if (PyErr_Occurred()) SWIG_fail;
9114 }
9115 resultobj = result;
9116 return resultobj;
9117 fail:
9118 return NULL;
9119 }
9120
9121
9122 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9123 PyObject *resultobj = 0;
9124 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9125 int arg2 = (int) -1 ;
9126 PyObject *result = 0 ;
9127 void *argp1 = 0 ;
9128 int res1 = 0 ;
9129 int val2 ;
9130 int ecode2 = 0 ;
9131 PyObject * obj0 = 0 ;
9132 PyObject * obj1 = 0 ;
9133 char * kwnames[] = {
9134 (char *) "self",(char *) "sizehint", NULL
9135 };
9136
9137 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
9138 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9139 if (!SWIG_IsOK(res1)) {
9140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9141 }
9142 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9143 if (obj1) {
9144 ecode2 = SWIG_AsVal_int(obj1, &val2);
9145 if (!SWIG_IsOK(ecode2)) {
9146 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
9147 }
9148 arg2 = static_cast< int >(val2);
9149 }
9150 {
9151 PyThreadState* __tstate = wxPyBeginAllowThreads();
9152 result = (PyObject *)(arg1)->readlines(arg2);
9153 wxPyEndAllowThreads(__tstate);
9154 if (PyErr_Occurred()) SWIG_fail;
9155 }
9156 resultobj = result;
9157 return resultobj;
9158 fail:
9159 return NULL;
9160 }
9161
9162
9163 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9164 PyObject *resultobj = 0;
9165 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9166 int arg2 ;
9167 int arg3 = (int) 0 ;
9168 void *argp1 = 0 ;
9169 int res1 = 0 ;
9170 int val2 ;
9171 int ecode2 = 0 ;
9172 int val3 ;
9173 int ecode3 = 0 ;
9174 PyObject * obj0 = 0 ;
9175 PyObject * obj1 = 0 ;
9176 PyObject * obj2 = 0 ;
9177 char * kwnames[] = {
9178 (char *) "self",(char *) "offset",(char *) "whence", NULL
9179 };
9180
9181 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9182 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9183 if (!SWIG_IsOK(res1)) {
9184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9185 }
9186 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9187 ecode2 = SWIG_AsVal_int(obj1, &val2);
9188 if (!SWIG_IsOK(ecode2)) {
9189 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
9190 }
9191 arg2 = static_cast< int >(val2);
9192 if (obj2) {
9193 ecode3 = SWIG_AsVal_int(obj2, &val3);
9194 if (!SWIG_IsOK(ecode3)) {
9195 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
9196 }
9197 arg3 = static_cast< int >(val3);
9198 }
9199 {
9200 PyThreadState* __tstate = wxPyBeginAllowThreads();
9201 (arg1)->seek(arg2,arg3);
9202 wxPyEndAllowThreads(__tstate);
9203 if (PyErr_Occurred()) SWIG_fail;
9204 }
9205 resultobj = SWIG_Py_Void();
9206 return resultobj;
9207 fail:
9208 return NULL;
9209 }
9210
9211
9212 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9213 PyObject *resultobj = 0;
9214 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9215 int result;
9216 void *argp1 = 0 ;
9217 int res1 = 0 ;
9218 PyObject *swig_obj[1] ;
9219
9220 if (!args) SWIG_fail;
9221 swig_obj[0] = args;
9222 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9223 if (!SWIG_IsOK(res1)) {
9224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9225 }
9226 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9227 {
9228 PyThreadState* __tstate = wxPyBeginAllowThreads();
9229 result = (int)(arg1)->tell();
9230 wxPyEndAllowThreads(__tstate);
9231 if (PyErr_Occurred()) SWIG_fail;
9232 }
9233 resultobj = SWIG_From_int(static_cast< int >(result));
9234 return resultobj;
9235 fail:
9236 return NULL;
9237 }
9238
9239
9240 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9241 PyObject *resultobj = 0;
9242 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9243 char result;
9244 void *argp1 = 0 ;
9245 int res1 = 0 ;
9246 PyObject *swig_obj[1] ;
9247
9248 if (!args) SWIG_fail;
9249 swig_obj[0] = args;
9250 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9251 if (!SWIG_IsOK(res1)) {
9252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9253 }
9254 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9255 {
9256 PyThreadState* __tstate = wxPyBeginAllowThreads();
9257 result = (char)(arg1)->Peek();
9258 wxPyEndAllowThreads(__tstate);
9259 if (PyErr_Occurred()) SWIG_fail;
9260 }
9261 resultobj = SWIG_From_char(static_cast< char >(result));
9262 return resultobj;
9263 fail:
9264 return NULL;
9265 }
9266
9267
9268 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9269 PyObject *resultobj = 0;
9270 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9271 char result;
9272 void *argp1 = 0 ;
9273 int res1 = 0 ;
9274 PyObject *swig_obj[1] ;
9275
9276 if (!args) SWIG_fail;
9277 swig_obj[0] = args;
9278 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9279 if (!SWIG_IsOK(res1)) {
9280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9281 }
9282 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9283 {
9284 PyThreadState* __tstate = wxPyBeginAllowThreads();
9285 result = (char)(arg1)->GetC();
9286 wxPyEndAllowThreads(__tstate);
9287 if (PyErr_Occurred()) SWIG_fail;
9288 }
9289 resultobj = SWIG_From_char(static_cast< char >(result));
9290 return resultobj;
9291 fail:
9292 return NULL;
9293 }
9294
9295
9296 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9297 PyObject *resultobj = 0;
9298 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9299 size_t result;
9300 void *argp1 = 0 ;
9301 int res1 = 0 ;
9302 PyObject *swig_obj[1] ;
9303
9304 if (!args) SWIG_fail;
9305 swig_obj[0] = args;
9306 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9307 if (!SWIG_IsOK(res1)) {
9308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9309 }
9310 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9311 {
9312 PyThreadState* __tstate = wxPyBeginAllowThreads();
9313 result = (size_t)(arg1)->LastRead();
9314 wxPyEndAllowThreads(__tstate);
9315 if (PyErr_Occurred()) SWIG_fail;
9316 }
9317 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9318 return resultobj;
9319 fail:
9320 return NULL;
9321 }
9322
9323
9324 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9325 PyObject *resultobj = 0;
9326 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9327 bool result;
9328 void *argp1 = 0 ;
9329 int res1 = 0 ;
9330 PyObject *swig_obj[1] ;
9331
9332 if (!args) SWIG_fail;
9333 swig_obj[0] = args;
9334 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9335 if (!SWIG_IsOK(res1)) {
9336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9337 }
9338 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9339 {
9340 PyThreadState* __tstate = wxPyBeginAllowThreads();
9341 result = (bool)(arg1)->CanRead();
9342 wxPyEndAllowThreads(__tstate);
9343 if (PyErr_Occurred()) SWIG_fail;
9344 }
9345 {
9346 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9347 }
9348 return resultobj;
9349 fail:
9350 return NULL;
9351 }
9352
9353
9354 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9355 PyObject *resultobj = 0;
9356 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9357 bool result;
9358 void *argp1 = 0 ;
9359 int res1 = 0 ;
9360 PyObject *swig_obj[1] ;
9361
9362 if (!args) SWIG_fail;
9363 swig_obj[0] = args;
9364 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9365 if (!SWIG_IsOK(res1)) {
9366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9367 }
9368 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9369 {
9370 PyThreadState* __tstate = wxPyBeginAllowThreads();
9371 result = (bool)(arg1)->Eof();
9372 wxPyEndAllowThreads(__tstate);
9373 if (PyErr_Occurred()) SWIG_fail;
9374 }
9375 {
9376 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9377 }
9378 return resultobj;
9379 fail:
9380 return NULL;
9381 }
9382
9383
9384 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9385 PyObject *resultobj = 0;
9386 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9387 char arg2 ;
9388 bool result;
9389 void *argp1 = 0 ;
9390 int res1 = 0 ;
9391 char val2 ;
9392 int ecode2 = 0 ;
9393 PyObject * obj0 = 0 ;
9394 PyObject * obj1 = 0 ;
9395 char * kwnames[] = {
9396 (char *) "self",(char *) "c", NULL
9397 };
9398
9399 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
9400 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9401 if (!SWIG_IsOK(res1)) {
9402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9403 }
9404 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9405 ecode2 = SWIG_AsVal_char(obj1, &val2);
9406 if (!SWIG_IsOK(ecode2)) {
9407 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
9408 }
9409 arg2 = static_cast< char >(val2);
9410 {
9411 PyThreadState* __tstate = wxPyBeginAllowThreads();
9412 result = (bool)(arg1)->Ungetch(arg2);
9413 wxPyEndAllowThreads(__tstate);
9414 if (PyErr_Occurred()) SWIG_fail;
9415 }
9416 {
9417 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9418 }
9419 return resultobj;
9420 fail:
9421 return NULL;
9422 }
9423
9424
9425 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9426 PyObject *resultobj = 0;
9427 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9428 long arg2 ;
9429 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
9430 long result;
9431 void *argp1 = 0 ;
9432 int res1 = 0 ;
9433 long val2 ;
9434 int ecode2 = 0 ;
9435 int val3 ;
9436 int ecode3 = 0 ;
9437 PyObject * obj0 = 0 ;
9438 PyObject * obj1 = 0 ;
9439 PyObject * obj2 = 0 ;
9440 char * kwnames[] = {
9441 (char *) "self",(char *) "pos",(char *) "mode", NULL
9442 };
9443
9444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9445 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9446 if (!SWIG_IsOK(res1)) {
9447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9448 }
9449 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9450 ecode2 = SWIG_AsVal_long(obj1, &val2);
9451 if (!SWIG_IsOK(ecode2)) {
9452 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
9453 }
9454 arg2 = static_cast< long >(val2);
9455 if (obj2) {
9456 ecode3 = SWIG_AsVal_int(obj2, &val3);
9457 if (!SWIG_IsOK(ecode3)) {
9458 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
9459 }
9460 arg3 = static_cast< wxSeekMode >(val3);
9461 }
9462 {
9463 PyThreadState* __tstate = wxPyBeginAllowThreads();
9464 result = (long)(arg1)->SeekI(arg2,arg3);
9465 wxPyEndAllowThreads(__tstate);
9466 if (PyErr_Occurred()) SWIG_fail;
9467 }
9468 resultobj = SWIG_From_long(static_cast< long >(result));
9469 return resultobj;
9470 fail:
9471 return NULL;
9472 }
9473
9474
9475 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9476 PyObject *resultobj = 0;
9477 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9478 long result;
9479 void *argp1 = 0 ;
9480 int res1 = 0 ;
9481 PyObject *swig_obj[1] ;
9482
9483 if (!args) SWIG_fail;
9484 swig_obj[0] = args;
9485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9486 if (!SWIG_IsOK(res1)) {
9487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9488 }
9489 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9490 {
9491 PyThreadState* __tstate = wxPyBeginAllowThreads();
9492 result = (long)(arg1)->TellI();
9493 wxPyEndAllowThreads(__tstate);
9494 if (PyErr_Occurred()) SWIG_fail;
9495 }
9496 resultobj = SWIG_From_long(static_cast< long >(result));
9497 return resultobj;
9498 fail:
9499 return NULL;
9500 }
9501
9502
9503 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9504 PyObject *obj;
9505 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9506 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
9507 return SWIG_Py_Void();
9508 }
9509
9510 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9511 return SWIG_Python_InitShadowInstance(args);
9512 }
9513
9514 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9515 PyObject *resultobj = 0;
9516 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9517 PyObject *arg2 = (PyObject *) 0 ;
9518 void *argp1 = 0 ;
9519 int res1 = 0 ;
9520 PyObject * obj0 = 0 ;
9521 PyObject * obj1 = 0 ;
9522 char * kwnames[] = {
9523 (char *) "self",(char *) "obj", NULL
9524 };
9525
9526 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
9527 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9528 if (!SWIG_IsOK(res1)) {
9529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
9530 }
9531 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9532 arg2 = obj1;
9533 {
9534 PyThreadState* __tstate = wxPyBeginAllowThreads();
9535 wxOutputStream_write(arg1,arg2);
9536 wxPyEndAllowThreads(__tstate);
9537 if (PyErr_Occurred()) SWIG_fail;
9538 }
9539 resultobj = SWIG_Py_Void();
9540 return resultobj;
9541 fail:
9542 return NULL;
9543 }
9544
9545
9546 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9547 PyObject *resultobj = 0;
9548 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9549 size_t result;
9550 void *argp1 = 0 ;
9551 int res1 = 0 ;
9552 PyObject *swig_obj[1] ;
9553
9554 if (!args) SWIG_fail;
9555 swig_obj[0] = args;
9556 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9557 if (!SWIG_IsOK(res1)) {
9558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
9559 }
9560 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9561 {
9562 PyThreadState* __tstate = wxPyBeginAllowThreads();
9563 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
9564 wxPyEndAllowThreads(__tstate);
9565 if (PyErr_Occurred()) SWIG_fail;
9566 }
9567 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9568 return resultobj;
9569 fail:
9570 return NULL;
9571 }
9572
9573
9574 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9575 PyObject *obj;
9576 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9577 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
9578 return SWIG_Py_Void();
9579 }
9580
9581 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9582 PyObject *resultobj = 0;
9583 wxInputStream *arg1 = (wxInputStream *) 0 ;
9584 wxString *arg2 = 0 ;
9585 wxString *arg3 = 0 ;
9586 wxString *arg4 = 0 ;
9587 wxDateTime arg5 ;
9588 wxFSFile *result = 0 ;
9589 wxPyInputStream *temp1 ;
9590 bool temp2 = false ;
9591 bool temp3 = false ;
9592 bool temp4 = false ;
9593 void *argp5 ;
9594 int res5 = 0 ;
9595 PyObject * obj0 = 0 ;
9596 PyObject * obj1 = 0 ;
9597 PyObject * obj2 = 0 ;
9598 PyObject * obj3 = 0 ;
9599 PyObject * obj4 = 0 ;
9600 char * kwnames[] = {
9601 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
9602 };
9603
9604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9605 {
9606 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
9607 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
9608 } else {
9609 PyErr_Clear(); // clear the failure of the wxPyConvert above
9610 arg1 = wxPyCBInputStream_create(obj0, true);
9611 if (arg1 == NULL) {
9612 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
9613 SWIG_fail;
9614 }
9615 }
9616 }
9617 {
9618 arg2 = wxString_in_helper(obj1);
9619 if (arg2 == NULL) SWIG_fail;
9620 temp2 = true;
9621 }
9622 {
9623 arg3 = wxString_in_helper(obj2);
9624 if (arg3 == NULL) SWIG_fail;
9625 temp3 = true;
9626 }
9627 {
9628 arg4 = wxString_in_helper(obj3);
9629 if (arg4 == NULL) SWIG_fail;
9630 temp4 = true;
9631 }
9632 {
9633 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
9634 if (!SWIG_IsOK(res5)) {
9635 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9636 }
9637 if (!argp5) {
9638 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9639 } else {
9640 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
9641 arg5 = *temp;
9642 if (SWIG_IsNewObj(res5)) delete temp;
9643 }
9644 }
9645 {
9646 PyThreadState* __tstate = wxPyBeginAllowThreads();
9647 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
9648 wxPyEndAllowThreads(__tstate);
9649 if (PyErr_Occurred()) SWIG_fail;
9650 }
9651 {
9652 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
9653 }
9654 {
9655 if (temp2)
9656 delete arg2;
9657 }
9658 {
9659 if (temp3)
9660 delete arg3;
9661 }
9662 {
9663 if (temp4)
9664 delete arg4;
9665 }
9666 return resultobj;
9667 fail:
9668 {
9669 if (temp2)
9670 delete arg2;
9671 }
9672 {
9673 if (temp3)
9674 delete arg3;
9675 }
9676 {
9677 if (temp4)
9678 delete arg4;
9679 }
9680 return NULL;
9681 }
9682
9683
9684 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9685 PyObject *resultobj = 0;
9686 wxFSFile *arg1 = (wxFSFile *) 0 ;
9687 void *argp1 = 0 ;
9688 int res1 = 0 ;
9689 PyObject *swig_obj[1] ;
9690
9691 if (!args) SWIG_fail;
9692 swig_obj[0] = args;
9693 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
9694 if (!SWIG_IsOK(res1)) {
9695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
9696 }
9697 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9698 {
9699 PyThreadState* __tstate = wxPyBeginAllowThreads();
9700 delete arg1;
9701
9702 wxPyEndAllowThreads(__tstate);
9703 if (PyErr_Occurred()) SWIG_fail;
9704 }
9705 resultobj = SWIG_Py_Void();
9706 return resultobj;
9707 fail:
9708 return NULL;
9709 }
9710
9711
9712 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9713 PyObject *resultobj = 0;
9714 wxFSFile *arg1 = (wxFSFile *) 0 ;
9715 wxInputStream *result = 0 ;
9716 void *argp1 = 0 ;
9717 int res1 = 0 ;
9718 PyObject *swig_obj[1] ;
9719
9720 if (!args) SWIG_fail;
9721 swig_obj[0] = args;
9722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9723 if (!SWIG_IsOK(res1)) {
9724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
9725 }
9726 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9727 {
9728 PyThreadState* __tstate = wxPyBeginAllowThreads();
9729 result = (wxInputStream *)(arg1)->GetStream();
9730 wxPyEndAllowThreads(__tstate);
9731 if (PyErr_Occurred()) SWIG_fail;
9732 }
9733 {
9734 wxPyInputStream * _ptr = NULL;
9735
9736 if (result) {
9737 _ptr = new wxPyInputStream(result);
9738 }
9739 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
9740 }
9741 return resultobj;
9742 fail:
9743 return NULL;
9744 }
9745
9746
9747 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9748 PyObject *resultobj = 0;
9749 wxFSFile *arg1 = (wxFSFile *) 0 ;
9750 wxString *result = 0 ;
9751 void *argp1 = 0 ;
9752 int res1 = 0 ;
9753 PyObject *swig_obj[1] ;
9754
9755 if (!args) SWIG_fail;
9756 swig_obj[0] = args;
9757 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9758 if (!SWIG_IsOK(res1)) {
9759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
9760 }
9761 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9762 {
9763 PyThreadState* __tstate = wxPyBeginAllowThreads();
9764 {
9765 wxString const &_result_ref = (arg1)->GetMimeType();
9766 result = (wxString *) &_result_ref;
9767 }
9768 wxPyEndAllowThreads(__tstate);
9769 if (PyErr_Occurred()) SWIG_fail;
9770 }
9771 {
9772 #if wxUSE_UNICODE
9773 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9774 #else
9775 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9776 #endif
9777 }
9778 return resultobj;
9779 fail:
9780 return NULL;
9781 }
9782
9783
9784 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9785 PyObject *resultobj = 0;
9786 wxFSFile *arg1 = (wxFSFile *) 0 ;
9787 wxString *result = 0 ;
9788 void *argp1 = 0 ;
9789 int res1 = 0 ;
9790 PyObject *swig_obj[1] ;
9791
9792 if (!args) SWIG_fail;
9793 swig_obj[0] = args;
9794 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9795 if (!SWIG_IsOK(res1)) {
9796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
9797 }
9798 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9799 {
9800 PyThreadState* __tstate = wxPyBeginAllowThreads();
9801 {
9802 wxString const &_result_ref = (arg1)->GetLocation();
9803 result = (wxString *) &_result_ref;
9804 }
9805 wxPyEndAllowThreads(__tstate);
9806 if (PyErr_Occurred()) SWIG_fail;
9807 }
9808 {
9809 #if wxUSE_UNICODE
9810 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9811 #else
9812 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9813 #endif
9814 }
9815 return resultobj;
9816 fail:
9817 return NULL;
9818 }
9819
9820
9821 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9822 PyObject *resultobj = 0;
9823 wxFSFile *arg1 = (wxFSFile *) 0 ;
9824 wxString *result = 0 ;
9825 void *argp1 = 0 ;
9826 int res1 = 0 ;
9827 PyObject *swig_obj[1] ;
9828
9829 if (!args) SWIG_fail;
9830 swig_obj[0] = args;
9831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9832 if (!SWIG_IsOK(res1)) {
9833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
9834 }
9835 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9836 {
9837 PyThreadState* __tstate = wxPyBeginAllowThreads();
9838 {
9839 wxString const &_result_ref = (arg1)->GetAnchor();
9840 result = (wxString *) &_result_ref;
9841 }
9842 wxPyEndAllowThreads(__tstate);
9843 if (PyErr_Occurred()) SWIG_fail;
9844 }
9845 {
9846 #if wxUSE_UNICODE
9847 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9848 #else
9849 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9850 #endif
9851 }
9852 return resultobj;
9853 fail:
9854 return NULL;
9855 }
9856
9857
9858 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9859 PyObject *resultobj = 0;
9860 wxFSFile *arg1 = (wxFSFile *) 0 ;
9861 wxDateTime result;
9862 void *argp1 = 0 ;
9863 int res1 = 0 ;
9864 PyObject *swig_obj[1] ;
9865
9866 if (!args) SWIG_fail;
9867 swig_obj[0] = args;
9868 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9869 if (!SWIG_IsOK(res1)) {
9870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
9871 }
9872 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9873 {
9874 PyThreadState* __tstate = wxPyBeginAllowThreads();
9875 result = (arg1)->GetModificationTime();
9876 wxPyEndAllowThreads(__tstate);
9877 if (PyErr_Occurred()) SWIG_fail;
9878 }
9879 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
9880 return resultobj;
9881 fail:
9882 return NULL;
9883 }
9884
9885
9886 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9887 PyObject *obj;
9888 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9889 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
9890 return SWIG_Py_Void();
9891 }
9892
9893 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9894 return SWIG_Python_InitShadowInstance(args);
9895 }
9896
9897 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9898 PyObject *resultobj = 0;
9899 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
9900 void *argp1 = 0 ;
9901 int res1 = 0 ;
9902 PyObject *swig_obj[1] ;
9903
9904 if (!args) SWIG_fail;
9905 swig_obj[0] = args;
9906 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
9907 if (!SWIG_IsOK(res1)) {
9908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
9909 }
9910 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
9911 {
9912 PyThreadState* __tstate = wxPyBeginAllowThreads();
9913 delete arg1;
9914
9915 wxPyEndAllowThreads(__tstate);
9916 if (PyErr_Occurred()) SWIG_fail;
9917 }
9918 resultobj = SWIG_Py_Void();
9919 return resultobj;
9920 fail:
9921 return NULL;
9922 }
9923
9924
9925 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9926 PyObject *obj;
9927 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9928 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
9929 return SWIG_Py_Void();
9930 }
9931
9932 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9933 PyObject *resultobj = 0;
9934 wxPyFileSystemHandler *result = 0 ;
9935
9936 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
9937 {
9938 PyThreadState* __tstate = wxPyBeginAllowThreads();
9939 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
9940 wxPyEndAllowThreads(__tstate);
9941 if (PyErr_Occurred()) SWIG_fail;
9942 }
9943 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
9944 return resultobj;
9945 fail:
9946 return NULL;
9947 }
9948
9949
9950 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9951 PyObject *resultobj = 0;
9952 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
9953 PyObject *arg2 = (PyObject *) 0 ;
9954 PyObject *arg3 = (PyObject *) 0 ;
9955 void *argp1 = 0 ;
9956 int res1 = 0 ;
9957 PyObject * obj0 = 0 ;
9958 PyObject * obj1 = 0 ;
9959 PyObject * obj2 = 0 ;
9960 char * kwnames[] = {
9961 (char *) "self",(char *) "self",(char *) "_class", NULL
9962 };
9963
9964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9965 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
9966 if (!SWIG_IsOK(res1)) {
9967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
9968 }
9969 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
9970 arg2 = obj1;
9971 arg3 = obj2;
9972 {
9973 PyThreadState* __tstate = wxPyBeginAllowThreads();
9974 (arg1)->_setCallbackInfo(arg2,arg3);
9975 wxPyEndAllowThreads(__tstate);
9976 if (PyErr_Occurred()) SWIG_fail;
9977 }
9978 resultobj = SWIG_Py_Void();
9979 return resultobj;
9980 fail:
9981 return NULL;
9982 }
9983
9984
9985 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9986 PyObject *resultobj = 0;
9987 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
9988 wxString *arg2 = 0 ;
9989 bool result;
9990 void *argp1 = 0 ;
9991 int res1 = 0 ;
9992 bool temp2 = false ;
9993 PyObject * obj0 = 0 ;
9994 PyObject * obj1 = 0 ;
9995 char * kwnames[] = {
9996 (char *) "self",(char *) "location", NULL
9997 };
9998
9999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10001 if (!SWIG_IsOK(res1)) {
10002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10003 }
10004 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10005 {
10006 arg2 = wxString_in_helper(obj1);
10007 if (arg2 == NULL) SWIG_fail;
10008 temp2 = true;
10009 }
10010 {
10011 PyThreadState* __tstate = wxPyBeginAllowThreads();
10012 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10013 wxPyEndAllowThreads(__tstate);
10014 if (PyErr_Occurred()) SWIG_fail;
10015 }
10016 {
10017 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10018 }
10019 {
10020 if (temp2)
10021 delete arg2;
10022 }
10023 return resultobj;
10024 fail:
10025 {
10026 if (temp2)
10027 delete arg2;
10028 }
10029 return NULL;
10030 }
10031
10032
10033 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10034 PyObject *resultobj = 0;
10035 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10036 wxFileSystem *arg2 = 0 ;
10037 wxString *arg3 = 0 ;
10038 wxFSFile *result = 0 ;
10039 void *argp1 = 0 ;
10040 int res1 = 0 ;
10041 void *argp2 = 0 ;
10042 int res2 = 0 ;
10043 bool temp3 = false ;
10044 PyObject * obj0 = 0 ;
10045 PyObject * obj1 = 0 ;
10046 PyObject * obj2 = 0 ;
10047 char * kwnames[] = {
10048 (char *) "self",(char *) "fs",(char *) "location", NULL
10049 };
10050
10051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10052 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10053 if (!SWIG_IsOK(res1)) {
10054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10055 }
10056 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10057 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10058 if (!SWIG_IsOK(res2)) {
10059 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10060 }
10061 if (!argp2) {
10062 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10063 }
10064 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10065 {
10066 arg3 = wxString_in_helper(obj2);
10067 if (arg3 == NULL) SWIG_fail;
10068 temp3 = true;
10069 }
10070 {
10071 PyThreadState* __tstate = wxPyBeginAllowThreads();
10072 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10073 wxPyEndAllowThreads(__tstate);
10074 if (PyErr_Occurred()) SWIG_fail;
10075 }
10076 {
10077 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
10078 }
10079 {
10080 if (temp3)
10081 delete arg3;
10082 }
10083 return resultobj;
10084 fail:
10085 {
10086 if (temp3)
10087 delete arg3;
10088 }
10089 return NULL;
10090 }
10091
10092
10093 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10094 PyObject *resultobj = 0;
10095 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10096 wxString *arg2 = 0 ;
10097 int arg3 = (int) 0 ;
10098 wxString result;
10099 void *argp1 = 0 ;
10100 int res1 = 0 ;
10101 bool temp2 = false ;
10102 int val3 ;
10103 int ecode3 = 0 ;
10104 PyObject * obj0 = 0 ;
10105 PyObject * obj1 = 0 ;
10106 PyObject * obj2 = 0 ;
10107 char * kwnames[] = {
10108 (char *) "self",(char *) "spec",(char *) "flags", NULL
10109 };
10110
10111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10113 if (!SWIG_IsOK(res1)) {
10114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10115 }
10116 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10117 {
10118 arg2 = wxString_in_helper(obj1);
10119 if (arg2 == NULL) SWIG_fail;
10120 temp2 = true;
10121 }
10122 if (obj2) {
10123 ecode3 = SWIG_AsVal_int(obj2, &val3);
10124 if (!SWIG_IsOK(ecode3)) {
10125 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
10126 }
10127 arg3 = static_cast< int >(val3);
10128 }
10129 {
10130 PyThreadState* __tstate = wxPyBeginAllowThreads();
10131 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10132 wxPyEndAllowThreads(__tstate);
10133 if (PyErr_Occurred()) SWIG_fail;
10134 }
10135 {
10136 #if wxUSE_UNICODE
10137 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10138 #else
10139 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10140 #endif
10141 }
10142 {
10143 if (temp2)
10144 delete arg2;
10145 }
10146 return resultobj;
10147 fail:
10148 {
10149 if (temp2)
10150 delete arg2;
10151 }
10152 return NULL;
10153 }
10154
10155
10156 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10157 PyObject *resultobj = 0;
10158 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10159 wxString result;
10160 void *argp1 = 0 ;
10161 int res1 = 0 ;
10162 PyObject *swig_obj[1] ;
10163
10164 if (!args) SWIG_fail;
10165 swig_obj[0] = args;
10166 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10167 if (!SWIG_IsOK(res1)) {
10168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10169 }
10170 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10171 {
10172 PyThreadState* __tstate = wxPyBeginAllowThreads();
10173 result = (arg1)->FindNext();
10174 wxPyEndAllowThreads(__tstate);
10175 if (PyErr_Occurred()) SWIG_fail;
10176 }
10177 {
10178 #if wxUSE_UNICODE
10179 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10180 #else
10181 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10182 #endif
10183 }
10184 return resultobj;
10185 fail:
10186 return NULL;
10187 }
10188
10189
10190 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10191 PyObject *resultobj = 0;
10192 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10193 wxString *arg2 = 0 ;
10194 wxString result;
10195 void *argp1 = 0 ;
10196 int res1 = 0 ;
10197 bool temp2 = false ;
10198 PyObject * obj0 = 0 ;
10199 PyObject * obj1 = 0 ;
10200 char * kwnames[] = {
10201 (char *) "self",(char *) "location", NULL
10202 };
10203
10204 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
10205 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10206 if (!SWIG_IsOK(res1)) {
10207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10208 }
10209 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10210 {
10211 arg2 = wxString_in_helper(obj1);
10212 if (arg2 == NULL) SWIG_fail;
10213 temp2 = true;
10214 }
10215 {
10216 PyThreadState* __tstate = wxPyBeginAllowThreads();
10217 result = (arg1)->GetProtocol((wxString const &)*arg2);
10218 wxPyEndAllowThreads(__tstate);
10219 if (PyErr_Occurred()) SWIG_fail;
10220 }
10221 {
10222 #if wxUSE_UNICODE
10223 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10224 #else
10225 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10226 #endif
10227 }
10228 {
10229 if (temp2)
10230 delete arg2;
10231 }
10232 return resultobj;
10233 fail:
10234 {
10235 if (temp2)
10236 delete arg2;
10237 }
10238 return NULL;
10239 }
10240
10241
10242 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10243 PyObject *resultobj = 0;
10244 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10245 wxString *arg2 = 0 ;
10246 wxString result;
10247 void *argp1 = 0 ;
10248 int res1 = 0 ;
10249 bool temp2 = false ;
10250 PyObject * obj0 = 0 ;
10251 PyObject * obj1 = 0 ;
10252 char * kwnames[] = {
10253 (char *) "self",(char *) "location", NULL
10254 };
10255
10256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10258 if (!SWIG_IsOK(res1)) {
10259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10260 }
10261 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10262 {
10263 arg2 = wxString_in_helper(obj1);
10264 if (arg2 == NULL) SWIG_fail;
10265 temp2 = true;
10266 }
10267 {
10268 PyThreadState* __tstate = wxPyBeginAllowThreads();
10269 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
10270 wxPyEndAllowThreads(__tstate);
10271 if (PyErr_Occurred()) SWIG_fail;
10272 }
10273 {
10274 #if wxUSE_UNICODE
10275 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10276 #else
10277 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10278 #endif
10279 }
10280 {
10281 if (temp2)
10282 delete arg2;
10283 }
10284 return resultobj;
10285 fail:
10286 {
10287 if (temp2)
10288 delete arg2;
10289 }
10290 return NULL;
10291 }
10292
10293
10294 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10295 PyObject *resultobj = 0;
10296 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10297 wxString *arg2 = 0 ;
10298 wxString result;
10299 void *argp1 = 0 ;
10300 int res1 = 0 ;
10301 bool temp2 = false ;
10302 PyObject * obj0 = 0 ;
10303 PyObject * obj1 = 0 ;
10304 char * kwnames[] = {
10305 (char *) "self",(char *) "location", NULL
10306 };
10307
10308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
10309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10310 if (!SWIG_IsOK(res1)) {
10311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10312 }
10313 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10314 {
10315 arg2 = wxString_in_helper(obj1);
10316 if (arg2 == NULL) SWIG_fail;
10317 temp2 = true;
10318 }
10319 {
10320 PyThreadState* __tstate = wxPyBeginAllowThreads();
10321 result = (arg1)->GetAnchor((wxString const &)*arg2);
10322 wxPyEndAllowThreads(__tstate);
10323 if (PyErr_Occurred()) SWIG_fail;
10324 }
10325 {
10326 #if wxUSE_UNICODE
10327 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10328 #else
10329 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10330 #endif
10331 }
10332 {
10333 if (temp2)
10334 delete arg2;
10335 }
10336 return resultobj;
10337 fail:
10338 {
10339 if (temp2)
10340 delete arg2;
10341 }
10342 return NULL;
10343 }
10344
10345
10346 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10347 PyObject *resultobj = 0;
10348 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10349 wxString *arg2 = 0 ;
10350 wxString result;
10351 void *argp1 = 0 ;
10352 int res1 = 0 ;
10353 bool temp2 = false ;
10354 PyObject * obj0 = 0 ;
10355 PyObject * obj1 = 0 ;
10356 char * kwnames[] = {
10357 (char *) "self",(char *) "location", NULL
10358 };
10359
10360 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10361 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10362 if (!SWIG_IsOK(res1)) {
10363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10364 }
10365 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10366 {
10367 arg2 = wxString_in_helper(obj1);
10368 if (arg2 == NULL) SWIG_fail;
10369 temp2 = true;
10370 }
10371 {
10372 PyThreadState* __tstate = wxPyBeginAllowThreads();
10373 result = (arg1)->GetRightLocation((wxString const &)*arg2);
10374 wxPyEndAllowThreads(__tstate);
10375 if (PyErr_Occurred()) SWIG_fail;
10376 }
10377 {
10378 #if wxUSE_UNICODE
10379 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10380 #else
10381 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10382 #endif
10383 }
10384 {
10385 if (temp2)
10386 delete arg2;
10387 }
10388 return resultobj;
10389 fail:
10390 {
10391 if (temp2)
10392 delete arg2;
10393 }
10394 return NULL;
10395 }
10396
10397
10398 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10399 PyObject *resultobj = 0;
10400 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10401 wxString *arg2 = 0 ;
10402 wxString result;
10403 void *argp1 = 0 ;
10404 int res1 = 0 ;
10405 bool temp2 = false ;
10406 PyObject * obj0 = 0 ;
10407 PyObject * obj1 = 0 ;
10408 char * kwnames[] = {
10409 (char *) "self",(char *) "location", NULL
10410 };
10411
10412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
10413 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10414 if (!SWIG_IsOK(res1)) {
10415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10416 }
10417 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10418 {
10419 arg2 = wxString_in_helper(obj1);
10420 if (arg2 == NULL) SWIG_fail;
10421 temp2 = true;
10422 }
10423 {
10424 PyThreadState* __tstate = wxPyBeginAllowThreads();
10425 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
10426 wxPyEndAllowThreads(__tstate);
10427 if (PyErr_Occurred()) SWIG_fail;
10428 }
10429 {
10430 #if wxUSE_UNICODE
10431 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10432 #else
10433 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10434 #endif
10435 }
10436 {
10437 if (temp2)
10438 delete arg2;
10439 }
10440 return resultobj;
10441 fail:
10442 {
10443 if (temp2)
10444 delete arg2;
10445 }
10446 return NULL;
10447 }
10448
10449
10450 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10451 PyObject *obj;
10452 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10453 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
10454 return SWIG_Py_Void();
10455 }
10456
10457 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10458 return SWIG_Python_InitShadowInstance(args);
10459 }
10460
10461 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10462 PyObject *resultobj = 0;
10463 wxFileSystem *result = 0 ;
10464
10465 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
10466 {
10467 PyThreadState* __tstate = wxPyBeginAllowThreads();
10468 result = (wxFileSystem *)new wxFileSystem();
10469 wxPyEndAllowThreads(__tstate);
10470 if (PyErr_Occurred()) SWIG_fail;
10471 }
10472 {
10473 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
10474 }
10475 return resultobj;
10476 fail:
10477 return NULL;
10478 }
10479
10480
10481 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10482 PyObject *resultobj = 0;
10483 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10484 void *argp1 = 0 ;
10485 int res1 = 0 ;
10486 PyObject *swig_obj[1] ;
10487
10488 if (!args) SWIG_fail;
10489 swig_obj[0] = args;
10490 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
10491 if (!SWIG_IsOK(res1)) {
10492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10493 }
10494 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10495 {
10496 PyThreadState* __tstate = wxPyBeginAllowThreads();
10497 delete arg1;
10498
10499 wxPyEndAllowThreads(__tstate);
10500 if (PyErr_Occurred()) SWIG_fail;
10501 }
10502 resultobj = SWIG_Py_Void();
10503 return resultobj;
10504 fail:
10505 return NULL;
10506 }
10507
10508
10509 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10510 PyObject *resultobj = 0;
10511 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10512 wxString *arg2 = 0 ;
10513 bool arg3 = (bool) false ;
10514 void *argp1 = 0 ;
10515 int res1 = 0 ;
10516 bool temp2 = false ;
10517 bool val3 ;
10518 int ecode3 = 0 ;
10519 PyObject * obj0 = 0 ;
10520 PyObject * obj1 = 0 ;
10521 PyObject * obj2 = 0 ;
10522 char * kwnames[] = {
10523 (char *) "self",(char *) "location",(char *) "is_dir", NULL
10524 };
10525
10526 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10527 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10528 if (!SWIG_IsOK(res1)) {
10529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10530 }
10531 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10532 {
10533 arg2 = wxString_in_helper(obj1);
10534 if (arg2 == NULL) SWIG_fail;
10535 temp2 = true;
10536 }
10537 if (obj2) {
10538 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10539 if (!SWIG_IsOK(ecode3)) {
10540 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
10541 }
10542 arg3 = static_cast< bool >(val3);
10543 }
10544 {
10545 PyThreadState* __tstate = wxPyBeginAllowThreads();
10546 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
10547 wxPyEndAllowThreads(__tstate);
10548 if (PyErr_Occurred()) SWIG_fail;
10549 }
10550 resultobj = SWIG_Py_Void();
10551 {
10552 if (temp2)
10553 delete arg2;
10554 }
10555 return resultobj;
10556 fail:
10557 {
10558 if (temp2)
10559 delete arg2;
10560 }
10561 return NULL;
10562 }
10563
10564
10565 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10566 PyObject *resultobj = 0;
10567 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10568 wxString result;
10569 void *argp1 = 0 ;
10570 int res1 = 0 ;
10571 PyObject *swig_obj[1] ;
10572
10573 if (!args) SWIG_fail;
10574 swig_obj[0] = args;
10575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10576 if (!SWIG_IsOK(res1)) {
10577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10578 }
10579 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10580 {
10581 PyThreadState* __tstate = wxPyBeginAllowThreads();
10582 result = (arg1)->GetPath();
10583 wxPyEndAllowThreads(__tstate);
10584 if (PyErr_Occurred()) SWIG_fail;
10585 }
10586 {
10587 #if wxUSE_UNICODE
10588 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10589 #else
10590 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10591 #endif
10592 }
10593 return resultobj;
10594 fail:
10595 return NULL;
10596 }
10597
10598
10599 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10600 PyObject *resultobj = 0;
10601 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10602 wxString *arg2 = 0 ;
10603 wxFSFile *result = 0 ;
10604 void *argp1 = 0 ;
10605 int res1 = 0 ;
10606 bool temp2 = false ;
10607 PyObject * obj0 = 0 ;
10608 PyObject * obj1 = 0 ;
10609 char * kwnames[] = {
10610 (char *) "self",(char *) "location", NULL
10611 };
10612
10613 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
10614 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10615 if (!SWIG_IsOK(res1)) {
10616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10617 }
10618 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10619 {
10620 arg2 = wxString_in_helper(obj1);
10621 if (arg2 == NULL) SWIG_fail;
10622 temp2 = true;
10623 }
10624 {
10625 PyThreadState* __tstate = wxPyBeginAllowThreads();
10626 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
10627 wxPyEndAllowThreads(__tstate);
10628 if (PyErr_Occurred()) SWIG_fail;
10629 }
10630 {
10631 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
10632 }
10633 {
10634 if (temp2)
10635 delete arg2;
10636 }
10637 return resultobj;
10638 fail:
10639 {
10640 if (temp2)
10641 delete arg2;
10642 }
10643 return NULL;
10644 }
10645
10646
10647 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10648 PyObject *resultobj = 0;
10649 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10650 wxString *arg2 = 0 ;
10651 int arg3 = (int) 0 ;
10652 wxString result;
10653 void *argp1 = 0 ;
10654 int res1 = 0 ;
10655 bool temp2 = false ;
10656 int val3 ;
10657 int ecode3 = 0 ;
10658 PyObject * obj0 = 0 ;
10659 PyObject * obj1 = 0 ;
10660 PyObject * obj2 = 0 ;
10661 char * kwnames[] = {
10662 (char *) "self",(char *) "spec",(char *) "flags", NULL
10663 };
10664
10665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10666 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10667 if (!SWIG_IsOK(res1)) {
10668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10669 }
10670 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10671 {
10672 arg2 = wxString_in_helper(obj1);
10673 if (arg2 == NULL) SWIG_fail;
10674 temp2 = true;
10675 }
10676 if (obj2) {
10677 ecode3 = SWIG_AsVal_int(obj2, &val3);
10678 if (!SWIG_IsOK(ecode3)) {
10679 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
10680 }
10681 arg3 = static_cast< int >(val3);
10682 }
10683 {
10684 PyThreadState* __tstate = wxPyBeginAllowThreads();
10685 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10686 wxPyEndAllowThreads(__tstate);
10687 if (PyErr_Occurred()) SWIG_fail;
10688 }
10689 {
10690 #if wxUSE_UNICODE
10691 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10692 #else
10693 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10694 #endif
10695 }
10696 {
10697 if (temp2)
10698 delete arg2;
10699 }
10700 return resultobj;
10701 fail:
10702 {
10703 if (temp2)
10704 delete arg2;
10705 }
10706 return NULL;
10707 }
10708
10709
10710 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10711 PyObject *resultobj = 0;
10712 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10713 wxString result;
10714 void *argp1 = 0 ;
10715 int res1 = 0 ;
10716 PyObject *swig_obj[1] ;
10717
10718 if (!args) SWIG_fail;
10719 swig_obj[0] = args;
10720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10721 if (!SWIG_IsOK(res1)) {
10722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10723 }
10724 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10725 {
10726 PyThreadState* __tstate = wxPyBeginAllowThreads();
10727 result = (arg1)->FindNext();
10728 wxPyEndAllowThreads(__tstate);
10729 if (PyErr_Occurred()) SWIG_fail;
10730 }
10731 {
10732 #if wxUSE_UNICODE
10733 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10734 #else
10735 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10736 #endif
10737 }
10738 return resultobj;
10739 fail:
10740 return NULL;
10741 }
10742
10743
10744 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10745 PyObject *resultobj = 0;
10746 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10747 int res1 = 0 ;
10748 PyObject * obj0 = 0 ;
10749 char * kwnames[] = {
10750 (char *) "handler", NULL
10751 };
10752
10753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
10754 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
10755 if (!SWIG_IsOK(res1)) {
10756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10757 }
10758 {
10759 PyThreadState* __tstate = wxPyBeginAllowThreads();
10760 wxFileSystem::AddHandler(arg1);
10761 wxPyEndAllowThreads(__tstate);
10762 if (PyErr_Occurred()) SWIG_fail;
10763 }
10764 resultobj = SWIG_Py_Void();
10765 return resultobj;
10766 fail:
10767 return NULL;
10768 }
10769
10770
10771 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10772 PyObject *resultobj = 0;
10773
10774 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
10775 {
10776 PyThreadState* __tstate = wxPyBeginAllowThreads();
10777 wxFileSystem::CleanUpHandlers();
10778 wxPyEndAllowThreads(__tstate);
10779 if (PyErr_Occurred()) SWIG_fail;
10780 }
10781 resultobj = SWIG_Py_Void();
10782 return resultobj;
10783 fail:
10784 return NULL;
10785 }
10786
10787
10788 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10789 PyObject *resultobj = 0;
10790 wxString *arg1 = 0 ;
10791 wxString result;
10792 bool temp1 = false ;
10793 PyObject * obj0 = 0 ;
10794 char * kwnames[] = {
10795 (char *) "filename", NULL
10796 };
10797
10798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
10799 {
10800 arg1 = wxString_in_helper(obj0);
10801 if (arg1 == NULL) SWIG_fail;
10802 temp1 = true;
10803 }
10804 {
10805 PyThreadState* __tstate = wxPyBeginAllowThreads();
10806 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
10807 wxPyEndAllowThreads(__tstate);
10808 if (PyErr_Occurred()) SWIG_fail;
10809 }
10810 {
10811 #if wxUSE_UNICODE
10812 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10813 #else
10814 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10815 #endif
10816 }
10817 {
10818 if (temp1)
10819 delete arg1;
10820 }
10821 return resultobj;
10822 fail:
10823 {
10824 if (temp1)
10825 delete arg1;
10826 }
10827 return NULL;
10828 }
10829
10830
10831 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10832 PyObject *resultobj = 0;
10833 wxString *arg1 = 0 ;
10834 wxString result;
10835 bool temp1 = false ;
10836 PyObject * obj0 = 0 ;
10837 char * kwnames[] = {
10838 (char *) "url", NULL
10839 };
10840
10841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
10842 {
10843 arg1 = wxString_in_helper(obj0);
10844 if (arg1 == NULL) SWIG_fail;
10845 temp1 = true;
10846 }
10847 {
10848 PyThreadState* __tstate = wxPyBeginAllowThreads();
10849 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
10850 wxPyEndAllowThreads(__tstate);
10851 if (PyErr_Occurred()) SWIG_fail;
10852 }
10853 {
10854 #if wxUSE_UNICODE
10855 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10856 #else
10857 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10858 #endif
10859 }
10860 {
10861 if (temp1)
10862 delete arg1;
10863 }
10864 return resultobj;
10865 fail:
10866 {
10867 if (temp1)
10868 delete arg1;
10869 }
10870 return NULL;
10871 }
10872
10873
10874 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10875 PyObject *obj;
10876 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10877 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
10878 return SWIG_Py_Void();
10879 }
10880
10881 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10882 return SWIG_Python_InitShadowInstance(args);
10883 }
10884
10885 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10886 PyObject *resultobj = 0;
10887 wxInternetFSHandler *result = 0 ;
10888
10889 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
10890 {
10891 PyThreadState* __tstate = wxPyBeginAllowThreads();
10892 result = (wxInternetFSHandler *)new wxInternetFSHandler();
10893 wxPyEndAllowThreads(__tstate);
10894 if (PyErr_Occurred()) SWIG_fail;
10895 }
10896 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
10897 return resultobj;
10898 fail:
10899 return NULL;
10900 }
10901
10902
10903 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10904 PyObject *resultobj = 0;
10905 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
10906 wxString *arg2 = 0 ;
10907 bool result;
10908 void *argp1 = 0 ;
10909 int res1 = 0 ;
10910 bool temp2 = false ;
10911 PyObject * obj0 = 0 ;
10912 PyObject * obj1 = 0 ;
10913 char * kwnames[] = {
10914 (char *) "self",(char *) "location", NULL
10915 };
10916
10917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10918 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
10919 if (!SWIG_IsOK(res1)) {
10920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
10921 }
10922 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
10923 {
10924 arg2 = wxString_in_helper(obj1);
10925 if (arg2 == NULL) SWIG_fail;
10926 temp2 = true;
10927 }
10928 {
10929 PyThreadState* __tstate = wxPyBeginAllowThreads();
10930 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10931 wxPyEndAllowThreads(__tstate);
10932 if (PyErr_Occurred()) SWIG_fail;
10933 }
10934 {
10935 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10936 }
10937 {
10938 if (temp2)
10939 delete arg2;
10940 }
10941 return resultobj;
10942 fail:
10943 {
10944 if (temp2)
10945 delete arg2;
10946 }
10947 return NULL;
10948 }
10949
10950
10951 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10952 PyObject *resultobj = 0;
10953 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
10954 wxFileSystem *arg2 = 0 ;
10955 wxString *arg3 = 0 ;
10956 wxFSFile *result = 0 ;
10957 void *argp1 = 0 ;
10958 int res1 = 0 ;
10959 void *argp2 = 0 ;
10960 int res2 = 0 ;
10961 bool temp3 = false ;
10962 PyObject * obj0 = 0 ;
10963 PyObject * obj1 = 0 ;
10964 PyObject * obj2 = 0 ;
10965 char * kwnames[] = {
10966 (char *) "self",(char *) "fs",(char *) "location", NULL
10967 };
10968
10969 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10970 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
10971 if (!SWIG_IsOK(res1)) {
10972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
10973 }
10974 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
10975 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10976 if (!SWIG_IsOK(res2)) {
10977 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10978 }
10979 if (!argp2) {
10980 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10981 }
10982 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10983 {
10984 arg3 = wxString_in_helper(obj2);
10985 if (arg3 == NULL) SWIG_fail;
10986 temp3 = true;
10987 }
10988 {
10989 PyThreadState* __tstate = wxPyBeginAllowThreads();
10990 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10991 wxPyEndAllowThreads(__tstate);
10992 if (PyErr_Occurred()) SWIG_fail;
10993 }
10994 {
10995 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
10996 }
10997 {
10998 if (temp3)
10999 delete arg3;
11000 }
11001 return resultobj;
11002 fail:
11003 {
11004 if (temp3)
11005 delete arg3;
11006 }
11007 return NULL;
11008 }
11009
11010
11011 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11012 PyObject *obj;
11013 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11014 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
11015 return SWIG_Py_Void();
11016 }
11017
11018 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11019 return SWIG_Python_InitShadowInstance(args);
11020 }
11021
11022 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11023 PyObject *resultobj = 0;
11024 wxZipFSHandler *result = 0 ;
11025
11026 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
11027 {
11028 PyThreadState* __tstate = wxPyBeginAllowThreads();
11029 result = (wxZipFSHandler *)new wxZipFSHandler();
11030 wxPyEndAllowThreads(__tstate);
11031 if (PyErr_Occurred()) SWIG_fail;
11032 }
11033 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
11034 return resultobj;
11035 fail:
11036 return NULL;
11037 }
11038
11039
11040 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11041 PyObject *resultobj = 0;
11042 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11043 wxString *arg2 = 0 ;
11044 bool result;
11045 void *argp1 = 0 ;
11046 int res1 = 0 ;
11047 bool temp2 = false ;
11048 PyObject * obj0 = 0 ;
11049 PyObject * obj1 = 0 ;
11050 char * kwnames[] = {
11051 (char *) "self",(char *) "location", NULL
11052 };
11053
11054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11055 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11056 if (!SWIG_IsOK(res1)) {
11057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11058 }
11059 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11060 {
11061 arg2 = wxString_in_helper(obj1);
11062 if (arg2 == NULL) SWIG_fail;
11063 temp2 = true;
11064 }
11065 {
11066 PyThreadState* __tstate = wxPyBeginAllowThreads();
11067 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11068 wxPyEndAllowThreads(__tstate);
11069 if (PyErr_Occurred()) SWIG_fail;
11070 }
11071 {
11072 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11073 }
11074 {
11075 if (temp2)
11076 delete arg2;
11077 }
11078 return resultobj;
11079 fail:
11080 {
11081 if (temp2)
11082 delete arg2;
11083 }
11084 return NULL;
11085 }
11086
11087
11088 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11089 PyObject *resultobj = 0;
11090 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11091 wxFileSystem *arg2 = 0 ;
11092 wxString *arg3 = 0 ;
11093 wxFSFile *result = 0 ;
11094 void *argp1 = 0 ;
11095 int res1 = 0 ;
11096 void *argp2 = 0 ;
11097 int res2 = 0 ;
11098 bool temp3 = false ;
11099 PyObject * obj0 = 0 ;
11100 PyObject * obj1 = 0 ;
11101 PyObject * obj2 = 0 ;
11102 char * kwnames[] = {
11103 (char *) "self",(char *) "fs",(char *) "location", NULL
11104 };
11105
11106 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11107 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11108 if (!SWIG_IsOK(res1)) {
11109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11110 }
11111 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11112 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11113 if (!SWIG_IsOK(res2)) {
11114 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11115 }
11116 if (!argp2) {
11117 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11118 }
11119 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11120 {
11121 arg3 = wxString_in_helper(obj2);
11122 if (arg3 == NULL) SWIG_fail;
11123 temp3 = true;
11124 }
11125 {
11126 PyThreadState* __tstate = wxPyBeginAllowThreads();
11127 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11128 wxPyEndAllowThreads(__tstate);
11129 if (PyErr_Occurred()) SWIG_fail;
11130 }
11131 {
11132 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
11133 }
11134 {
11135 if (temp3)
11136 delete arg3;
11137 }
11138 return resultobj;
11139 fail:
11140 {
11141 if (temp3)
11142 delete arg3;
11143 }
11144 return NULL;
11145 }
11146
11147
11148 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11149 PyObject *resultobj = 0;
11150 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11151 wxString *arg2 = 0 ;
11152 int arg3 = (int) 0 ;
11153 wxString result;
11154 void *argp1 = 0 ;
11155 int res1 = 0 ;
11156 bool temp2 = false ;
11157 int val3 ;
11158 int ecode3 = 0 ;
11159 PyObject * obj0 = 0 ;
11160 PyObject * obj1 = 0 ;
11161 PyObject * obj2 = 0 ;
11162 char * kwnames[] = {
11163 (char *) "self",(char *) "spec",(char *) "flags", NULL
11164 };
11165
11166 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11167 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11168 if (!SWIG_IsOK(res1)) {
11169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11170 }
11171 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11172 {
11173 arg2 = wxString_in_helper(obj1);
11174 if (arg2 == NULL) SWIG_fail;
11175 temp2 = true;
11176 }
11177 if (obj2) {
11178 ecode3 = SWIG_AsVal_int(obj2, &val3);
11179 if (!SWIG_IsOK(ecode3)) {
11180 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11181 }
11182 arg3 = static_cast< int >(val3);
11183 }
11184 {
11185 PyThreadState* __tstate = wxPyBeginAllowThreads();
11186 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11187 wxPyEndAllowThreads(__tstate);
11188 if (PyErr_Occurred()) SWIG_fail;
11189 }
11190 {
11191 #if wxUSE_UNICODE
11192 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11193 #else
11194 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11195 #endif
11196 }
11197 {
11198 if (temp2)
11199 delete arg2;
11200 }
11201 return resultobj;
11202 fail:
11203 {
11204 if (temp2)
11205 delete arg2;
11206 }
11207 return NULL;
11208 }
11209
11210
11211 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11212 PyObject *resultobj = 0;
11213 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11214 wxString result;
11215 void *argp1 = 0 ;
11216 int res1 = 0 ;
11217 PyObject *swig_obj[1] ;
11218
11219 if (!args) SWIG_fail;
11220 swig_obj[0] = args;
11221 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11222 if (!SWIG_IsOK(res1)) {
11223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11224 }
11225 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11226 {
11227 PyThreadState* __tstate = wxPyBeginAllowThreads();
11228 result = (arg1)->FindNext();
11229 wxPyEndAllowThreads(__tstate);
11230 if (PyErr_Occurred()) SWIG_fail;
11231 }
11232 {
11233 #if wxUSE_UNICODE
11234 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11235 #else
11236 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11237 #endif
11238 }
11239 return resultobj;
11240 fail:
11241 return NULL;
11242 }
11243
11244
11245 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11246 PyObject *obj;
11247 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11248 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
11249 return SWIG_Py_Void();
11250 }
11251
11252 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11253 return SWIG_Python_InitShadowInstance(args);
11254 }
11255
11256 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11257 PyObject *resultobj = 0;
11258 wxString *arg1 = 0 ;
11259 wxImage *arg2 = 0 ;
11260 long arg3 ;
11261 bool temp1 = false ;
11262 void *argp2 = 0 ;
11263 int res2 = 0 ;
11264 long val3 ;
11265 int ecode3 = 0 ;
11266 PyObject * obj0 = 0 ;
11267 PyObject * obj1 = 0 ;
11268 PyObject * obj2 = 0 ;
11269 char * kwnames[] = {
11270 (char *) "filename",(char *) "image",(char *) "type", NULL
11271 };
11272
11273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11274 {
11275 arg1 = wxString_in_helper(obj0);
11276 if (arg1 == NULL) SWIG_fail;
11277 temp1 = true;
11278 }
11279 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
11280 if (!SWIG_IsOK(res2)) {
11281 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11282 }
11283 if (!argp2) {
11284 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11285 }
11286 arg2 = reinterpret_cast< wxImage * >(argp2);
11287 ecode3 = SWIG_AsVal_long(obj2, &val3);
11288 if (!SWIG_IsOK(ecode3)) {
11289 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
11290 }
11291 arg3 = static_cast< long >(val3);
11292 {
11293 PyThreadState* __tstate = wxPyBeginAllowThreads();
11294 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
11295 wxPyEndAllowThreads(__tstate);
11296 if (PyErr_Occurred()) SWIG_fail;
11297 }
11298 resultobj = SWIG_Py_Void();
11299 {
11300 if (temp1)
11301 delete arg1;
11302 }
11303 return resultobj;
11304 fail:
11305 {
11306 if (temp1)
11307 delete arg1;
11308 }
11309 return NULL;
11310 }
11311
11312
11313 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11314 PyObject *resultobj = 0;
11315 wxString *arg1 = 0 ;
11316 wxBitmap *arg2 = 0 ;
11317 long arg3 ;
11318 bool temp1 = false ;
11319 void *argp2 = 0 ;
11320 int res2 = 0 ;
11321 long val3 ;
11322 int ecode3 = 0 ;
11323 PyObject * obj0 = 0 ;
11324 PyObject * obj1 = 0 ;
11325 PyObject * obj2 = 0 ;
11326 char * kwnames[] = {
11327 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
11328 };
11329
11330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11331 {
11332 arg1 = wxString_in_helper(obj0);
11333 if (arg1 == NULL) SWIG_fail;
11334 temp1 = true;
11335 }
11336 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
11337 if (!SWIG_IsOK(res2)) {
11338 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11339 }
11340 if (!argp2) {
11341 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11342 }
11343 arg2 = reinterpret_cast< wxBitmap * >(argp2);
11344 ecode3 = SWIG_AsVal_long(obj2, &val3);
11345 if (!SWIG_IsOK(ecode3)) {
11346 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
11347 }
11348 arg3 = static_cast< long >(val3);
11349 {
11350 PyThreadState* __tstate = wxPyBeginAllowThreads();
11351 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
11352 wxPyEndAllowThreads(__tstate);
11353 if (PyErr_Occurred()) SWIG_fail;
11354 }
11355 resultobj = SWIG_Py_Void();
11356 {
11357 if (temp1)
11358 delete arg1;
11359 }
11360 return resultobj;
11361 fail:
11362 {
11363 if (temp1)
11364 delete arg1;
11365 }
11366 return NULL;
11367 }
11368
11369
11370 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11371 PyObject *resultobj = 0;
11372 wxString *arg1 = 0 ;
11373 PyObject *arg2 = (PyObject *) 0 ;
11374 bool temp1 = false ;
11375 PyObject * obj0 = 0 ;
11376 PyObject * obj1 = 0 ;
11377 char * kwnames[] = {
11378 (char *) "filename",(char *) "data", NULL
11379 };
11380
11381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
11382 {
11383 arg1 = wxString_in_helper(obj0);
11384 if (arg1 == NULL) SWIG_fail;
11385 temp1 = true;
11386 }
11387 arg2 = obj1;
11388 {
11389 PyThreadState* __tstate = wxPyBeginAllowThreads();
11390 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
11391 wxPyEndAllowThreads(__tstate);
11392 if (PyErr_Occurred()) SWIG_fail;
11393 }
11394 resultobj = SWIG_Py_Void();
11395 {
11396 if (temp1)
11397 delete arg1;
11398 }
11399 return resultobj;
11400 fail:
11401 {
11402 if (temp1)
11403 delete arg1;
11404 }
11405 return NULL;
11406 }
11407
11408
11409 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11410 PyObject *resultobj = 0;
11411 wxMemoryFSHandler *result = 0 ;
11412
11413 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
11414 {
11415 PyThreadState* __tstate = wxPyBeginAllowThreads();
11416 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
11417 wxPyEndAllowThreads(__tstate);
11418 if (PyErr_Occurred()) SWIG_fail;
11419 }
11420 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
11421 return resultobj;
11422 fail:
11423 return NULL;
11424 }
11425
11426
11427 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11428 PyObject *resultobj = 0;
11429 wxString *arg1 = 0 ;
11430 bool temp1 = false ;
11431 PyObject * obj0 = 0 ;
11432 char * kwnames[] = {
11433 (char *) "filename", NULL
11434 };
11435
11436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
11437 {
11438 arg1 = wxString_in_helper(obj0);
11439 if (arg1 == NULL) SWIG_fail;
11440 temp1 = true;
11441 }
11442 {
11443 PyThreadState* __tstate = wxPyBeginAllowThreads();
11444 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
11445 wxPyEndAllowThreads(__tstate);
11446 if (PyErr_Occurred()) SWIG_fail;
11447 }
11448 resultobj = SWIG_Py_Void();
11449 {
11450 if (temp1)
11451 delete arg1;
11452 }
11453 return resultobj;
11454 fail:
11455 {
11456 if (temp1)
11457 delete arg1;
11458 }
11459 return NULL;
11460 }
11461
11462
11463 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11464 PyObject *resultobj = 0;
11465 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11466 wxString *arg2 = 0 ;
11467 bool result;
11468 void *argp1 = 0 ;
11469 int res1 = 0 ;
11470 bool temp2 = false ;
11471 PyObject * obj0 = 0 ;
11472 PyObject * obj1 = 0 ;
11473 char * kwnames[] = {
11474 (char *) "self",(char *) "location", NULL
11475 };
11476
11477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11478 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11479 if (!SWIG_IsOK(res1)) {
11480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11481 }
11482 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11483 {
11484 arg2 = wxString_in_helper(obj1);
11485 if (arg2 == NULL) SWIG_fail;
11486 temp2 = true;
11487 }
11488 {
11489 PyThreadState* __tstate = wxPyBeginAllowThreads();
11490 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11491 wxPyEndAllowThreads(__tstate);
11492 if (PyErr_Occurred()) SWIG_fail;
11493 }
11494 {
11495 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11496 }
11497 {
11498 if (temp2)
11499 delete arg2;
11500 }
11501 return resultobj;
11502 fail:
11503 {
11504 if (temp2)
11505 delete arg2;
11506 }
11507 return NULL;
11508 }
11509
11510
11511 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11512 PyObject *resultobj = 0;
11513 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11514 wxFileSystem *arg2 = 0 ;
11515 wxString *arg3 = 0 ;
11516 wxFSFile *result = 0 ;
11517 void *argp1 = 0 ;
11518 int res1 = 0 ;
11519 void *argp2 = 0 ;
11520 int res2 = 0 ;
11521 bool temp3 = false ;
11522 PyObject * obj0 = 0 ;
11523 PyObject * obj1 = 0 ;
11524 PyObject * obj2 = 0 ;
11525 char * kwnames[] = {
11526 (char *) "self",(char *) "fs",(char *) "location", NULL
11527 };
11528
11529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11530 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11531 if (!SWIG_IsOK(res1)) {
11532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11533 }
11534 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11535 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11536 if (!SWIG_IsOK(res2)) {
11537 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11538 }
11539 if (!argp2) {
11540 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11541 }
11542 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11543 {
11544 arg3 = wxString_in_helper(obj2);
11545 if (arg3 == NULL) SWIG_fail;
11546 temp3 = true;
11547 }
11548 {
11549 PyThreadState* __tstate = wxPyBeginAllowThreads();
11550 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11551 wxPyEndAllowThreads(__tstate);
11552 if (PyErr_Occurred()) SWIG_fail;
11553 }
11554 {
11555 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
11556 }
11557 {
11558 if (temp3)
11559 delete arg3;
11560 }
11561 return resultobj;
11562 fail:
11563 {
11564 if (temp3)
11565 delete arg3;
11566 }
11567 return NULL;
11568 }
11569
11570
11571 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11572 PyObject *resultobj = 0;
11573 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11574 wxString *arg2 = 0 ;
11575 int arg3 = (int) 0 ;
11576 wxString result;
11577 void *argp1 = 0 ;
11578 int res1 = 0 ;
11579 bool temp2 = false ;
11580 int val3 ;
11581 int ecode3 = 0 ;
11582 PyObject * obj0 = 0 ;
11583 PyObject * obj1 = 0 ;
11584 PyObject * obj2 = 0 ;
11585 char * kwnames[] = {
11586 (char *) "self",(char *) "spec",(char *) "flags", NULL
11587 };
11588
11589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11590 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11591 if (!SWIG_IsOK(res1)) {
11592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11593 }
11594 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11595 {
11596 arg2 = wxString_in_helper(obj1);
11597 if (arg2 == NULL) SWIG_fail;
11598 temp2 = true;
11599 }
11600 if (obj2) {
11601 ecode3 = SWIG_AsVal_int(obj2, &val3);
11602 if (!SWIG_IsOK(ecode3)) {
11603 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11604 }
11605 arg3 = static_cast< int >(val3);
11606 }
11607 {
11608 PyThreadState* __tstate = wxPyBeginAllowThreads();
11609 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11610 wxPyEndAllowThreads(__tstate);
11611 if (PyErr_Occurred()) SWIG_fail;
11612 }
11613 {
11614 #if wxUSE_UNICODE
11615 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11616 #else
11617 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11618 #endif
11619 }
11620 {
11621 if (temp2)
11622 delete arg2;
11623 }
11624 return resultobj;
11625 fail:
11626 {
11627 if (temp2)
11628 delete arg2;
11629 }
11630 return NULL;
11631 }
11632
11633
11634 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11635 PyObject *resultobj = 0;
11636 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11637 wxString result;
11638 void *argp1 = 0 ;
11639 int res1 = 0 ;
11640 PyObject *swig_obj[1] ;
11641
11642 if (!args) SWIG_fail;
11643 swig_obj[0] = args;
11644 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11645 if (!SWIG_IsOK(res1)) {
11646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11647 }
11648 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11649 {
11650 PyThreadState* __tstate = wxPyBeginAllowThreads();
11651 result = (arg1)->FindNext();
11652 wxPyEndAllowThreads(__tstate);
11653 if (PyErr_Occurred()) SWIG_fail;
11654 }
11655 {
11656 #if wxUSE_UNICODE
11657 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11658 #else
11659 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11660 #endif
11661 }
11662 return resultobj;
11663 fail:
11664 return NULL;
11665 }
11666
11667
11668 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11669 PyObject *obj;
11670 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11671 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
11672 return SWIG_Py_Void();
11673 }
11674
11675 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11676 return SWIG_Python_InitShadowInstance(args);
11677 }
11678
11679 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11680 PyObject *resultobj = 0;
11681 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11682 wxString result;
11683 void *argp1 = 0 ;
11684 int res1 = 0 ;
11685 PyObject *swig_obj[1] ;
11686
11687 if (!args) SWIG_fail;
11688 swig_obj[0] = args;
11689 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11690 if (!SWIG_IsOK(res1)) {
11691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11692 }
11693 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11694 {
11695 PyThreadState* __tstate = wxPyBeginAllowThreads();
11696 result = (arg1)->GetName();
11697 wxPyEndAllowThreads(__tstate);
11698 if (PyErr_Occurred()) SWIG_fail;
11699 }
11700 {
11701 #if wxUSE_UNICODE
11702 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11703 #else
11704 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11705 #endif
11706 }
11707 return resultobj;
11708 fail:
11709 return NULL;
11710 }
11711
11712
11713 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11714 PyObject *resultobj = 0;
11715 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11716 wxString result;
11717 void *argp1 = 0 ;
11718 int res1 = 0 ;
11719 PyObject *swig_obj[1] ;
11720
11721 if (!args) SWIG_fail;
11722 swig_obj[0] = args;
11723 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11724 if (!SWIG_IsOK(res1)) {
11725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11726 }
11727 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11728 {
11729 PyThreadState* __tstate = wxPyBeginAllowThreads();
11730 result = (arg1)->GetExtension();
11731 wxPyEndAllowThreads(__tstate);
11732 if (PyErr_Occurred()) SWIG_fail;
11733 }
11734 {
11735 #if wxUSE_UNICODE
11736 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11737 #else
11738 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11739 #endif
11740 }
11741 return resultobj;
11742 fail:
11743 return NULL;
11744 }
11745
11746
11747 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11748 PyObject *resultobj = 0;
11749 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11750 long result;
11751 void *argp1 = 0 ;
11752 int res1 = 0 ;
11753 PyObject *swig_obj[1] ;
11754
11755 if (!args) SWIG_fail;
11756 swig_obj[0] = args;
11757 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11758 if (!SWIG_IsOK(res1)) {
11759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11760 }
11761 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11762 {
11763 PyThreadState* __tstate = wxPyBeginAllowThreads();
11764 result = (long)(arg1)->GetType();
11765 wxPyEndAllowThreads(__tstate);
11766 if (PyErr_Occurred()) SWIG_fail;
11767 }
11768 resultobj = SWIG_From_long(static_cast< long >(result));
11769 return resultobj;
11770 fail:
11771 return NULL;
11772 }
11773
11774
11775 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11776 PyObject *resultobj = 0;
11777 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11778 wxString result;
11779 void *argp1 = 0 ;
11780 int res1 = 0 ;
11781 PyObject *swig_obj[1] ;
11782
11783 if (!args) SWIG_fail;
11784 swig_obj[0] = args;
11785 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11786 if (!SWIG_IsOK(res1)) {
11787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11788 }
11789 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11790 {
11791 PyThreadState* __tstate = wxPyBeginAllowThreads();
11792 result = (arg1)->GetMimeType();
11793 wxPyEndAllowThreads(__tstate);
11794 if (PyErr_Occurred()) SWIG_fail;
11795 }
11796 {
11797 #if wxUSE_UNICODE
11798 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11799 #else
11800 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11801 #endif
11802 }
11803 return resultobj;
11804 fail:
11805 return NULL;
11806 }
11807
11808
11809 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11810 PyObject *resultobj = 0;
11811 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11812 wxString *arg2 = 0 ;
11813 bool result;
11814 void *argp1 = 0 ;
11815 int res1 = 0 ;
11816 bool temp2 = false ;
11817 PyObject * obj0 = 0 ;
11818 PyObject * obj1 = 0 ;
11819 char * kwnames[] = {
11820 (char *) "self",(char *) "name", NULL
11821 };
11822
11823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
11824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11825 if (!SWIG_IsOK(res1)) {
11826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11827 }
11828 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11829 {
11830 arg2 = wxString_in_helper(obj1);
11831 if (arg2 == NULL) SWIG_fail;
11832 temp2 = true;
11833 }
11834 {
11835 PyThreadState* __tstate = wxPyBeginAllowThreads();
11836 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
11837 wxPyEndAllowThreads(__tstate);
11838 if (PyErr_Occurred()) SWIG_fail;
11839 }
11840 {
11841 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11842 }
11843 {
11844 if (temp2)
11845 delete arg2;
11846 }
11847 return resultobj;
11848 fail:
11849 {
11850 if (temp2)
11851 delete arg2;
11852 }
11853 return NULL;
11854 }
11855
11856
11857 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11858 PyObject *resultobj = 0;
11859 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11860 wxString *arg2 = 0 ;
11861 void *argp1 = 0 ;
11862 int res1 = 0 ;
11863 bool temp2 = false ;
11864 PyObject * obj0 = 0 ;
11865 PyObject * obj1 = 0 ;
11866 char * kwnames[] = {
11867 (char *) "self",(char *) "name", NULL
11868 };
11869
11870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
11871 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11872 if (!SWIG_IsOK(res1)) {
11873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11874 }
11875 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11876 {
11877 arg2 = wxString_in_helper(obj1);
11878 if (arg2 == NULL) SWIG_fail;
11879 temp2 = true;
11880 }
11881 {
11882 PyThreadState* __tstate = wxPyBeginAllowThreads();
11883 (arg1)->SetName((wxString const &)*arg2);
11884 wxPyEndAllowThreads(__tstate);
11885 if (PyErr_Occurred()) SWIG_fail;
11886 }
11887 resultobj = SWIG_Py_Void();
11888 {
11889 if (temp2)
11890 delete arg2;
11891 }
11892 return resultobj;
11893 fail:
11894 {
11895 if (temp2)
11896 delete arg2;
11897 }
11898 return NULL;
11899 }
11900
11901
11902 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11903 PyObject *resultobj = 0;
11904 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11905 wxString *arg2 = 0 ;
11906 void *argp1 = 0 ;
11907 int res1 = 0 ;
11908 bool temp2 = false ;
11909 PyObject * obj0 = 0 ;
11910 PyObject * obj1 = 0 ;
11911 char * kwnames[] = {
11912 (char *) "self",(char *) "extension", NULL
11913 };
11914
11915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
11916 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11917 if (!SWIG_IsOK(res1)) {
11918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11919 }
11920 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11921 {
11922 arg2 = wxString_in_helper(obj1);
11923 if (arg2 == NULL) SWIG_fail;
11924 temp2 = true;
11925 }
11926 {
11927 PyThreadState* __tstate = wxPyBeginAllowThreads();
11928 (arg1)->SetExtension((wxString const &)*arg2);
11929 wxPyEndAllowThreads(__tstate);
11930 if (PyErr_Occurred()) SWIG_fail;
11931 }
11932 resultobj = SWIG_Py_Void();
11933 {
11934 if (temp2)
11935 delete arg2;
11936 }
11937 return resultobj;
11938 fail:
11939 {
11940 if (temp2)
11941 delete arg2;
11942 }
11943 return NULL;
11944 }
11945
11946
11947 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11948 PyObject *resultobj = 0;
11949 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11950 long arg2 ;
11951 void *argp1 = 0 ;
11952 int res1 = 0 ;
11953 long val2 ;
11954 int ecode2 = 0 ;
11955 PyObject * obj0 = 0 ;
11956 PyObject * obj1 = 0 ;
11957 char * kwnames[] = {
11958 (char *) "self",(char *) "type", NULL
11959 };
11960
11961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
11962 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11963 if (!SWIG_IsOK(res1)) {
11964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11965 }
11966 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11967 ecode2 = SWIG_AsVal_long(obj1, &val2);
11968 if (!SWIG_IsOK(ecode2)) {
11969 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
11970 }
11971 arg2 = static_cast< long >(val2);
11972 {
11973 PyThreadState* __tstate = wxPyBeginAllowThreads();
11974 (arg1)->SetType(arg2);
11975 wxPyEndAllowThreads(__tstate);
11976 if (PyErr_Occurred()) SWIG_fail;
11977 }
11978 resultobj = SWIG_Py_Void();
11979 return resultobj;
11980 fail:
11981 return NULL;
11982 }
11983
11984
11985 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11986 PyObject *resultobj = 0;
11987 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11988 wxString *arg2 = 0 ;
11989 void *argp1 = 0 ;
11990 int res1 = 0 ;
11991 bool temp2 = false ;
11992 PyObject * obj0 = 0 ;
11993 PyObject * obj1 = 0 ;
11994 char * kwnames[] = {
11995 (char *) "self",(char *) "mimetype", NULL
11996 };
11997
11998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
11999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12000 if (!SWIG_IsOK(res1)) {
12001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12002 }
12003 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12004 {
12005 arg2 = wxString_in_helper(obj1);
12006 if (arg2 == NULL) SWIG_fail;
12007 temp2 = true;
12008 }
12009 {
12010 PyThreadState* __tstate = wxPyBeginAllowThreads();
12011 (arg1)->SetMimeType((wxString const &)*arg2);
12012 wxPyEndAllowThreads(__tstate);
12013 if (PyErr_Occurred()) SWIG_fail;
12014 }
12015 resultobj = SWIG_Py_Void();
12016 {
12017 if (temp2)
12018 delete arg2;
12019 }
12020 return resultobj;
12021 fail:
12022 {
12023 if (temp2)
12024 delete arg2;
12025 }
12026 return NULL;
12027 }
12028
12029
12030 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12031 PyObject *obj;
12032 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12033 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
12034 return SWIG_Py_Void();
12035 }
12036
12037 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12038 PyObject *resultobj = 0;
12039 wxPyImageHandler *result = 0 ;
12040
12041 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
12042 {
12043 PyThreadState* __tstate = wxPyBeginAllowThreads();
12044 result = (wxPyImageHandler *)new wxPyImageHandler();
12045 wxPyEndAllowThreads(__tstate);
12046 if (PyErr_Occurred()) SWIG_fail;
12047 }
12048 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
12049 return resultobj;
12050 fail:
12051 return NULL;
12052 }
12053
12054
12055 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12056 PyObject *resultobj = 0;
12057 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
12058 PyObject *arg2 = (PyObject *) 0 ;
12059 void *argp1 = 0 ;
12060 int res1 = 0 ;
12061 PyObject * obj0 = 0 ;
12062 PyObject * obj1 = 0 ;
12063 char * kwnames[] = {
12064 (char *) "self",(char *) "self", NULL
12065 };
12066
12067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
12068 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
12069 if (!SWIG_IsOK(res1)) {
12070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
12071 }
12072 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
12073 arg2 = obj1;
12074 {
12075 PyThreadState* __tstate = wxPyBeginAllowThreads();
12076 (arg1)->_SetSelf(arg2);
12077 wxPyEndAllowThreads(__tstate);
12078 if (PyErr_Occurred()) SWIG_fail;
12079 }
12080 resultobj = SWIG_Py_Void();
12081 return resultobj;
12082 fail:
12083 return NULL;
12084 }
12085
12086
12087 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12088 PyObject *obj;
12089 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12090 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
12091 return SWIG_Py_Void();
12092 }
12093
12094 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12095 return SWIG_Python_InitShadowInstance(args);
12096 }
12097
12098 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12099 PyObject *resultobj = 0;
12100 wxImageHistogram *result = 0 ;
12101
12102 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
12103 {
12104 PyThreadState* __tstate = wxPyBeginAllowThreads();
12105 result = (wxImageHistogram *)new wxImageHistogram();
12106 wxPyEndAllowThreads(__tstate);
12107 if (PyErr_Occurred()) SWIG_fail;
12108 }
12109 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
12110 return resultobj;
12111 fail:
12112 return NULL;
12113 }
12114
12115
12116 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12117 PyObject *resultobj = 0;
12118 byte arg1 ;
12119 byte arg2 ;
12120 byte arg3 ;
12121 unsigned long result;
12122 unsigned char val1 ;
12123 int ecode1 = 0 ;
12124 unsigned char val2 ;
12125 int ecode2 = 0 ;
12126 unsigned char val3 ;
12127 int ecode3 = 0 ;
12128 PyObject * obj0 = 0 ;
12129 PyObject * obj1 = 0 ;
12130 PyObject * obj2 = 0 ;
12131 char * kwnames[] = {
12132 (char *) "r",(char *) "g",(char *) "b", NULL
12133 };
12134
12135 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12136 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12137 if (!SWIG_IsOK(ecode1)) {
12138 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
12139 }
12140 arg1 = static_cast< byte >(val1);
12141 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12142 if (!SWIG_IsOK(ecode2)) {
12143 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
12144 }
12145 arg2 = static_cast< byte >(val2);
12146 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12147 if (!SWIG_IsOK(ecode3)) {
12148 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
12149 }
12150 arg3 = static_cast< byte >(val3);
12151 {
12152 PyThreadState* __tstate = wxPyBeginAllowThreads();
12153 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
12154 wxPyEndAllowThreads(__tstate);
12155 if (PyErr_Occurred()) SWIG_fail;
12156 }
12157 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12158 return resultobj;
12159 fail:
12160 return NULL;
12161 }
12162
12163
12164 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12165 PyObject *resultobj = 0;
12166 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12167 byte *arg2 = (byte *) 0 ;
12168 byte *arg3 = (byte *) 0 ;
12169 byte *arg4 = (byte *) 0 ;
12170 byte arg5 = (byte) 1 ;
12171 byte arg6 = (byte) 0 ;
12172 byte arg7 = (byte) 0 ;
12173 bool result;
12174 void *argp1 = 0 ;
12175 int res1 = 0 ;
12176 byte temp2 ;
12177 int res2 = SWIG_TMPOBJ ;
12178 byte temp3 ;
12179 int res3 = SWIG_TMPOBJ ;
12180 byte temp4 ;
12181 int res4 = SWIG_TMPOBJ ;
12182 unsigned char val5 ;
12183 int ecode5 = 0 ;
12184 unsigned char val6 ;
12185 int ecode6 = 0 ;
12186 unsigned char val7 ;
12187 int ecode7 = 0 ;
12188 PyObject * obj0 = 0 ;
12189 PyObject * obj1 = 0 ;
12190 PyObject * obj2 = 0 ;
12191 PyObject * obj3 = 0 ;
12192 char * kwnames[] = {
12193 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
12194 };
12195
12196 arg2 = &temp2;
12197 arg3 = &temp3;
12198 arg4 = &temp4;
12199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12200 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12201 if (!SWIG_IsOK(res1)) {
12202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
12203 }
12204 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12205 if (obj1) {
12206 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
12207 if (!SWIG_IsOK(ecode5)) {
12208 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
12209 }
12210 arg5 = static_cast< byte >(val5);
12211 }
12212 if (obj2) {
12213 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
12214 if (!SWIG_IsOK(ecode6)) {
12215 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
12216 }
12217 arg6 = static_cast< byte >(val6);
12218 }
12219 if (obj3) {
12220 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
12221 if (!SWIG_IsOK(ecode7)) {
12222 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
12223 }
12224 arg7 = static_cast< byte >(val7);
12225 }
12226 {
12227 PyThreadState* __tstate = wxPyBeginAllowThreads();
12228 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
12229 wxPyEndAllowThreads(__tstate);
12230 if (PyErr_Occurred()) SWIG_fail;
12231 }
12232 {
12233 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12234 }
12235 if (SWIG_IsTmpObj(res2)) {
12236 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
12237 } else {
12238 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12239 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
12240 }
12241 if (SWIG_IsTmpObj(res3)) {
12242 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
12243 } else {
12244 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12245 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
12246 }
12247 if (SWIG_IsTmpObj(res4)) {
12248 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
12249 } else {
12250 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12251 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
12252 }
12253 return resultobj;
12254 fail:
12255 return NULL;
12256 }
12257
12258
12259 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12260 PyObject *resultobj = 0;
12261 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12262 unsigned long arg2 ;
12263 unsigned long result;
12264 void *argp1 = 0 ;
12265 int res1 = 0 ;
12266 unsigned long val2 ;
12267 int ecode2 = 0 ;
12268 PyObject * obj0 = 0 ;
12269 PyObject * obj1 = 0 ;
12270 char * kwnames[] = {
12271 (char *) "self",(char *) "key", NULL
12272 };
12273
12274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
12275 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12276 if (!SWIG_IsOK(res1)) {
12277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12278 }
12279 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12280 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
12281 if (!SWIG_IsOK(ecode2)) {
12282 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
12283 }
12284 arg2 = static_cast< unsigned long >(val2);
12285 {
12286 PyThreadState* __tstate = wxPyBeginAllowThreads();
12287 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
12288 wxPyEndAllowThreads(__tstate);
12289 if (PyErr_Occurred()) SWIG_fail;
12290 }
12291 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12292 return resultobj;
12293 fail:
12294 return NULL;
12295 }
12296
12297
12298 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12299 PyObject *resultobj = 0;
12300 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12301 byte arg2 ;
12302 byte arg3 ;
12303 byte arg4 ;
12304 unsigned long result;
12305 void *argp1 = 0 ;
12306 int res1 = 0 ;
12307 unsigned char val2 ;
12308 int ecode2 = 0 ;
12309 unsigned char val3 ;
12310 int ecode3 = 0 ;
12311 unsigned char val4 ;
12312 int ecode4 = 0 ;
12313 PyObject * obj0 = 0 ;
12314 PyObject * obj1 = 0 ;
12315 PyObject * obj2 = 0 ;
12316 PyObject * obj3 = 0 ;
12317 char * kwnames[] = {
12318 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12319 };
12320
12321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12322 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12323 if (!SWIG_IsOK(res1)) {
12324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12325 }
12326 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12327 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12328 if (!SWIG_IsOK(ecode2)) {
12329 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
12330 }
12331 arg2 = static_cast< byte >(val2);
12332 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12333 if (!SWIG_IsOK(ecode3)) {
12334 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
12335 }
12336 arg3 = static_cast< byte >(val3);
12337 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
12338 if (!SWIG_IsOK(ecode4)) {
12339 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
12340 }
12341 arg4 = static_cast< byte >(val4);
12342 {
12343 PyThreadState* __tstate = wxPyBeginAllowThreads();
12344 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
12345 wxPyEndAllowThreads(__tstate);
12346 if (PyErr_Occurred()) SWIG_fail;
12347 }
12348 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12349 return resultobj;
12350 fail:
12351 return NULL;
12352 }
12353
12354
12355 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12356 PyObject *resultobj = 0;
12357 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12358 wxColour *arg2 = 0 ;
12359 unsigned long result;
12360 void *argp1 = 0 ;
12361 int res1 = 0 ;
12362 wxColour temp2 ;
12363 PyObject * obj0 = 0 ;
12364 PyObject * obj1 = 0 ;
12365 char * kwnames[] = {
12366 (char *) "self",(char *) "colour", NULL
12367 };
12368
12369 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
12370 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12371 if (!SWIG_IsOK(res1)) {
12372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12373 }
12374 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12375 {
12376 arg2 = &temp2;
12377 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12378 }
12379 {
12380 PyThreadState* __tstate = wxPyBeginAllowThreads();
12381 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
12382 wxPyEndAllowThreads(__tstate);
12383 if (PyErr_Occurred()) SWIG_fail;
12384 }
12385 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12386 return resultobj;
12387 fail:
12388 return NULL;
12389 }
12390
12391
12392 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12393 PyObject *obj;
12394 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12395 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
12396 return SWIG_Py_Void();
12397 }
12398
12399 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12400 return SWIG_Python_InitShadowInstance(args);
12401 }
12402
12403 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12404 PyObject *resultobj = 0;
12405 byte arg1 = (byte) 0 ;
12406 byte arg2 = (byte) 0 ;
12407 byte arg3 = (byte) 0 ;
12408 wxImage_RGBValue *result = 0 ;
12409 unsigned char val1 ;
12410 int ecode1 = 0 ;
12411 unsigned char val2 ;
12412 int ecode2 = 0 ;
12413 unsigned char val3 ;
12414 int ecode3 = 0 ;
12415 PyObject * obj0 = 0 ;
12416 PyObject * obj1 = 0 ;
12417 PyObject * obj2 = 0 ;
12418 char * kwnames[] = {
12419 (char *) "r",(char *) "g",(char *) "b", NULL
12420 };
12421
12422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12423 if (obj0) {
12424 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12425 if (!SWIG_IsOK(ecode1)) {
12426 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
12427 }
12428 arg1 = static_cast< byte >(val1);
12429 }
12430 if (obj1) {
12431 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12432 if (!SWIG_IsOK(ecode2)) {
12433 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
12434 }
12435 arg2 = static_cast< byte >(val2);
12436 }
12437 if (obj2) {
12438 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12439 if (!SWIG_IsOK(ecode3)) {
12440 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
12441 }
12442 arg3 = static_cast< byte >(val3);
12443 }
12444 {
12445 PyThreadState* __tstate = wxPyBeginAllowThreads();
12446 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
12447 wxPyEndAllowThreads(__tstate);
12448 if (PyErr_Occurred()) SWIG_fail;
12449 }
12450 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
12451 return resultobj;
12452 fail:
12453 return NULL;
12454 }
12455
12456
12457 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12458 PyObject *resultobj = 0;
12459 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12460 byte arg2 ;
12461 void *argp1 = 0 ;
12462 int res1 = 0 ;
12463 unsigned char val2 ;
12464 int ecode2 = 0 ;
12465 PyObject *swig_obj[2] ;
12466
12467 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
12468 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12469 if (!SWIG_IsOK(res1)) {
12470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12471 }
12472 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12473 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12474 if (!SWIG_IsOK(ecode2)) {
12475 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
12476 }
12477 arg2 = static_cast< byte >(val2);
12478 if (arg1) (arg1)->red = arg2;
12479
12480 resultobj = SWIG_Py_Void();
12481 return resultobj;
12482 fail:
12483 return NULL;
12484 }
12485
12486
12487 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12488 PyObject *resultobj = 0;
12489 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12490 byte result;
12491 void *argp1 = 0 ;
12492 int res1 = 0 ;
12493 PyObject *swig_obj[1] ;
12494
12495 if (!args) SWIG_fail;
12496 swig_obj[0] = args;
12497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12498 if (!SWIG_IsOK(res1)) {
12499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12500 }
12501 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12502 result = (byte) ((arg1)->red);
12503 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12504 return resultobj;
12505 fail:
12506 return NULL;
12507 }
12508
12509
12510 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12511 PyObject *resultobj = 0;
12512 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12513 byte arg2 ;
12514 void *argp1 = 0 ;
12515 int res1 = 0 ;
12516 unsigned char val2 ;
12517 int ecode2 = 0 ;
12518 PyObject *swig_obj[2] ;
12519
12520 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
12521 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12522 if (!SWIG_IsOK(res1)) {
12523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12524 }
12525 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12526 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12527 if (!SWIG_IsOK(ecode2)) {
12528 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
12529 }
12530 arg2 = static_cast< byte >(val2);
12531 if (arg1) (arg1)->green = arg2;
12532
12533 resultobj = SWIG_Py_Void();
12534 return resultobj;
12535 fail:
12536 return NULL;
12537 }
12538
12539
12540 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12541 PyObject *resultobj = 0;
12542 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12543 byte result;
12544 void *argp1 = 0 ;
12545 int res1 = 0 ;
12546 PyObject *swig_obj[1] ;
12547
12548 if (!args) SWIG_fail;
12549 swig_obj[0] = args;
12550 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12551 if (!SWIG_IsOK(res1)) {
12552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12553 }
12554 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12555 result = (byte) ((arg1)->green);
12556 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12557 return resultobj;
12558 fail:
12559 return NULL;
12560 }
12561
12562
12563 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12564 PyObject *resultobj = 0;
12565 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12566 byte arg2 ;
12567 void *argp1 = 0 ;
12568 int res1 = 0 ;
12569 unsigned char val2 ;
12570 int ecode2 = 0 ;
12571 PyObject *swig_obj[2] ;
12572
12573 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
12574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12575 if (!SWIG_IsOK(res1)) {
12576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12577 }
12578 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12579 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12580 if (!SWIG_IsOK(ecode2)) {
12581 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
12582 }
12583 arg2 = static_cast< byte >(val2);
12584 if (arg1) (arg1)->blue = arg2;
12585
12586 resultobj = SWIG_Py_Void();
12587 return resultobj;
12588 fail:
12589 return NULL;
12590 }
12591
12592
12593 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12594 PyObject *resultobj = 0;
12595 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12596 byte result;
12597 void *argp1 = 0 ;
12598 int res1 = 0 ;
12599 PyObject *swig_obj[1] ;
12600
12601 if (!args) SWIG_fail;
12602 swig_obj[0] = args;
12603 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12604 if (!SWIG_IsOK(res1)) {
12605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12606 }
12607 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12608 result = (byte) ((arg1)->blue);
12609 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12610 return resultobj;
12611 fail:
12612 return NULL;
12613 }
12614
12615
12616 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12617 PyObject *obj;
12618 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12619 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
12620 return SWIG_Py_Void();
12621 }
12622
12623 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12624 return SWIG_Python_InitShadowInstance(args);
12625 }
12626
12627 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12628 PyObject *resultobj = 0;
12629 double arg1 = (double) 0.0 ;
12630 double arg2 = (double) 0.0 ;
12631 double arg3 = (double) 0.0 ;
12632 wxImage_HSVValue *result = 0 ;
12633 double val1 ;
12634 int ecode1 = 0 ;
12635 double val2 ;
12636 int ecode2 = 0 ;
12637 double val3 ;
12638 int ecode3 = 0 ;
12639 PyObject * obj0 = 0 ;
12640 PyObject * obj1 = 0 ;
12641 PyObject * obj2 = 0 ;
12642 char * kwnames[] = {
12643 (char *) "h",(char *) "s",(char *) "v", NULL
12644 };
12645
12646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12647 if (obj0) {
12648 ecode1 = SWIG_AsVal_double(obj0, &val1);
12649 if (!SWIG_IsOK(ecode1)) {
12650 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
12651 }
12652 arg1 = static_cast< double >(val1);
12653 }
12654 if (obj1) {
12655 ecode2 = SWIG_AsVal_double(obj1, &val2);
12656 if (!SWIG_IsOK(ecode2)) {
12657 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
12658 }
12659 arg2 = static_cast< double >(val2);
12660 }
12661 if (obj2) {
12662 ecode3 = SWIG_AsVal_double(obj2, &val3);
12663 if (!SWIG_IsOK(ecode3)) {
12664 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
12665 }
12666 arg3 = static_cast< double >(val3);
12667 }
12668 {
12669 PyThreadState* __tstate = wxPyBeginAllowThreads();
12670 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
12671 wxPyEndAllowThreads(__tstate);
12672 if (PyErr_Occurred()) SWIG_fail;
12673 }
12674 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
12675 return resultobj;
12676 fail:
12677 return NULL;
12678 }
12679
12680
12681 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12682 PyObject *resultobj = 0;
12683 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12684 double arg2 ;
12685 void *argp1 = 0 ;
12686 int res1 = 0 ;
12687 double val2 ;
12688 int ecode2 = 0 ;
12689 PyObject *swig_obj[2] ;
12690
12691 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
12692 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12693 if (!SWIG_IsOK(res1)) {
12694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12695 }
12696 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12697 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12698 if (!SWIG_IsOK(ecode2)) {
12699 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
12700 }
12701 arg2 = static_cast< double >(val2);
12702 if (arg1) (arg1)->hue = arg2;
12703
12704 resultobj = SWIG_Py_Void();
12705 return resultobj;
12706 fail:
12707 return NULL;
12708 }
12709
12710
12711 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12712 PyObject *resultobj = 0;
12713 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12714 double result;
12715 void *argp1 = 0 ;
12716 int res1 = 0 ;
12717 PyObject *swig_obj[1] ;
12718
12719 if (!args) SWIG_fail;
12720 swig_obj[0] = args;
12721 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12722 if (!SWIG_IsOK(res1)) {
12723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12724 }
12725 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12726 result = (double) ((arg1)->hue);
12727 resultobj = SWIG_From_double(static_cast< double >(result));
12728 return resultobj;
12729 fail:
12730 return NULL;
12731 }
12732
12733
12734 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12735 PyObject *resultobj = 0;
12736 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12737 double arg2 ;
12738 void *argp1 = 0 ;
12739 int res1 = 0 ;
12740 double val2 ;
12741 int ecode2 = 0 ;
12742 PyObject *swig_obj[2] ;
12743
12744 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
12745 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12746 if (!SWIG_IsOK(res1)) {
12747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12748 }
12749 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12750 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12751 if (!SWIG_IsOK(ecode2)) {
12752 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
12753 }
12754 arg2 = static_cast< double >(val2);
12755 if (arg1) (arg1)->saturation = arg2;
12756
12757 resultobj = SWIG_Py_Void();
12758 return resultobj;
12759 fail:
12760 return NULL;
12761 }
12762
12763
12764 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12765 PyObject *resultobj = 0;
12766 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12767 double result;
12768 void *argp1 = 0 ;
12769 int res1 = 0 ;
12770 PyObject *swig_obj[1] ;
12771
12772 if (!args) SWIG_fail;
12773 swig_obj[0] = args;
12774 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12775 if (!SWIG_IsOK(res1)) {
12776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12777 }
12778 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12779 result = (double) ((arg1)->saturation);
12780 resultobj = SWIG_From_double(static_cast< double >(result));
12781 return resultobj;
12782 fail:
12783 return NULL;
12784 }
12785
12786
12787 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12788 PyObject *resultobj = 0;
12789 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12790 double arg2 ;
12791 void *argp1 = 0 ;
12792 int res1 = 0 ;
12793 double val2 ;
12794 int ecode2 = 0 ;
12795 PyObject *swig_obj[2] ;
12796
12797 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
12798 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12799 if (!SWIG_IsOK(res1)) {
12800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12801 }
12802 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12803 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12804 if (!SWIG_IsOK(ecode2)) {
12805 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
12806 }
12807 arg2 = static_cast< double >(val2);
12808 if (arg1) (arg1)->value = arg2;
12809
12810 resultobj = SWIG_Py_Void();
12811 return resultobj;
12812 fail:
12813 return NULL;
12814 }
12815
12816
12817 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12818 PyObject *resultobj = 0;
12819 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12820 double result;
12821 void *argp1 = 0 ;
12822 int res1 = 0 ;
12823 PyObject *swig_obj[1] ;
12824
12825 if (!args) SWIG_fail;
12826 swig_obj[0] = args;
12827 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12828 if (!SWIG_IsOK(res1)) {
12829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12830 }
12831 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12832 result = (double) ((arg1)->value);
12833 resultobj = SWIG_From_double(static_cast< double >(result));
12834 return resultobj;
12835 fail:
12836 return NULL;
12837 }
12838
12839
12840 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12841 PyObject *obj;
12842 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12843 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
12844 return SWIG_Py_Void();
12845 }
12846
12847 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12848 return SWIG_Python_InitShadowInstance(args);
12849 }
12850
12851 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12852 PyObject *resultobj = 0;
12853 wxString *arg1 = 0 ;
12854 long arg2 = (long) wxBITMAP_TYPE_ANY ;
12855 int arg3 = (int) -1 ;
12856 wxImage *result = 0 ;
12857 bool temp1 = false ;
12858 long val2 ;
12859 int ecode2 = 0 ;
12860 int val3 ;
12861 int ecode3 = 0 ;
12862 PyObject * obj0 = 0 ;
12863 PyObject * obj1 = 0 ;
12864 PyObject * obj2 = 0 ;
12865 char * kwnames[] = {
12866 (char *) "name",(char *) "type",(char *) "index", NULL
12867 };
12868
12869 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12870 {
12871 arg1 = wxString_in_helper(obj0);
12872 if (arg1 == NULL) SWIG_fail;
12873 temp1 = true;
12874 }
12875 if (obj1) {
12876 ecode2 = SWIG_AsVal_long(obj1, &val2);
12877 if (!SWIG_IsOK(ecode2)) {
12878 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
12879 }
12880 arg2 = static_cast< long >(val2);
12881 }
12882 if (obj2) {
12883 ecode3 = SWIG_AsVal_int(obj2, &val3);
12884 if (!SWIG_IsOK(ecode3)) {
12885 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
12886 }
12887 arg3 = static_cast< int >(val3);
12888 }
12889 {
12890 PyThreadState* __tstate = wxPyBeginAllowThreads();
12891 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
12892 wxPyEndAllowThreads(__tstate);
12893 if (PyErr_Occurred()) SWIG_fail;
12894 }
12895 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
12896 {
12897 if (temp1)
12898 delete arg1;
12899 }
12900 return resultobj;
12901 fail:
12902 {
12903 if (temp1)
12904 delete arg1;
12905 }
12906 return NULL;
12907 }
12908
12909
12910 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12911 PyObject *resultobj = 0;
12912 wxImage *arg1 = (wxImage *) 0 ;
12913 void *argp1 = 0 ;
12914 int res1 = 0 ;
12915 PyObject *swig_obj[1] ;
12916
12917 if (!args) SWIG_fail;
12918 swig_obj[0] = args;
12919 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
12920 if (!SWIG_IsOK(res1)) {
12921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
12922 }
12923 arg1 = reinterpret_cast< wxImage * >(argp1);
12924 {
12925 PyThreadState* __tstate = wxPyBeginAllowThreads();
12926 delete arg1;
12927
12928 wxPyEndAllowThreads(__tstate);
12929 if (PyErr_Occurred()) SWIG_fail;
12930 }
12931 resultobj = SWIG_Py_Void();
12932 return resultobj;
12933 fail:
12934 return NULL;
12935 }
12936
12937
12938 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12939 PyObject *resultobj = 0;
12940 wxString *arg1 = 0 ;
12941 wxString *arg2 = 0 ;
12942 int arg3 = (int) -1 ;
12943 wxImage *result = 0 ;
12944 bool temp1 = false ;
12945 bool temp2 = false ;
12946 int val3 ;
12947 int ecode3 = 0 ;
12948 PyObject * obj0 = 0 ;
12949 PyObject * obj1 = 0 ;
12950 PyObject * obj2 = 0 ;
12951 char * kwnames[] = {
12952 (char *) "name",(char *) "mimetype",(char *) "index", NULL
12953 };
12954
12955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12956 {
12957 arg1 = wxString_in_helper(obj0);
12958 if (arg1 == NULL) SWIG_fail;
12959 temp1 = true;
12960 }
12961 {
12962 arg2 = wxString_in_helper(obj1);
12963 if (arg2 == NULL) SWIG_fail;
12964 temp2 = true;
12965 }
12966 if (obj2) {
12967 ecode3 = SWIG_AsVal_int(obj2, &val3);
12968 if (!SWIG_IsOK(ecode3)) {
12969 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
12970 }
12971 arg3 = static_cast< int >(val3);
12972 }
12973 {
12974 PyThreadState* __tstate = wxPyBeginAllowThreads();
12975 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
12976 wxPyEndAllowThreads(__tstate);
12977 if (PyErr_Occurred()) SWIG_fail;
12978 }
12979 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
12980 {
12981 if (temp1)
12982 delete arg1;
12983 }
12984 {
12985 if (temp2)
12986 delete arg2;
12987 }
12988 return resultobj;
12989 fail:
12990 {
12991 if (temp1)
12992 delete arg1;
12993 }
12994 {
12995 if (temp2)
12996 delete arg2;
12997 }
12998 return NULL;
12999 }
13000
13001
13002 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13003 PyObject *resultobj = 0;
13004 wxInputStream *arg1 = 0 ;
13005 long arg2 = (long) wxBITMAP_TYPE_ANY ;
13006 int arg3 = (int) -1 ;
13007 wxImage *result = 0 ;
13008 wxPyInputStream *temp1 ;
13009 bool created1 ;
13010 long val2 ;
13011 int ecode2 = 0 ;
13012 int val3 ;
13013 int ecode3 = 0 ;
13014 PyObject * obj0 = 0 ;
13015 PyObject * obj1 = 0 ;
13016 PyObject * obj2 = 0 ;
13017 char * kwnames[] = {
13018 (char *) "stream",(char *) "type",(char *) "index", NULL
13019 };
13020
13021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13022 {
13023 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13024 arg1 = temp1->m_wxis;
13025 created1 = false;
13026 } else {
13027 PyErr_Clear(); // clear the failure of the wxPyConvert above
13028 arg1 = wxPyCBInputStream_create(obj0, false);
13029 if (arg1 == NULL) {
13030 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13031 SWIG_fail;
13032 }
13033 created1 = true;
13034 }
13035 }
13036 if (obj1) {
13037 ecode2 = SWIG_AsVal_long(obj1, &val2);
13038 if (!SWIG_IsOK(ecode2)) {
13039 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
13040 }
13041 arg2 = static_cast< long >(val2);
13042 }
13043 if (obj2) {
13044 ecode3 = SWIG_AsVal_int(obj2, &val3);
13045 if (!SWIG_IsOK(ecode3)) {
13046 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
13047 }
13048 arg3 = static_cast< int >(val3);
13049 }
13050 {
13051 PyThreadState* __tstate = wxPyBeginAllowThreads();
13052 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
13053 wxPyEndAllowThreads(__tstate);
13054 if (PyErr_Occurred()) SWIG_fail;
13055 }
13056 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13057 {
13058 if (created1) delete arg1;
13059 }
13060 return resultobj;
13061 fail:
13062 {
13063 if (created1) delete arg1;
13064 }
13065 return NULL;
13066 }
13067
13068
13069 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13070 PyObject *resultobj = 0;
13071 wxInputStream *arg1 = 0 ;
13072 wxString *arg2 = 0 ;
13073 int arg3 = (int) -1 ;
13074 wxImage *result = 0 ;
13075 wxPyInputStream *temp1 ;
13076 bool created1 ;
13077 bool temp2 = false ;
13078 int val3 ;
13079 int ecode3 = 0 ;
13080 PyObject * obj0 = 0 ;
13081 PyObject * obj1 = 0 ;
13082 PyObject * obj2 = 0 ;
13083 char * kwnames[] = {
13084 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
13085 };
13086
13087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13088 {
13089 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13090 arg1 = temp1->m_wxis;
13091 created1 = false;
13092 } else {
13093 PyErr_Clear(); // clear the failure of the wxPyConvert above
13094 arg1 = wxPyCBInputStream_create(obj0, false);
13095 if (arg1 == NULL) {
13096 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13097 SWIG_fail;
13098 }
13099 created1 = true;
13100 }
13101 }
13102 {
13103 arg2 = wxString_in_helper(obj1);
13104 if (arg2 == NULL) SWIG_fail;
13105 temp2 = true;
13106 }
13107 if (obj2) {
13108 ecode3 = SWIG_AsVal_int(obj2, &val3);
13109 if (!SWIG_IsOK(ecode3)) {
13110 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
13111 }
13112 arg3 = static_cast< int >(val3);
13113 }
13114 {
13115 PyThreadState* __tstate = wxPyBeginAllowThreads();
13116 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
13117 wxPyEndAllowThreads(__tstate);
13118 if (PyErr_Occurred()) SWIG_fail;
13119 }
13120 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13121 {
13122 if (created1) delete arg1;
13123 }
13124 {
13125 if (temp2)
13126 delete arg2;
13127 }
13128 return resultobj;
13129 fail:
13130 {
13131 if (created1) delete arg1;
13132 }
13133 {
13134 if (temp2)
13135 delete arg2;
13136 }
13137 return NULL;
13138 }
13139
13140
13141 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13142 PyObject *resultobj = 0;
13143 int arg1 = (int) 0 ;
13144 int arg2 = (int) 0 ;
13145 bool arg3 = (bool) true ;
13146 wxImage *result = 0 ;
13147 int val1 ;
13148 int ecode1 = 0 ;
13149 int val2 ;
13150 int ecode2 = 0 ;
13151 bool val3 ;
13152 int ecode3 = 0 ;
13153 PyObject * obj0 = 0 ;
13154 PyObject * obj1 = 0 ;
13155 PyObject * obj2 = 0 ;
13156 char * kwnames[] = {
13157 (char *) "width",(char *) "height",(char *) "clear", NULL
13158 };
13159
13160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13161 if (obj0) {
13162 ecode1 = SWIG_AsVal_int(obj0, &val1);
13163 if (!SWIG_IsOK(ecode1)) {
13164 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
13165 }
13166 arg1 = static_cast< int >(val1);
13167 }
13168 if (obj1) {
13169 ecode2 = SWIG_AsVal_int(obj1, &val2);
13170 if (!SWIG_IsOK(ecode2)) {
13171 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
13172 }
13173 arg2 = static_cast< int >(val2);
13174 }
13175 if (obj2) {
13176 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13177 if (!SWIG_IsOK(ecode3)) {
13178 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
13179 }
13180 arg3 = static_cast< bool >(val3);
13181 }
13182 {
13183 PyThreadState* __tstate = wxPyBeginAllowThreads();
13184 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
13185 wxPyEndAllowThreads(__tstate);
13186 if (PyErr_Occurred()) SWIG_fail;
13187 }
13188 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13189 return resultobj;
13190 fail:
13191 return NULL;
13192 }
13193
13194
13195 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13196 PyObject *resultobj = 0;
13197 wxBitmap *arg1 = 0 ;
13198 wxImage *result = 0 ;
13199 void *argp1 = 0 ;
13200 int res1 = 0 ;
13201 PyObject * obj0 = 0 ;
13202 char * kwnames[] = {
13203 (char *) "bitmap", NULL
13204 };
13205
13206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
13207 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
13208 if (!SWIG_IsOK(res1)) {
13209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13210 }
13211 if (!argp1) {
13212 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13213 }
13214 arg1 = reinterpret_cast< wxBitmap * >(argp1);
13215 {
13216 if (!wxPyCheckForApp()) SWIG_fail;
13217 PyThreadState* __tstate = wxPyBeginAllowThreads();
13218 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
13219 wxPyEndAllowThreads(__tstate);
13220 if (PyErr_Occurred()) SWIG_fail;
13221 }
13222 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13223 return resultobj;
13224 fail:
13225 return NULL;
13226 }
13227
13228
13229 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13230 PyObject *resultobj = 0;
13231 int arg1 ;
13232 int arg2 ;
13233 buffer arg3 ;
13234 int arg4 ;
13235 wxImage *result = 0 ;
13236 int val1 ;
13237 int ecode1 = 0 ;
13238 int val2 ;
13239 int ecode2 = 0 ;
13240 PyObject * obj0 = 0 ;
13241 PyObject * obj1 = 0 ;
13242 PyObject * obj2 = 0 ;
13243 char * kwnames[] = {
13244 (char *) "width",(char *) "height",(char *) "data", NULL
13245 };
13246
13247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13248 ecode1 = SWIG_AsVal_int(obj0, &val1);
13249 if (!SWIG_IsOK(ecode1)) {
13250 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
13251 }
13252 arg1 = static_cast< int >(val1);
13253 ecode2 = SWIG_AsVal_int(obj1, &val2);
13254 if (!SWIG_IsOK(ecode2)) {
13255 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
13256 }
13257 arg2 = static_cast< int >(val2);
13258 {
13259 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
13260 }
13261 {
13262 PyThreadState* __tstate = wxPyBeginAllowThreads();
13263 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
13264 wxPyEndAllowThreads(__tstate);
13265 if (PyErr_Occurred()) SWIG_fail;
13266 }
13267 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13268 return resultobj;
13269 fail:
13270 return NULL;
13271 }
13272
13273
13274 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13275 PyObject *resultobj = 0;
13276 int arg1 ;
13277 int arg2 ;
13278 buffer arg3 ;
13279 int arg4 ;
13280 buffer arg5 ;
13281 int arg6 ;
13282 wxImage *result = 0 ;
13283 int val1 ;
13284 int ecode1 = 0 ;
13285 int val2 ;
13286 int ecode2 = 0 ;
13287 PyObject * obj0 = 0 ;
13288 PyObject * obj1 = 0 ;
13289 PyObject * obj2 = 0 ;
13290 PyObject * obj3 = 0 ;
13291 char * kwnames[] = {
13292 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
13293 };
13294
13295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13296 ecode1 = SWIG_AsVal_int(obj0, &val1);
13297 if (!SWIG_IsOK(ecode1)) {
13298 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
13299 }
13300 arg1 = static_cast< int >(val1);
13301 ecode2 = SWIG_AsVal_int(obj1, &val2);
13302 if (!SWIG_IsOK(ecode2)) {
13303 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
13304 }
13305 arg2 = static_cast< int >(val2);
13306 {
13307 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
13308 }
13309 {
13310 if (!PyArg_Parse(obj3, "t#", &arg5, &arg6)) SWIG_fail;
13311 }
13312 {
13313 PyThreadState* __tstate = wxPyBeginAllowThreads();
13314 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
13315 wxPyEndAllowThreads(__tstate);
13316 if (PyErr_Occurred()) SWIG_fail;
13317 }
13318 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13319 return resultobj;
13320 fail:
13321 return NULL;
13322 }
13323
13324
13325 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13326 PyObject *resultobj = 0;
13327 wxImage *arg1 = (wxImage *) 0 ;
13328 int arg2 ;
13329 int arg3 ;
13330 bool arg4 = (bool) true ;
13331 void *argp1 = 0 ;
13332 int res1 = 0 ;
13333 int val2 ;
13334 int ecode2 = 0 ;
13335 int val3 ;
13336 int ecode3 = 0 ;
13337 bool val4 ;
13338 int ecode4 = 0 ;
13339 PyObject * obj0 = 0 ;
13340 PyObject * obj1 = 0 ;
13341 PyObject * obj2 = 0 ;
13342 PyObject * obj3 = 0 ;
13343 char * kwnames[] = {
13344 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
13345 };
13346
13347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13348 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13349 if (!SWIG_IsOK(res1)) {
13350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
13351 }
13352 arg1 = reinterpret_cast< wxImage * >(argp1);
13353 ecode2 = SWIG_AsVal_int(obj1, &val2);
13354 if (!SWIG_IsOK(ecode2)) {
13355 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
13356 }
13357 arg2 = static_cast< int >(val2);
13358 ecode3 = SWIG_AsVal_int(obj2, &val3);
13359 if (!SWIG_IsOK(ecode3)) {
13360 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
13361 }
13362 arg3 = static_cast< int >(val3);
13363 if (obj3) {
13364 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13365 if (!SWIG_IsOK(ecode4)) {
13366 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
13367 }
13368 arg4 = static_cast< bool >(val4);
13369 }
13370 {
13371 PyThreadState* __tstate = wxPyBeginAllowThreads();
13372 (arg1)->Create(arg2,arg3,arg4);
13373 wxPyEndAllowThreads(__tstate);
13374 if (PyErr_Occurred()) SWIG_fail;
13375 }
13376 resultobj = SWIG_Py_Void();
13377 return resultobj;
13378 fail:
13379 return NULL;
13380 }
13381
13382
13383 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13384 PyObject *resultobj = 0;
13385 wxImage *arg1 = (wxImage *) 0 ;
13386 void *argp1 = 0 ;
13387 int res1 = 0 ;
13388 PyObject *swig_obj[1] ;
13389
13390 if (!args) SWIG_fail;
13391 swig_obj[0] = args;
13392 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13393 if (!SWIG_IsOK(res1)) {
13394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
13395 }
13396 arg1 = reinterpret_cast< wxImage * >(argp1);
13397 {
13398 PyThreadState* __tstate = wxPyBeginAllowThreads();
13399 (arg1)->Destroy();
13400 wxPyEndAllowThreads(__tstate);
13401 if (PyErr_Occurred()) SWIG_fail;
13402 }
13403 resultobj = SWIG_Py_Void();
13404 return resultobj;
13405 fail:
13406 return NULL;
13407 }
13408
13409
13410 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13411 PyObject *resultobj = 0;
13412 wxImage *arg1 = (wxImage *) 0 ;
13413 int arg2 ;
13414 int arg3 ;
13415 SwigValueWrapper<wxImage > result;
13416 void *argp1 = 0 ;
13417 int res1 = 0 ;
13418 int val2 ;
13419 int ecode2 = 0 ;
13420 int val3 ;
13421 int ecode3 = 0 ;
13422 PyObject * obj0 = 0 ;
13423 PyObject * obj1 = 0 ;
13424 PyObject * obj2 = 0 ;
13425 char * kwnames[] = {
13426 (char *) "self",(char *) "width",(char *) "height", NULL
13427 };
13428
13429 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13430 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13431 if (!SWIG_IsOK(res1)) {
13432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
13433 }
13434 arg1 = reinterpret_cast< wxImage * >(argp1);
13435 ecode2 = SWIG_AsVal_int(obj1, &val2);
13436 if (!SWIG_IsOK(ecode2)) {
13437 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
13438 }
13439 arg2 = static_cast< int >(val2);
13440 ecode3 = SWIG_AsVal_int(obj2, &val3);
13441 if (!SWIG_IsOK(ecode3)) {
13442 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
13443 }
13444 arg3 = static_cast< int >(val3);
13445 {
13446 PyThreadState* __tstate = wxPyBeginAllowThreads();
13447 result = (arg1)->Scale(arg2,arg3);
13448 wxPyEndAllowThreads(__tstate);
13449 if (PyErr_Occurred()) SWIG_fail;
13450 }
13451 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13452 return resultobj;
13453 fail:
13454 return NULL;
13455 }
13456
13457
13458 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13459 PyObject *resultobj = 0;
13460 wxImage *arg1 = (wxImage *) 0 ;
13461 int arg2 ;
13462 int arg3 ;
13463 SwigValueWrapper<wxImage > result;
13464 void *argp1 = 0 ;
13465 int res1 = 0 ;
13466 int val2 ;
13467 int ecode2 = 0 ;
13468 int val3 ;
13469 int ecode3 = 0 ;
13470 PyObject * obj0 = 0 ;
13471 PyObject * obj1 = 0 ;
13472 PyObject * obj2 = 0 ;
13473 char * kwnames[] = {
13474 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
13475 };
13476
13477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13478 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13479 if (!SWIG_IsOK(res1)) {
13480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
13481 }
13482 arg1 = reinterpret_cast< wxImage * >(argp1);
13483 ecode2 = SWIG_AsVal_int(obj1, &val2);
13484 if (!SWIG_IsOK(ecode2)) {
13485 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
13486 }
13487 arg2 = static_cast< int >(val2);
13488 ecode3 = SWIG_AsVal_int(obj2, &val3);
13489 if (!SWIG_IsOK(ecode3)) {
13490 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
13491 }
13492 arg3 = static_cast< int >(val3);
13493 {
13494 PyThreadState* __tstate = wxPyBeginAllowThreads();
13495 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
13496 wxPyEndAllowThreads(__tstate);
13497 if (PyErr_Occurred()) SWIG_fail;
13498 }
13499 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13500 return resultobj;
13501 fail:
13502 return NULL;
13503 }
13504
13505
13506 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13507 PyObject *resultobj = 0;
13508 wxImage *arg1 = (wxImage *) 0 ;
13509 int arg2 ;
13510 int arg3 ;
13511 wxImage *result = 0 ;
13512 void *argp1 = 0 ;
13513 int res1 = 0 ;
13514 int val2 ;
13515 int ecode2 = 0 ;
13516 int val3 ;
13517 int ecode3 = 0 ;
13518 PyObject * obj0 = 0 ;
13519 PyObject * obj1 = 0 ;
13520 PyObject * obj2 = 0 ;
13521 char * kwnames[] = {
13522 (char *) "self",(char *) "width",(char *) "height", NULL
13523 };
13524
13525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13526 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13527 if (!SWIG_IsOK(res1)) {
13528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
13529 }
13530 arg1 = reinterpret_cast< wxImage * >(argp1);
13531 ecode2 = SWIG_AsVal_int(obj1, &val2);
13532 if (!SWIG_IsOK(ecode2)) {
13533 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
13534 }
13535 arg2 = static_cast< int >(val2);
13536 ecode3 = SWIG_AsVal_int(obj2, &val3);
13537 if (!SWIG_IsOK(ecode3)) {
13538 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
13539 }
13540 arg3 = static_cast< int >(val3);
13541 {
13542 PyThreadState* __tstate = wxPyBeginAllowThreads();
13543 {
13544 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
13545 result = (wxImage *) &_result_ref;
13546 }
13547 wxPyEndAllowThreads(__tstate);
13548 if (PyErr_Occurred()) SWIG_fail;
13549 }
13550 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13551 return resultobj;
13552 fail:
13553 return NULL;
13554 }
13555
13556
13557 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13558 PyObject *resultobj = 0;
13559 wxImage *arg1 = (wxImage *) 0 ;
13560 wxSize *arg2 = 0 ;
13561 wxPoint *arg3 = 0 ;
13562 int arg4 = (int) -1 ;
13563 int arg5 = (int) -1 ;
13564 int arg6 = (int) -1 ;
13565 wxImage *result = 0 ;
13566 void *argp1 = 0 ;
13567 int res1 = 0 ;
13568 wxSize temp2 ;
13569 wxPoint temp3 ;
13570 int val4 ;
13571 int ecode4 = 0 ;
13572 int val5 ;
13573 int ecode5 = 0 ;
13574 int val6 ;
13575 int ecode6 = 0 ;
13576 PyObject * obj0 = 0 ;
13577 PyObject * obj1 = 0 ;
13578 PyObject * obj2 = 0 ;
13579 PyObject * obj3 = 0 ;
13580 PyObject * obj4 = 0 ;
13581 PyObject * obj5 = 0 ;
13582 char * kwnames[] = {
13583 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
13584 };
13585
13586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13587 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13588 if (!SWIG_IsOK(res1)) {
13589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
13590 }
13591 arg1 = reinterpret_cast< wxImage * >(argp1);
13592 {
13593 arg2 = &temp2;
13594 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
13595 }
13596 {
13597 arg3 = &temp3;
13598 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13599 }
13600 if (obj3) {
13601 ecode4 = SWIG_AsVal_int(obj3, &val4);
13602 if (!SWIG_IsOK(ecode4)) {
13603 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
13604 }
13605 arg4 = static_cast< int >(val4);
13606 }
13607 if (obj4) {
13608 ecode5 = SWIG_AsVal_int(obj4, &val5);
13609 if (!SWIG_IsOK(ecode5)) {
13610 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
13611 }
13612 arg5 = static_cast< int >(val5);
13613 }
13614 if (obj5) {
13615 ecode6 = SWIG_AsVal_int(obj5, &val6);
13616 if (!SWIG_IsOK(ecode6)) {
13617 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
13618 }
13619 arg6 = static_cast< int >(val6);
13620 }
13621 {
13622 PyThreadState* __tstate = wxPyBeginAllowThreads();
13623 {
13624 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
13625 result = (wxImage *) &_result_ref;
13626 }
13627 wxPyEndAllowThreads(__tstate);
13628 if (PyErr_Occurred()) SWIG_fail;
13629 }
13630 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13631 return resultobj;
13632 fail:
13633 return NULL;
13634 }
13635
13636
13637 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13638 PyObject *resultobj = 0;
13639 wxImage *arg1 = (wxImage *) 0 ;
13640 int arg2 ;
13641 int arg3 ;
13642 byte arg4 ;
13643 byte arg5 ;
13644 byte arg6 ;
13645 void *argp1 = 0 ;
13646 int res1 = 0 ;
13647 int val2 ;
13648 int ecode2 = 0 ;
13649 int val3 ;
13650 int ecode3 = 0 ;
13651 unsigned char val4 ;
13652 int ecode4 = 0 ;
13653 unsigned char val5 ;
13654 int ecode5 = 0 ;
13655 unsigned char val6 ;
13656 int ecode6 = 0 ;
13657 PyObject * obj0 = 0 ;
13658 PyObject * obj1 = 0 ;
13659 PyObject * obj2 = 0 ;
13660 PyObject * obj3 = 0 ;
13661 PyObject * obj4 = 0 ;
13662 PyObject * obj5 = 0 ;
13663 char * kwnames[] = {
13664 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
13665 };
13666
13667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13668 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13669 if (!SWIG_IsOK(res1)) {
13670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
13671 }
13672 arg1 = reinterpret_cast< wxImage * >(argp1);
13673 ecode2 = SWIG_AsVal_int(obj1, &val2);
13674 if (!SWIG_IsOK(ecode2)) {
13675 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
13676 }
13677 arg2 = static_cast< int >(val2);
13678 ecode3 = SWIG_AsVal_int(obj2, &val3);
13679 if (!SWIG_IsOK(ecode3)) {
13680 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
13681 }
13682 arg3 = static_cast< int >(val3);
13683 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13684 if (!SWIG_IsOK(ecode4)) {
13685 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
13686 }
13687 arg4 = static_cast< byte >(val4);
13688 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13689 if (!SWIG_IsOK(ecode5)) {
13690 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
13691 }
13692 arg5 = static_cast< byte >(val5);
13693 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
13694 if (!SWIG_IsOK(ecode6)) {
13695 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
13696 }
13697 arg6 = static_cast< byte >(val6);
13698 {
13699 PyThreadState* __tstate = wxPyBeginAllowThreads();
13700 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
13701 wxPyEndAllowThreads(__tstate);
13702 if (PyErr_Occurred()) SWIG_fail;
13703 }
13704 resultobj = SWIG_Py_Void();
13705 return resultobj;
13706 fail:
13707 return NULL;
13708 }
13709
13710
13711 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13712 PyObject *resultobj = 0;
13713 wxImage *arg1 = (wxImage *) 0 ;
13714 wxRect *arg2 = 0 ;
13715 byte arg3 ;
13716 byte arg4 ;
13717 byte arg5 ;
13718 void *argp1 = 0 ;
13719 int res1 = 0 ;
13720 wxRect temp2 ;
13721 unsigned char val3 ;
13722 int ecode3 = 0 ;
13723 unsigned char val4 ;
13724 int ecode4 = 0 ;
13725 unsigned char val5 ;
13726 int ecode5 = 0 ;
13727 PyObject * obj0 = 0 ;
13728 PyObject * obj1 = 0 ;
13729 PyObject * obj2 = 0 ;
13730 PyObject * obj3 = 0 ;
13731 PyObject * obj4 = 0 ;
13732 char * kwnames[] = {
13733 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
13734 };
13735
13736 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
13737 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13738 if (!SWIG_IsOK(res1)) {
13739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
13740 }
13741 arg1 = reinterpret_cast< wxImage * >(argp1);
13742 {
13743 arg2 = &temp2;
13744 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13745 }
13746 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
13747 if (!SWIG_IsOK(ecode3)) {
13748 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
13749 }
13750 arg3 = static_cast< byte >(val3);
13751 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13752 if (!SWIG_IsOK(ecode4)) {
13753 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
13754 }
13755 arg4 = static_cast< byte >(val4);
13756 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13757 if (!SWIG_IsOK(ecode5)) {
13758 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
13759 }
13760 arg5 = static_cast< byte >(val5);
13761 {
13762 PyThreadState* __tstate = wxPyBeginAllowThreads();
13763 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
13764 wxPyEndAllowThreads(__tstate);
13765 if (PyErr_Occurred()) SWIG_fail;
13766 }
13767 resultobj = SWIG_Py_Void();
13768 return resultobj;
13769 fail:
13770 return NULL;
13771 }
13772
13773
13774 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13775 PyObject *resultobj = 0;
13776 wxImage *arg1 = (wxImage *) 0 ;
13777 int arg2 ;
13778 int arg3 ;
13779 byte result;
13780 void *argp1 = 0 ;
13781 int res1 = 0 ;
13782 int val2 ;
13783 int ecode2 = 0 ;
13784 int val3 ;
13785 int ecode3 = 0 ;
13786 PyObject * obj0 = 0 ;
13787 PyObject * obj1 = 0 ;
13788 PyObject * obj2 = 0 ;
13789 char * kwnames[] = {
13790 (char *) "self",(char *) "x",(char *) "y", NULL
13791 };
13792
13793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13794 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13795 if (!SWIG_IsOK(res1)) {
13796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
13797 }
13798 arg1 = reinterpret_cast< wxImage * >(argp1);
13799 ecode2 = SWIG_AsVal_int(obj1, &val2);
13800 if (!SWIG_IsOK(ecode2)) {
13801 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
13802 }
13803 arg2 = static_cast< int >(val2);
13804 ecode3 = SWIG_AsVal_int(obj2, &val3);
13805 if (!SWIG_IsOK(ecode3)) {
13806 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
13807 }
13808 arg3 = static_cast< int >(val3);
13809 {
13810 PyThreadState* __tstate = wxPyBeginAllowThreads();
13811 result = (byte)(arg1)->GetRed(arg2,arg3);
13812 wxPyEndAllowThreads(__tstate);
13813 if (PyErr_Occurred()) SWIG_fail;
13814 }
13815 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13816 return resultobj;
13817 fail:
13818 return NULL;
13819 }
13820
13821
13822 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13823 PyObject *resultobj = 0;
13824 wxImage *arg1 = (wxImage *) 0 ;
13825 int arg2 ;
13826 int arg3 ;
13827 byte result;
13828 void *argp1 = 0 ;
13829 int res1 = 0 ;
13830 int val2 ;
13831 int ecode2 = 0 ;
13832 int val3 ;
13833 int ecode3 = 0 ;
13834 PyObject * obj0 = 0 ;
13835 PyObject * obj1 = 0 ;
13836 PyObject * obj2 = 0 ;
13837 char * kwnames[] = {
13838 (char *) "self",(char *) "x",(char *) "y", NULL
13839 };
13840
13841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13842 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13843 if (!SWIG_IsOK(res1)) {
13844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
13845 }
13846 arg1 = reinterpret_cast< wxImage * >(argp1);
13847 ecode2 = SWIG_AsVal_int(obj1, &val2);
13848 if (!SWIG_IsOK(ecode2)) {
13849 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
13850 }
13851 arg2 = static_cast< int >(val2);
13852 ecode3 = SWIG_AsVal_int(obj2, &val3);
13853 if (!SWIG_IsOK(ecode3)) {
13854 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
13855 }
13856 arg3 = static_cast< int >(val3);
13857 {
13858 PyThreadState* __tstate = wxPyBeginAllowThreads();
13859 result = (byte)(arg1)->GetGreen(arg2,arg3);
13860 wxPyEndAllowThreads(__tstate);
13861 if (PyErr_Occurred()) SWIG_fail;
13862 }
13863 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13864 return resultobj;
13865 fail:
13866 return NULL;
13867 }
13868
13869
13870 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13871 PyObject *resultobj = 0;
13872 wxImage *arg1 = (wxImage *) 0 ;
13873 int arg2 ;
13874 int arg3 ;
13875 byte result;
13876 void *argp1 = 0 ;
13877 int res1 = 0 ;
13878 int val2 ;
13879 int ecode2 = 0 ;
13880 int val3 ;
13881 int ecode3 = 0 ;
13882 PyObject * obj0 = 0 ;
13883 PyObject * obj1 = 0 ;
13884 PyObject * obj2 = 0 ;
13885 char * kwnames[] = {
13886 (char *) "self",(char *) "x",(char *) "y", NULL
13887 };
13888
13889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13891 if (!SWIG_IsOK(res1)) {
13892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
13893 }
13894 arg1 = reinterpret_cast< wxImage * >(argp1);
13895 ecode2 = SWIG_AsVal_int(obj1, &val2);
13896 if (!SWIG_IsOK(ecode2)) {
13897 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
13898 }
13899 arg2 = static_cast< int >(val2);
13900 ecode3 = SWIG_AsVal_int(obj2, &val3);
13901 if (!SWIG_IsOK(ecode3)) {
13902 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
13903 }
13904 arg3 = static_cast< int >(val3);
13905 {
13906 PyThreadState* __tstate = wxPyBeginAllowThreads();
13907 result = (byte)(arg1)->GetBlue(arg2,arg3);
13908 wxPyEndAllowThreads(__tstate);
13909 if (PyErr_Occurred()) SWIG_fail;
13910 }
13911 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13912 return resultobj;
13913 fail:
13914 return NULL;
13915 }
13916
13917
13918 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13919 PyObject *resultobj = 0;
13920 wxImage *arg1 = (wxImage *) 0 ;
13921 int arg2 ;
13922 int arg3 ;
13923 byte arg4 ;
13924 void *argp1 = 0 ;
13925 int res1 = 0 ;
13926 int val2 ;
13927 int ecode2 = 0 ;
13928 int val3 ;
13929 int ecode3 = 0 ;
13930 unsigned char val4 ;
13931 int ecode4 = 0 ;
13932 PyObject * obj0 = 0 ;
13933 PyObject * obj1 = 0 ;
13934 PyObject * obj2 = 0 ;
13935 PyObject * obj3 = 0 ;
13936 char * kwnames[] = {
13937 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
13938 };
13939
13940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13941 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13942 if (!SWIG_IsOK(res1)) {
13943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
13944 }
13945 arg1 = reinterpret_cast< wxImage * >(argp1);
13946 ecode2 = SWIG_AsVal_int(obj1, &val2);
13947 if (!SWIG_IsOK(ecode2)) {
13948 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
13949 }
13950 arg2 = static_cast< int >(val2);
13951 ecode3 = SWIG_AsVal_int(obj2, &val3);
13952 if (!SWIG_IsOK(ecode3)) {
13953 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
13954 }
13955 arg3 = static_cast< int >(val3);
13956 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13957 if (!SWIG_IsOK(ecode4)) {
13958 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
13959 }
13960 arg4 = static_cast< byte >(val4);
13961 {
13962 PyThreadState* __tstate = wxPyBeginAllowThreads();
13963 (arg1)->SetAlpha(arg2,arg3,arg4);
13964 wxPyEndAllowThreads(__tstate);
13965 if (PyErr_Occurred()) SWIG_fail;
13966 }
13967 resultobj = SWIG_Py_Void();
13968 return resultobj;
13969 fail:
13970 return NULL;
13971 }
13972
13973
13974 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13975 PyObject *resultobj = 0;
13976 wxImage *arg1 = (wxImage *) 0 ;
13977 int arg2 ;
13978 int arg3 ;
13979 byte result;
13980 void *argp1 = 0 ;
13981 int res1 = 0 ;
13982 int val2 ;
13983 int ecode2 = 0 ;
13984 int val3 ;
13985 int ecode3 = 0 ;
13986 PyObject * obj0 = 0 ;
13987 PyObject * obj1 = 0 ;
13988 PyObject * obj2 = 0 ;
13989 char * kwnames[] = {
13990 (char *) "self",(char *) "x",(char *) "y", NULL
13991 };
13992
13993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13995 if (!SWIG_IsOK(res1)) {
13996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
13997 }
13998 arg1 = reinterpret_cast< wxImage * >(argp1);
13999 ecode2 = SWIG_AsVal_int(obj1, &val2);
14000 if (!SWIG_IsOK(ecode2)) {
14001 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
14002 }
14003 arg2 = static_cast< int >(val2);
14004 ecode3 = SWIG_AsVal_int(obj2, &val3);
14005 if (!SWIG_IsOK(ecode3)) {
14006 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
14007 }
14008 arg3 = static_cast< int >(val3);
14009 {
14010 PyThreadState* __tstate = wxPyBeginAllowThreads();
14011 result = (byte)(arg1)->GetAlpha(arg2,arg3);
14012 wxPyEndAllowThreads(__tstate);
14013 if (PyErr_Occurred()) SWIG_fail;
14014 }
14015 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14016 return resultobj;
14017 fail:
14018 return NULL;
14019 }
14020
14021
14022 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14023 PyObject *resultobj = 0;
14024 wxImage *arg1 = (wxImage *) 0 ;
14025 bool result;
14026 void *argp1 = 0 ;
14027 int res1 = 0 ;
14028 PyObject *swig_obj[1] ;
14029
14030 if (!args) SWIG_fail;
14031 swig_obj[0] = args;
14032 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14033 if (!SWIG_IsOK(res1)) {
14034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14035 }
14036 arg1 = reinterpret_cast< wxImage * >(argp1);
14037 {
14038 PyThreadState* __tstate = wxPyBeginAllowThreads();
14039 result = (bool)(arg1)->HasAlpha();
14040 wxPyEndAllowThreads(__tstate);
14041 if (PyErr_Occurred()) SWIG_fail;
14042 }
14043 {
14044 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14045 }
14046 return resultobj;
14047 fail:
14048 return NULL;
14049 }
14050
14051
14052 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14053 PyObject *resultobj = 0;
14054 wxImage *arg1 = (wxImage *) 0 ;
14055 void *argp1 = 0 ;
14056 int res1 = 0 ;
14057 PyObject *swig_obj[1] ;
14058
14059 if (!args) SWIG_fail;
14060 swig_obj[0] = args;
14061 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14062 if (!SWIG_IsOK(res1)) {
14063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14064 }
14065 arg1 = reinterpret_cast< wxImage * >(argp1);
14066 {
14067 PyThreadState* __tstate = wxPyBeginAllowThreads();
14068 (arg1)->InitAlpha();
14069 wxPyEndAllowThreads(__tstate);
14070 if (PyErr_Occurred()) SWIG_fail;
14071 }
14072 resultobj = SWIG_Py_Void();
14073 return resultobj;
14074 fail:
14075 return NULL;
14076 }
14077
14078
14079 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14080 PyObject *resultobj = 0;
14081 wxImage *arg1 = (wxImage *) 0 ;
14082 int arg2 ;
14083 int arg3 ;
14084 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14085 bool result;
14086 void *argp1 = 0 ;
14087 int res1 = 0 ;
14088 int val2 ;
14089 int ecode2 = 0 ;
14090 int val3 ;
14091 int ecode3 = 0 ;
14092 unsigned char val4 ;
14093 int ecode4 = 0 ;
14094 PyObject * obj0 = 0 ;
14095 PyObject * obj1 = 0 ;
14096 PyObject * obj2 = 0 ;
14097 PyObject * obj3 = 0 ;
14098 char * kwnames[] = {
14099 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
14100 };
14101
14102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14103 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14104 if (!SWIG_IsOK(res1)) {
14105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
14106 }
14107 arg1 = reinterpret_cast< wxImage * >(argp1);
14108 ecode2 = SWIG_AsVal_int(obj1, &val2);
14109 if (!SWIG_IsOK(ecode2)) {
14110 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
14111 }
14112 arg2 = static_cast< int >(val2);
14113 ecode3 = SWIG_AsVal_int(obj2, &val3);
14114 if (!SWIG_IsOK(ecode3)) {
14115 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
14116 }
14117 arg3 = static_cast< int >(val3);
14118 if (obj3) {
14119 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14120 if (!SWIG_IsOK(ecode4)) {
14121 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
14122 }
14123 arg4 = static_cast< byte >(val4);
14124 }
14125 {
14126 PyThreadState* __tstate = wxPyBeginAllowThreads();
14127 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
14128 wxPyEndAllowThreads(__tstate);
14129 if (PyErr_Occurred()) SWIG_fail;
14130 }
14131 {
14132 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14133 }
14134 return resultobj;
14135 fail:
14136 return NULL;
14137 }
14138
14139
14140 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14141 PyObject *resultobj = 0;
14142 wxImage *arg1 = (wxImage *) 0 ;
14143 byte *arg2 = (byte *) 0 ;
14144 byte *arg3 = (byte *) 0 ;
14145 byte *arg4 = (byte *) 0 ;
14146 byte arg5 = (byte) 0 ;
14147 byte arg6 = (byte) 0 ;
14148 byte arg7 = (byte) 0 ;
14149 bool result;
14150 void *argp1 = 0 ;
14151 int res1 = 0 ;
14152 byte temp2 ;
14153 int res2 = SWIG_TMPOBJ ;
14154 byte temp3 ;
14155 int res3 = SWIG_TMPOBJ ;
14156 byte temp4 ;
14157 int res4 = SWIG_TMPOBJ ;
14158 unsigned char val5 ;
14159 int ecode5 = 0 ;
14160 unsigned char val6 ;
14161 int ecode6 = 0 ;
14162 unsigned char val7 ;
14163 int ecode7 = 0 ;
14164 PyObject * obj0 = 0 ;
14165 PyObject * obj1 = 0 ;
14166 PyObject * obj2 = 0 ;
14167 PyObject * obj3 = 0 ;
14168 char * kwnames[] = {
14169 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14170 };
14171
14172 arg2 = &temp2;
14173 arg3 = &temp3;
14174 arg4 = &temp4;
14175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14177 if (!SWIG_IsOK(res1)) {
14178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
14179 }
14180 arg1 = reinterpret_cast< wxImage * >(argp1);
14181 if (obj1) {
14182 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14183 if (!SWIG_IsOK(ecode5)) {
14184 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14185 }
14186 arg5 = static_cast< byte >(val5);
14187 }
14188 if (obj2) {
14189 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14190 if (!SWIG_IsOK(ecode6)) {
14191 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14192 }
14193 arg6 = static_cast< byte >(val6);
14194 }
14195 if (obj3) {
14196 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14197 if (!SWIG_IsOK(ecode7)) {
14198 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14199 }
14200 arg7 = static_cast< byte >(val7);
14201 }
14202 {
14203 PyThreadState* __tstate = wxPyBeginAllowThreads();
14204 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14205 wxPyEndAllowThreads(__tstate);
14206 if (PyErr_Occurred()) SWIG_fail;
14207 }
14208 {
14209 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14210 }
14211 if (SWIG_IsTmpObj(res2)) {
14212 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14213 } else {
14214 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14215 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14216 }
14217 if (SWIG_IsTmpObj(res3)) {
14218 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14219 } else {
14220 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14221 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14222 }
14223 if (SWIG_IsTmpObj(res4)) {
14224 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14225 } else {
14226 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14227 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14228 }
14229 return resultobj;
14230 fail:
14231 return NULL;
14232 }
14233
14234
14235 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14236 PyObject *resultobj = 0;
14237 wxImage *arg1 = (wxImage *) 0 ;
14238 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14239 bool result;
14240 void *argp1 = 0 ;
14241 int res1 = 0 ;
14242 unsigned char val2 ;
14243 int ecode2 = 0 ;
14244 PyObject * obj0 = 0 ;
14245 PyObject * obj1 = 0 ;
14246 char * kwnames[] = {
14247 (char *) "self",(char *) "threshold", NULL
14248 };
14249
14250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
14251 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14252 if (!SWIG_IsOK(res1)) {
14253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
14254 }
14255 arg1 = reinterpret_cast< wxImage * >(argp1);
14256 if (obj1) {
14257 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14258 if (!SWIG_IsOK(ecode2)) {
14259 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
14260 }
14261 arg2 = static_cast< byte >(val2);
14262 }
14263 {
14264 PyThreadState* __tstate = wxPyBeginAllowThreads();
14265 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
14266 wxPyEndAllowThreads(__tstate);
14267 if (PyErr_Occurred()) SWIG_fail;
14268 }
14269 {
14270 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14271 }
14272 return resultobj;
14273 fail:
14274 return NULL;
14275 }
14276
14277
14278 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14279 PyObject *resultobj = 0;
14280 wxImage *arg1 = (wxImage *) 0 ;
14281 byte arg2 ;
14282 byte arg3 ;
14283 byte arg4 ;
14284 bool result;
14285 void *argp1 = 0 ;
14286 int res1 = 0 ;
14287 unsigned char val2 ;
14288 int ecode2 = 0 ;
14289 unsigned char val3 ;
14290 int ecode3 = 0 ;
14291 unsigned char val4 ;
14292 int ecode4 = 0 ;
14293 PyObject * obj0 = 0 ;
14294 PyObject * obj1 = 0 ;
14295 PyObject * obj2 = 0 ;
14296 PyObject * obj3 = 0 ;
14297 char * kwnames[] = {
14298 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
14299 };
14300
14301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14302 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14303 if (!SWIG_IsOK(res1)) {
14304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14305 }
14306 arg1 = reinterpret_cast< wxImage * >(argp1);
14307 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14308 if (!SWIG_IsOK(ecode2)) {
14309 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
14310 }
14311 arg2 = static_cast< byte >(val2);
14312 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14313 if (!SWIG_IsOK(ecode3)) {
14314 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
14315 }
14316 arg3 = static_cast< byte >(val3);
14317 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14318 if (!SWIG_IsOK(ecode4)) {
14319 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
14320 }
14321 arg4 = static_cast< byte >(val4);
14322 {
14323 PyThreadState* __tstate = wxPyBeginAllowThreads();
14324 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
14325 wxPyEndAllowThreads(__tstate);
14326 if (PyErr_Occurred()) SWIG_fail;
14327 }
14328 {
14329 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14330 }
14331 return resultobj;
14332 fail:
14333 return NULL;
14334 }
14335
14336
14337 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14338 PyObject *resultobj = 0;
14339 wxImage *arg1 = (wxImage *) 0 ;
14340 wxImage *arg2 = 0 ;
14341 byte arg3 ;
14342 byte arg4 ;
14343 byte arg5 ;
14344 bool result;
14345 void *argp1 = 0 ;
14346 int res1 = 0 ;
14347 void *argp2 = 0 ;
14348 int res2 = 0 ;
14349 unsigned char val3 ;
14350 int ecode3 = 0 ;
14351 unsigned char val4 ;
14352 int ecode4 = 0 ;
14353 unsigned char val5 ;
14354 int ecode5 = 0 ;
14355 PyObject * obj0 = 0 ;
14356 PyObject * obj1 = 0 ;
14357 PyObject * obj2 = 0 ;
14358 PyObject * obj3 = 0 ;
14359 PyObject * obj4 = 0 ;
14360 char * kwnames[] = {
14361 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
14362 };
14363
14364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
14365 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14366 if (!SWIG_IsOK(res1)) {
14367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
14368 }
14369 arg1 = reinterpret_cast< wxImage * >(argp1);
14370 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
14371 if (!SWIG_IsOK(res2)) {
14372 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14373 }
14374 if (!argp2) {
14375 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14376 }
14377 arg2 = reinterpret_cast< wxImage * >(argp2);
14378 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14379 if (!SWIG_IsOK(ecode3)) {
14380 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
14381 }
14382 arg3 = static_cast< byte >(val3);
14383 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14384 if (!SWIG_IsOK(ecode4)) {
14385 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
14386 }
14387 arg4 = static_cast< byte >(val4);
14388 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
14389 if (!SWIG_IsOK(ecode5)) {
14390 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
14391 }
14392 arg5 = static_cast< byte >(val5);
14393 {
14394 PyThreadState* __tstate = wxPyBeginAllowThreads();
14395 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
14396 wxPyEndAllowThreads(__tstate);
14397 if (PyErr_Occurred()) SWIG_fail;
14398 }
14399 {
14400 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14401 }
14402 return resultobj;
14403 fail:
14404 return NULL;
14405 }
14406
14407
14408 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14409 PyObject *resultobj = 0;
14410 wxString *arg1 = 0 ;
14411 bool result;
14412 bool temp1 = false ;
14413 PyObject * obj0 = 0 ;
14414 char * kwnames[] = {
14415 (char *) "filename", NULL
14416 };
14417
14418 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
14419 {
14420 arg1 = wxString_in_helper(obj0);
14421 if (arg1 == NULL) SWIG_fail;
14422 temp1 = true;
14423 }
14424 {
14425 PyThreadState* __tstate = wxPyBeginAllowThreads();
14426 result = (bool)wxImage::CanRead((wxString const &)*arg1);
14427 wxPyEndAllowThreads(__tstate);
14428 if (PyErr_Occurred()) SWIG_fail;
14429 }
14430 {
14431 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14432 }
14433 {
14434 if (temp1)
14435 delete arg1;
14436 }
14437 return resultobj;
14438 fail:
14439 {
14440 if (temp1)
14441 delete arg1;
14442 }
14443 return NULL;
14444 }
14445
14446
14447 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14448 PyObject *resultobj = 0;
14449 wxString *arg1 = 0 ;
14450 long arg2 = (long) wxBITMAP_TYPE_ANY ;
14451 int result;
14452 bool temp1 = false ;
14453 long val2 ;
14454 int ecode2 = 0 ;
14455 PyObject * obj0 = 0 ;
14456 PyObject * obj1 = 0 ;
14457 char * kwnames[] = {
14458 (char *) "filename",(char *) "type", NULL
14459 };
14460
14461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
14462 {
14463 arg1 = wxString_in_helper(obj0);
14464 if (arg1 == NULL) SWIG_fail;
14465 temp1 = true;
14466 }
14467 if (obj1) {
14468 ecode2 = SWIG_AsVal_long(obj1, &val2);
14469 if (!SWIG_IsOK(ecode2)) {
14470 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
14471 }
14472 arg2 = static_cast< long >(val2);
14473 }
14474 {
14475 PyThreadState* __tstate = wxPyBeginAllowThreads();
14476 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
14477 wxPyEndAllowThreads(__tstate);
14478 if (PyErr_Occurred()) SWIG_fail;
14479 }
14480 resultobj = SWIG_From_int(static_cast< int >(result));
14481 {
14482 if (temp1)
14483 delete arg1;
14484 }
14485 return resultobj;
14486 fail:
14487 {
14488 if (temp1)
14489 delete arg1;
14490 }
14491 return NULL;
14492 }
14493
14494
14495 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14496 PyObject *resultobj = 0;
14497 wxImage *arg1 = (wxImage *) 0 ;
14498 wxString *arg2 = 0 ;
14499 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14500 int arg4 = (int) -1 ;
14501 bool result;
14502 void *argp1 = 0 ;
14503 int res1 = 0 ;
14504 bool temp2 = false ;
14505 long val3 ;
14506 int ecode3 = 0 ;
14507 int val4 ;
14508 int ecode4 = 0 ;
14509 PyObject * obj0 = 0 ;
14510 PyObject * obj1 = 0 ;
14511 PyObject * obj2 = 0 ;
14512 PyObject * obj3 = 0 ;
14513 char * kwnames[] = {
14514 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
14515 };
14516
14517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14518 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14519 if (!SWIG_IsOK(res1)) {
14520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
14521 }
14522 arg1 = reinterpret_cast< wxImage * >(argp1);
14523 {
14524 arg2 = wxString_in_helper(obj1);
14525 if (arg2 == NULL) SWIG_fail;
14526 temp2 = true;
14527 }
14528 if (obj2) {
14529 ecode3 = SWIG_AsVal_long(obj2, &val3);
14530 if (!SWIG_IsOK(ecode3)) {
14531 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
14532 }
14533 arg3 = static_cast< long >(val3);
14534 }
14535 if (obj3) {
14536 ecode4 = SWIG_AsVal_int(obj3, &val4);
14537 if (!SWIG_IsOK(ecode4)) {
14538 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
14539 }
14540 arg4 = static_cast< int >(val4);
14541 }
14542 {
14543 PyThreadState* __tstate = wxPyBeginAllowThreads();
14544 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
14545 wxPyEndAllowThreads(__tstate);
14546 if (PyErr_Occurred()) SWIG_fail;
14547 }
14548 {
14549 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14550 }
14551 {
14552 if (temp2)
14553 delete arg2;
14554 }
14555 return resultobj;
14556 fail:
14557 {
14558 if (temp2)
14559 delete arg2;
14560 }
14561 return NULL;
14562 }
14563
14564
14565 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14566 PyObject *resultobj = 0;
14567 wxImage *arg1 = (wxImage *) 0 ;
14568 wxString *arg2 = 0 ;
14569 wxString *arg3 = 0 ;
14570 int arg4 = (int) -1 ;
14571 bool result;
14572 void *argp1 = 0 ;
14573 int res1 = 0 ;
14574 bool temp2 = false ;
14575 bool temp3 = false ;
14576 int val4 ;
14577 int ecode4 = 0 ;
14578 PyObject * obj0 = 0 ;
14579 PyObject * obj1 = 0 ;
14580 PyObject * obj2 = 0 ;
14581 PyObject * obj3 = 0 ;
14582 char * kwnames[] = {
14583 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
14584 };
14585
14586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14587 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14588 if (!SWIG_IsOK(res1)) {
14589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14590 }
14591 arg1 = reinterpret_cast< wxImage * >(argp1);
14592 {
14593 arg2 = wxString_in_helper(obj1);
14594 if (arg2 == NULL) SWIG_fail;
14595 temp2 = true;
14596 }
14597 {
14598 arg3 = wxString_in_helper(obj2);
14599 if (arg3 == NULL) SWIG_fail;
14600 temp3 = true;
14601 }
14602 if (obj3) {
14603 ecode4 = SWIG_AsVal_int(obj3, &val4);
14604 if (!SWIG_IsOK(ecode4)) {
14605 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
14606 }
14607 arg4 = static_cast< int >(val4);
14608 }
14609 {
14610 PyThreadState* __tstate = wxPyBeginAllowThreads();
14611 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14612 wxPyEndAllowThreads(__tstate);
14613 if (PyErr_Occurred()) SWIG_fail;
14614 }
14615 {
14616 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14617 }
14618 {
14619 if (temp2)
14620 delete arg2;
14621 }
14622 {
14623 if (temp3)
14624 delete arg3;
14625 }
14626 return resultobj;
14627 fail:
14628 {
14629 if (temp2)
14630 delete arg2;
14631 }
14632 {
14633 if (temp3)
14634 delete arg3;
14635 }
14636 return NULL;
14637 }
14638
14639
14640 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14641 PyObject *resultobj = 0;
14642 wxImage *arg1 = (wxImage *) 0 ;
14643 wxString *arg2 = 0 ;
14644 int arg3 ;
14645 bool result;
14646 void *argp1 = 0 ;
14647 int res1 = 0 ;
14648 bool temp2 = false ;
14649 int val3 ;
14650 int ecode3 = 0 ;
14651 PyObject * obj0 = 0 ;
14652 PyObject * obj1 = 0 ;
14653 PyObject * obj2 = 0 ;
14654 char * kwnames[] = {
14655 (char *) "self",(char *) "name",(char *) "type", NULL
14656 };
14657
14658 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14659 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14660 if (!SWIG_IsOK(res1)) {
14661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
14662 }
14663 arg1 = reinterpret_cast< wxImage * >(argp1);
14664 {
14665 arg2 = wxString_in_helper(obj1);
14666 if (arg2 == NULL) SWIG_fail;
14667 temp2 = true;
14668 }
14669 ecode3 = SWIG_AsVal_int(obj2, &val3);
14670 if (!SWIG_IsOK(ecode3)) {
14671 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
14672 }
14673 arg3 = static_cast< int >(val3);
14674 {
14675 PyThreadState* __tstate = wxPyBeginAllowThreads();
14676 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
14677 wxPyEndAllowThreads(__tstate);
14678 if (PyErr_Occurred()) SWIG_fail;
14679 }
14680 {
14681 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14682 }
14683 {
14684 if (temp2)
14685 delete arg2;
14686 }
14687 return resultobj;
14688 fail:
14689 {
14690 if (temp2)
14691 delete arg2;
14692 }
14693 return NULL;
14694 }
14695
14696
14697 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14698 PyObject *resultobj = 0;
14699 wxImage *arg1 = (wxImage *) 0 ;
14700 wxString *arg2 = 0 ;
14701 wxString *arg3 = 0 ;
14702 bool result;
14703 void *argp1 = 0 ;
14704 int res1 = 0 ;
14705 bool temp2 = false ;
14706 bool temp3 = false ;
14707 PyObject * obj0 = 0 ;
14708 PyObject * obj1 = 0 ;
14709 PyObject * obj2 = 0 ;
14710 char * kwnames[] = {
14711 (char *) "self",(char *) "name",(char *) "mimetype", NULL
14712 };
14713
14714 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14715 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14716 if (!SWIG_IsOK(res1)) {
14717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14718 }
14719 arg1 = reinterpret_cast< wxImage * >(argp1);
14720 {
14721 arg2 = wxString_in_helper(obj1);
14722 if (arg2 == NULL) SWIG_fail;
14723 temp2 = true;
14724 }
14725 {
14726 arg3 = wxString_in_helper(obj2);
14727 if (arg3 == NULL) SWIG_fail;
14728 temp3 = true;
14729 }
14730 {
14731 PyThreadState* __tstate = wxPyBeginAllowThreads();
14732 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
14733 wxPyEndAllowThreads(__tstate);
14734 if (PyErr_Occurred()) SWIG_fail;
14735 }
14736 {
14737 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14738 }
14739 {
14740 if (temp2)
14741 delete arg2;
14742 }
14743 {
14744 if (temp3)
14745 delete arg3;
14746 }
14747 return resultobj;
14748 fail:
14749 {
14750 if (temp2)
14751 delete arg2;
14752 }
14753 {
14754 if (temp3)
14755 delete arg3;
14756 }
14757 return NULL;
14758 }
14759
14760
14761 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14762 PyObject *resultobj = 0;
14763 wxInputStream *arg1 = 0 ;
14764 bool result;
14765 wxPyInputStream *temp1 ;
14766 bool created1 ;
14767 PyObject * obj0 = 0 ;
14768 char * kwnames[] = {
14769 (char *) "stream", NULL
14770 };
14771
14772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
14773 {
14774 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
14775 arg1 = temp1->m_wxis;
14776 created1 = false;
14777 } else {
14778 PyErr_Clear(); // clear the failure of the wxPyConvert above
14779 arg1 = wxPyCBInputStream_create(obj0, false);
14780 if (arg1 == NULL) {
14781 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14782 SWIG_fail;
14783 }
14784 created1 = true;
14785 }
14786 }
14787 {
14788 PyThreadState* __tstate = wxPyBeginAllowThreads();
14789 result = (bool)wxImage::CanRead(*arg1);
14790 wxPyEndAllowThreads(__tstate);
14791 if (PyErr_Occurred()) SWIG_fail;
14792 }
14793 {
14794 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14795 }
14796 {
14797 if (created1) delete arg1;
14798 }
14799 return resultobj;
14800 fail:
14801 {
14802 if (created1) delete arg1;
14803 }
14804 return NULL;
14805 }
14806
14807
14808 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14809 PyObject *resultobj = 0;
14810 wxImage *arg1 = (wxImage *) 0 ;
14811 wxInputStream *arg2 = 0 ;
14812 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14813 int arg4 = (int) -1 ;
14814 bool result;
14815 void *argp1 = 0 ;
14816 int res1 = 0 ;
14817 wxPyInputStream *temp2 ;
14818 bool created2 ;
14819 long val3 ;
14820 int ecode3 = 0 ;
14821 int val4 ;
14822 int ecode4 = 0 ;
14823 PyObject * obj0 = 0 ;
14824 PyObject * obj1 = 0 ;
14825 PyObject * obj2 = 0 ;
14826 PyObject * obj3 = 0 ;
14827 char * kwnames[] = {
14828 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
14829 };
14830
14831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14833 if (!SWIG_IsOK(res1)) {
14834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
14835 }
14836 arg1 = reinterpret_cast< wxImage * >(argp1);
14837 {
14838 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14839 arg2 = temp2->m_wxis;
14840 created2 = false;
14841 } else {
14842 PyErr_Clear(); // clear the failure of the wxPyConvert above
14843 arg2 = wxPyCBInputStream_create(obj1, false);
14844 if (arg2 == NULL) {
14845 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14846 SWIG_fail;
14847 }
14848 created2 = true;
14849 }
14850 }
14851 if (obj2) {
14852 ecode3 = SWIG_AsVal_long(obj2, &val3);
14853 if (!SWIG_IsOK(ecode3)) {
14854 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
14855 }
14856 arg3 = static_cast< long >(val3);
14857 }
14858 if (obj3) {
14859 ecode4 = SWIG_AsVal_int(obj3, &val4);
14860 if (!SWIG_IsOK(ecode4)) {
14861 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
14862 }
14863 arg4 = static_cast< int >(val4);
14864 }
14865 {
14866 PyThreadState* __tstate = wxPyBeginAllowThreads();
14867 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
14868 wxPyEndAllowThreads(__tstate);
14869 if (PyErr_Occurred()) SWIG_fail;
14870 }
14871 {
14872 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14873 }
14874 {
14875 if (created2) delete arg2;
14876 }
14877 return resultobj;
14878 fail:
14879 {
14880 if (created2) delete arg2;
14881 }
14882 return NULL;
14883 }
14884
14885
14886 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14887 PyObject *resultobj = 0;
14888 wxImage *arg1 = (wxImage *) 0 ;
14889 wxInputStream *arg2 = 0 ;
14890 wxString *arg3 = 0 ;
14891 int arg4 = (int) -1 ;
14892 bool result;
14893 void *argp1 = 0 ;
14894 int res1 = 0 ;
14895 wxPyInputStream *temp2 ;
14896 bool created2 ;
14897 bool temp3 = false ;
14898 int val4 ;
14899 int ecode4 = 0 ;
14900 PyObject * obj0 = 0 ;
14901 PyObject * obj1 = 0 ;
14902 PyObject * obj2 = 0 ;
14903 PyObject * obj3 = 0 ;
14904 char * kwnames[] = {
14905 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
14906 };
14907
14908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14909 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14910 if (!SWIG_IsOK(res1)) {
14911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
14912 }
14913 arg1 = reinterpret_cast< wxImage * >(argp1);
14914 {
14915 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14916 arg2 = temp2->m_wxis;
14917 created2 = false;
14918 } else {
14919 PyErr_Clear(); // clear the failure of the wxPyConvert above
14920 arg2 = wxPyCBInputStream_create(obj1, false);
14921 if (arg2 == NULL) {
14922 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14923 SWIG_fail;
14924 }
14925 created2 = true;
14926 }
14927 }
14928 {
14929 arg3 = wxString_in_helper(obj2);
14930 if (arg3 == NULL) SWIG_fail;
14931 temp3 = true;
14932 }
14933 if (obj3) {
14934 ecode4 = SWIG_AsVal_int(obj3, &val4);
14935 if (!SWIG_IsOK(ecode4)) {
14936 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
14937 }
14938 arg4 = static_cast< int >(val4);
14939 }
14940 {
14941 PyThreadState* __tstate = wxPyBeginAllowThreads();
14942 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
14943 wxPyEndAllowThreads(__tstate);
14944 if (PyErr_Occurred()) SWIG_fail;
14945 }
14946 {
14947 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14948 }
14949 {
14950 if (created2) delete arg2;
14951 }
14952 {
14953 if (temp3)
14954 delete arg3;
14955 }
14956 return resultobj;
14957 fail:
14958 {
14959 if (created2) delete arg2;
14960 }
14961 {
14962 if (temp3)
14963 delete arg3;
14964 }
14965 return NULL;
14966 }
14967
14968
14969 SWIGINTERN PyObject *_wrap_Image_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14970 PyObject *resultobj = 0;
14971 wxImage *arg1 = (wxImage *) 0 ;
14972 bool result;
14973 void *argp1 = 0 ;
14974 int res1 = 0 ;
14975 PyObject *swig_obj[1] ;
14976
14977 if (!args) SWIG_fail;
14978 swig_obj[0] = args;
14979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14980 if (!SWIG_IsOK(res1)) {
14981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Ok" "', expected argument " "1"" of type '" "wxImage *""'");
14982 }
14983 arg1 = reinterpret_cast< wxImage * >(argp1);
14984 {
14985 PyThreadState* __tstate = wxPyBeginAllowThreads();
14986 result = (bool)(arg1)->Ok();
14987 wxPyEndAllowThreads(__tstate);
14988 if (PyErr_Occurred()) SWIG_fail;
14989 }
14990 {
14991 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14992 }
14993 return resultobj;
14994 fail:
14995 return NULL;
14996 }
14997
14998
14999 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15000 PyObject *resultobj = 0;
15001 wxImage *arg1 = (wxImage *) 0 ;
15002 int result;
15003 void *argp1 = 0 ;
15004 int res1 = 0 ;
15005 PyObject *swig_obj[1] ;
15006
15007 if (!args) SWIG_fail;
15008 swig_obj[0] = args;
15009 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15010 if (!SWIG_IsOK(res1)) {
15011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
15012 }
15013 arg1 = reinterpret_cast< wxImage * >(argp1);
15014 {
15015 PyThreadState* __tstate = wxPyBeginAllowThreads();
15016 result = (int)(arg1)->GetWidth();
15017 wxPyEndAllowThreads(__tstate);
15018 if (PyErr_Occurred()) SWIG_fail;
15019 }
15020 resultobj = SWIG_From_int(static_cast< int >(result));
15021 return resultobj;
15022 fail:
15023 return NULL;
15024 }
15025
15026
15027 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15028 PyObject *resultobj = 0;
15029 wxImage *arg1 = (wxImage *) 0 ;
15030 int result;
15031 void *argp1 = 0 ;
15032 int res1 = 0 ;
15033 PyObject *swig_obj[1] ;
15034
15035 if (!args) SWIG_fail;
15036 swig_obj[0] = args;
15037 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15038 if (!SWIG_IsOK(res1)) {
15039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
15040 }
15041 arg1 = reinterpret_cast< wxImage * >(argp1);
15042 {
15043 PyThreadState* __tstate = wxPyBeginAllowThreads();
15044 result = (int)(arg1)->GetHeight();
15045 wxPyEndAllowThreads(__tstate);
15046 if (PyErr_Occurred()) SWIG_fail;
15047 }
15048 resultobj = SWIG_From_int(static_cast< int >(result));
15049 return resultobj;
15050 fail:
15051 return NULL;
15052 }
15053
15054
15055 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15056 PyObject *resultobj = 0;
15057 wxImage *arg1 = (wxImage *) 0 ;
15058 wxSize result;
15059 void *argp1 = 0 ;
15060 int res1 = 0 ;
15061 PyObject *swig_obj[1] ;
15062
15063 if (!args) SWIG_fail;
15064 swig_obj[0] = args;
15065 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15066 if (!SWIG_IsOK(res1)) {
15067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
15068 }
15069 arg1 = reinterpret_cast< wxImage * >(argp1);
15070 {
15071 PyThreadState* __tstate = wxPyBeginAllowThreads();
15072 result = wxImage_GetSize(arg1);
15073 wxPyEndAllowThreads(__tstate);
15074 if (PyErr_Occurred()) SWIG_fail;
15075 }
15076 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
15077 return resultobj;
15078 fail:
15079 return NULL;
15080 }
15081
15082
15083 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15084 PyObject *resultobj = 0;
15085 wxImage *arg1 = (wxImage *) 0 ;
15086 wxRect *arg2 = 0 ;
15087 SwigValueWrapper<wxImage > result;
15088 void *argp1 = 0 ;
15089 int res1 = 0 ;
15090 wxRect temp2 ;
15091 PyObject * obj0 = 0 ;
15092 PyObject * obj1 = 0 ;
15093 char * kwnames[] = {
15094 (char *) "self",(char *) "rect", NULL
15095 };
15096
15097 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
15098 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15099 if (!SWIG_IsOK(res1)) {
15100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
15101 }
15102 arg1 = reinterpret_cast< wxImage * >(argp1);
15103 {
15104 arg2 = &temp2;
15105 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
15106 }
15107 {
15108 PyThreadState* __tstate = wxPyBeginAllowThreads();
15109 result = (arg1)->GetSubImage((wxRect const &)*arg2);
15110 wxPyEndAllowThreads(__tstate);
15111 if (PyErr_Occurred()) SWIG_fail;
15112 }
15113 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15114 return resultobj;
15115 fail:
15116 return NULL;
15117 }
15118
15119
15120 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15121 PyObject *resultobj = 0;
15122 wxImage *arg1 = (wxImage *) 0 ;
15123 wxSize *arg2 = 0 ;
15124 wxPoint *arg3 = 0 ;
15125 int arg4 = (int) -1 ;
15126 int arg5 = (int) -1 ;
15127 int arg6 = (int) -1 ;
15128 SwigValueWrapper<wxImage > result;
15129 void *argp1 = 0 ;
15130 int res1 = 0 ;
15131 wxSize temp2 ;
15132 wxPoint temp3 ;
15133 int val4 ;
15134 int ecode4 = 0 ;
15135 int val5 ;
15136 int ecode5 = 0 ;
15137 int val6 ;
15138 int ecode6 = 0 ;
15139 PyObject * obj0 = 0 ;
15140 PyObject * obj1 = 0 ;
15141 PyObject * obj2 = 0 ;
15142 PyObject * obj3 = 0 ;
15143 PyObject * obj4 = 0 ;
15144 PyObject * obj5 = 0 ;
15145 char * kwnames[] = {
15146 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
15147 };
15148
15149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
15150 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15151 if (!SWIG_IsOK(res1)) {
15152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
15153 }
15154 arg1 = reinterpret_cast< wxImage * >(argp1);
15155 {
15156 arg2 = &temp2;
15157 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
15158 }
15159 {
15160 arg3 = &temp3;
15161 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15162 }
15163 if (obj3) {
15164 ecode4 = SWIG_AsVal_int(obj3, &val4);
15165 if (!SWIG_IsOK(ecode4)) {
15166 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
15167 }
15168 arg4 = static_cast< int >(val4);
15169 }
15170 if (obj4) {
15171 ecode5 = SWIG_AsVal_int(obj4, &val5);
15172 if (!SWIG_IsOK(ecode5)) {
15173 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
15174 }
15175 arg5 = static_cast< int >(val5);
15176 }
15177 if (obj5) {
15178 ecode6 = SWIG_AsVal_int(obj5, &val6);
15179 if (!SWIG_IsOK(ecode6)) {
15180 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
15181 }
15182 arg6 = static_cast< int >(val6);
15183 }
15184 {
15185 PyThreadState* __tstate = wxPyBeginAllowThreads();
15186 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
15187 wxPyEndAllowThreads(__tstate);
15188 if (PyErr_Occurred()) SWIG_fail;
15189 }
15190 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15191 return resultobj;
15192 fail:
15193 return NULL;
15194 }
15195
15196
15197 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15198 PyObject *resultobj = 0;
15199 wxImage *arg1 = (wxImage *) 0 ;
15200 SwigValueWrapper<wxImage > result;
15201 void *argp1 = 0 ;
15202 int res1 = 0 ;
15203 PyObject *swig_obj[1] ;
15204
15205 if (!args) SWIG_fail;
15206 swig_obj[0] = args;
15207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15208 if (!SWIG_IsOK(res1)) {
15209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
15210 }
15211 arg1 = reinterpret_cast< wxImage * >(argp1);
15212 {
15213 PyThreadState* __tstate = wxPyBeginAllowThreads();
15214 result = (arg1)->Copy();
15215 wxPyEndAllowThreads(__tstate);
15216 if (PyErr_Occurred()) SWIG_fail;
15217 }
15218 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15219 return resultobj;
15220 fail:
15221 return NULL;
15222 }
15223
15224
15225 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15226 PyObject *resultobj = 0;
15227 wxImage *arg1 = (wxImage *) 0 ;
15228 wxImage *arg2 = 0 ;
15229 int arg3 ;
15230 int arg4 ;
15231 void *argp1 = 0 ;
15232 int res1 = 0 ;
15233 void *argp2 = 0 ;
15234 int res2 = 0 ;
15235 int val3 ;
15236 int ecode3 = 0 ;
15237 int val4 ;
15238 int ecode4 = 0 ;
15239 PyObject * obj0 = 0 ;
15240 PyObject * obj1 = 0 ;
15241 PyObject * obj2 = 0 ;
15242 PyObject * obj3 = 0 ;
15243 char * kwnames[] = {
15244 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
15245 };
15246
15247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15248 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15249 if (!SWIG_IsOK(res1)) {
15250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
15251 }
15252 arg1 = reinterpret_cast< wxImage * >(argp1);
15253 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
15254 if (!SWIG_IsOK(res2)) {
15255 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15256 }
15257 if (!argp2) {
15258 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15259 }
15260 arg2 = reinterpret_cast< wxImage * >(argp2);
15261 ecode3 = SWIG_AsVal_int(obj2, &val3);
15262 if (!SWIG_IsOK(ecode3)) {
15263 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
15264 }
15265 arg3 = static_cast< int >(val3);
15266 ecode4 = SWIG_AsVal_int(obj3, &val4);
15267 if (!SWIG_IsOK(ecode4)) {
15268 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
15269 }
15270 arg4 = static_cast< int >(val4);
15271 {
15272 PyThreadState* __tstate = wxPyBeginAllowThreads();
15273 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
15274 wxPyEndAllowThreads(__tstate);
15275 if (PyErr_Occurred()) SWIG_fail;
15276 }
15277 resultobj = SWIG_Py_Void();
15278 return resultobj;
15279 fail:
15280 return NULL;
15281 }
15282
15283
15284 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15285 PyObject *resultobj = 0;
15286 wxImage *arg1 = (wxImage *) 0 ;
15287 PyObject *result = 0 ;
15288 void *argp1 = 0 ;
15289 int res1 = 0 ;
15290 PyObject *swig_obj[1] ;
15291
15292 if (!args) SWIG_fail;
15293 swig_obj[0] = args;
15294 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15295 if (!SWIG_IsOK(res1)) {
15296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
15297 }
15298 arg1 = reinterpret_cast< wxImage * >(argp1);
15299 {
15300 PyThreadState* __tstate = wxPyBeginAllowThreads();
15301 result = (PyObject *)wxImage_GetData(arg1);
15302 wxPyEndAllowThreads(__tstate);
15303 if (PyErr_Occurred()) SWIG_fail;
15304 }
15305 resultobj = result;
15306 return resultobj;
15307 fail:
15308 return NULL;
15309 }
15310
15311
15312 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15313 PyObject *resultobj = 0;
15314 wxImage *arg1 = (wxImage *) 0 ;
15315 buffer arg2 ;
15316 int arg3 ;
15317 void *argp1 = 0 ;
15318 int res1 = 0 ;
15319 PyObject * obj0 = 0 ;
15320 PyObject * obj1 = 0 ;
15321 char * kwnames[] = {
15322 (char *) "self",(char *) "data", NULL
15323 };
15324
15325 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
15326 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15327 if (!SWIG_IsOK(res1)) {
15328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
15329 }
15330 arg1 = reinterpret_cast< wxImage * >(argp1);
15331 {
15332 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15333 }
15334 {
15335 PyThreadState* __tstate = wxPyBeginAllowThreads();
15336 wxImage_SetData(arg1,arg2,arg3);
15337 wxPyEndAllowThreads(__tstate);
15338 if (PyErr_Occurred()) SWIG_fail;
15339 }
15340 resultobj = SWIG_Py_Void();
15341 return resultobj;
15342 fail:
15343 return NULL;
15344 }
15345
15346
15347 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15348 PyObject *resultobj = 0;
15349 wxImage *arg1 = (wxImage *) 0 ;
15350 PyObject *result = 0 ;
15351 void *argp1 = 0 ;
15352 int res1 = 0 ;
15353 PyObject *swig_obj[1] ;
15354
15355 if (!args) SWIG_fail;
15356 swig_obj[0] = args;
15357 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15358 if (!SWIG_IsOK(res1)) {
15359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15360 }
15361 arg1 = reinterpret_cast< wxImage * >(argp1);
15362 {
15363 PyThreadState* __tstate = wxPyBeginAllowThreads();
15364 result = (PyObject *)wxImage_GetDataBuffer(arg1);
15365 wxPyEndAllowThreads(__tstate);
15366 if (PyErr_Occurred()) SWIG_fail;
15367 }
15368 resultobj = result;
15369 return resultobj;
15370 fail:
15371 return NULL;
15372 }
15373
15374
15375 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15376 PyObject *resultobj = 0;
15377 wxImage *arg1 = (wxImage *) 0 ;
15378 buffer arg2 ;
15379 int arg3 ;
15380 void *argp1 = 0 ;
15381 int res1 = 0 ;
15382 PyObject * obj0 = 0 ;
15383 PyObject * obj1 = 0 ;
15384 char * kwnames[] = {
15385 (char *) "self",(char *) "data", NULL
15386 };
15387
15388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15389 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15390 if (!SWIG_IsOK(res1)) {
15391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15392 }
15393 arg1 = reinterpret_cast< wxImage * >(argp1);
15394 {
15395 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15396 }
15397 {
15398 PyThreadState* __tstate = wxPyBeginAllowThreads();
15399 wxImage_SetDataBuffer(arg1,arg2,arg3);
15400 wxPyEndAllowThreads(__tstate);
15401 if (PyErr_Occurred()) SWIG_fail;
15402 }
15403 resultobj = SWIG_Py_Void();
15404 return resultobj;
15405 fail:
15406 return NULL;
15407 }
15408
15409
15410 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15411 PyObject *resultobj = 0;
15412 wxImage *arg1 = (wxImage *) 0 ;
15413 PyObject *result = 0 ;
15414 void *argp1 = 0 ;
15415 int res1 = 0 ;
15416 PyObject *swig_obj[1] ;
15417
15418 if (!args) SWIG_fail;
15419 swig_obj[0] = args;
15420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15421 if (!SWIG_IsOK(res1)) {
15422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15423 }
15424 arg1 = reinterpret_cast< wxImage * >(argp1);
15425 {
15426 PyThreadState* __tstate = wxPyBeginAllowThreads();
15427 result = (PyObject *)wxImage_GetAlphaData(arg1);
15428 wxPyEndAllowThreads(__tstate);
15429 if (PyErr_Occurred()) SWIG_fail;
15430 }
15431 resultobj = result;
15432 return resultobj;
15433 fail:
15434 return NULL;
15435 }
15436
15437
15438 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15439 PyObject *resultobj = 0;
15440 wxImage *arg1 = (wxImage *) 0 ;
15441 buffer arg2 ;
15442 int arg3 ;
15443 void *argp1 = 0 ;
15444 int res1 = 0 ;
15445 PyObject * obj0 = 0 ;
15446 PyObject * obj1 = 0 ;
15447 char * kwnames[] = {
15448 (char *) "self",(char *) "alpha", NULL
15449 };
15450
15451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
15452 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15453 if (!SWIG_IsOK(res1)) {
15454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15455 }
15456 arg1 = reinterpret_cast< wxImage * >(argp1);
15457 {
15458 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15459 }
15460 {
15461 PyThreadState* __tstate = wxPyBeginAllowThreads();
15462 wxImage_SetAlphaData(arg1,arg2,arg3);
15463 wxPyEndAllowThreads(__tstate);
15464 if (PyErr_Occurred()) SWIG_fail;
15465 }
15466 resultobj = SWIG_Py_Void();
15467 return resultobj;
15468 fail:
15469 return NULL;
15470 }
15471
15472
15473 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15474 PyObject *resultobj = 0;
15475 wxImage *arg1 = (wxImage *) 0 ;
15476 PyObject *result = 0 ;
15477 void *argp1 = 0 ;
15478 int res1 = 0 ;
15479 PyObject *swig_obj[1] ;
15480
15481 if (!args) SWIG_fail;
15482 swig_obj[0] = args;
15483 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15484 if (!SWIG_IsOK(res1)) {
15485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15486 }
15487 arg1 = reinterpret_cast< wxImage * >(argp1);
15488 {
15489 PyThreadState* __tstate = wxPyBeginAllowThreads();
15490 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
15491 wxPyEndAllowThreads(__tstate);
15492 if (PyErr_Occurred()) SWIG_fail;
15493 }
15494 resultobj = result;
15495 return resultobj;
15496 fail:
15497 return NULL;
15498 }
15499
15500
15501 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15502 PyObject *resultobj = 0;
15503 wxImage *arg1 = (wxImage *) 0 ;
15504 buffer arg2 ;
15505 int arg3 ;
15506 void *argp1 = 0 ;
15507 int res1 = 0 ;
15508 PyObject * obj0 = 0 ;
15509 PyObject * obj1 = 0 ;
15510 char * kwnames[] = {
15511 (char *) "self",(char *) "alpha", NULL
15512 };
15513
15514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15515 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15516 if (!SWIG_IsOK(res1)) {
15517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15518 }
15519 arg1 = reinterpret_cast< wxImage * >(argp1);
15520 {
15521 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15522 }
15523 {
15524 PyThreadState* __tstate = wxPyBeginAllowThreads();
15525 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
15526 wxPyEndAllowThreads(__tstate);
15527 if (PyErr_Occurred()) SWIG_fail;
15528 }
15529 resultobj = SWIG_Py_Void();
15530 return resultobj;
15531 fail:
15532 return NULL;
15533 }
15534
15535
15536 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15537 PyObject *resultobj = 0;
15538 wxImage *arg1 = (wxImage *) 0 ;
15539 byte arg2 ;
15540 byte arg3 ;
15541 byte arg4 ;
15542 void *argp1 = 0 ;
15543 int res1 = 0 ;
15544 unsigned char val2 ;
15545 int ecode2 = 0 ;
15546 unsigned char val3 ;
15547 int ecode3 = 0 ;
15548 unsigned char val4 ;
15549 int ecode4 = 0 ;
15550 PyObject * obj0 = 0 ;
15551 PyObject * obj1 = 0 ;
15552 PyObject * obj2 = 0 ;
15553 PyObject * obj3 = 0 ;
15554 char * kwnames[] = {
15555 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
15556 };
15557
15558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15559 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15560 if (!SWIG_IsOK(res1)) {
15561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
15562 }
15563 arg1 = reinterpret_cast< wxImage * >(argp1);
15564 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15565 if (!SWIG_IsOK(ecode2)) {
15566 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
15567 }
15568 arg2 = static_cast< byte >(val2);
15569 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15570 if (!SWIG_IsOK(ecode3)) {
15571 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
15572 }
15573 arg3 = static_cast< byte >(val3);
15574 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15575 if (!SWIG_IsOK(ecode4)) {
15576 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
15577 }
15578 arg4 = static_cast< byte >(val4);
15579 {
15580 PyThreadState* __tstate = wxPyBeginAllowThreads();
15581 (arg1)->SetMaskColour(arg2,arg3,arg4);
15582 wxPyEndAllowThreads(__tstate);
15583 if (PyErr_Occurred()) SWIG_fail;
15584 }
15585 resultobj = SWIG_Py_Void();
15586 return resultobj;
15587 fail:
15588 return NULL;
15589 }
15590
15591
15592 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15593 PyObject *resultobj = 0;
15594 wxImage *arg1 = (wxImage *) 0 ;
15595 byte *arg2 = (byte *) 0 ;
15596 byte *arg3 = (byte *) 0 ;
15597 byte *arg4 = (byte *) 0 ;
15598 void *argp1 = 0 ;
15599 int res1 = 0 ;
15600 byte temp2 ;
15601 int res2 = SWIG_TMPOBJ ;
15602 byte temp3 ;
15603 int res3 = SWIG_TMPOBJ ;
15604 byte temp4 ;
15605 int res4 = SWIG_TMPOBJ ;
15606 PyObject *swig_obj[1] ;
15607
15608 arg2 = &temp2;
15609 arg3 = &temp3;
15610 arg4 = &temp4;
15611 if (!args) SWIG_fail;
15612 swig_obj[0] = args;
15613 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15614 if (!SWIG_IsOK(res1)) {
15615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
15616 }
15617 arg1 = reinterpret_cast< wxImage * >(argp1);
15618 {
15619 PyThreadState* __tstate = wxPyBeginAllowThreads();
15620 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
15621 wxPyEndAllowThreads(__tstate);
15622 if (PyErr_Occurred()) SWIG_fail;
15623 }
15624 resultobj = SWIG_Py_Void();
15625 if (SWIG_IsTmpObj(res2)) {
15626 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
15627 } else {
15628 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15629 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
15630 }
15631 if (SWIG_IsTmpObj(res3)) {
15632 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
15633 } else {
15634 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15635 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
15636 }
15637 if (SWIG_IsTmpObj(res4)) {
15638 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
15639 } else {
15640 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15641 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
15642 }
15643 return resultobj;
15644 fail:
15645 return NULL;
15646 }
15647
15648
15649 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15650 PyObject *resultobj = 0;
15651 wxImage *arg1 = (wxImage *) 0 ;
15652 byte result;
15653 void *argp1 = 0 ;
15654 int res1 = 0 ;
15655 PyObject *swig_obj[1] ;
15656
15657 if (!args) SWIG_fail;
15658 swig_obj[0] = args;
15659 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15660 if (!SWIG_IsOK(res1)) {
15661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
15662 }
15663 arg1 = reinterpret_cast< wxImage * >(argp1);
15664 {
15665 PyThreadState* __tstate = wxPyBeginAllowThreads();
15666 result = (byte)(arg1)->GetMaskRed();
15667 wxPyEndAllowThreads(__tstate);
15668 if (PyErr_Occurred()) SWIG_fail;
15669 }
15670 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15671 return resultobj;
15672 fail:
15673 return NULL;
15674 }
15675
15676
15677 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15678 PyObject *resultobj = 0;
15679 wxImage *arg1 = (wxImage *) 0 ;
15680 byte result;
15681 void *argp1 = 0 ;
15682 int res1 = 0 ;
15683 PyObject *swig_obj[1] ;
15684
15685 if (!args) SWIG_fail;
15686 swig_obj[0] = args;
15687 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15688 if (!SWIG_IsOK(res1)) {
15689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
15690 }
15691 arg1 = reinterpret_cast< wxImage * >(argp1);
15692 {
15693 PyThreadState* __tstate = wxPyBeginAllowThreads();
15694 result = (byte)(arg1)->GetMaskGreen();
15695 wxPyEndAllowThreads(__tstate);
15696 if (PyErr_Occurred()) SWIG_fail;
15697 }
15698 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15699 return resultobj;
15700 fail:
15701 return NULL;
15702 }
15703
15704
15705 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15706 PyObject *resultobj = 0;
15707 wxImage *arg1 = (wxImage *) 0 ;
15708 byte result;
15709 void *argp1 = 0 ;
15710 int res1 = 0 ;
15711 PyObject *swig_obj[1] ;
15712
15713 if (!args) SWIG_fail;
15714 swig_obj[0] = args;
15715 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15716 if (!SWIG_IsOK(res1)) {
15717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
15718 }
15719 arg1 = reinterpret_cast< wxImage * >(argp1);
15720 {
15721 PyThreadState* __tstate = wxPyBeginAllowThreads();
15722 result = (byte)(arg1)->GetMaskBlue();
15723 wxPyEndAllowThreads(__tstate);
15724 if (PyErr_Occurred()) SWIG_fail;
15725 }
15726 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15727 return resultobj;
15728 fail:
15729 return NULL;
15730 }
15731
15732
15733 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15734 PyObject *resultobj = 0;
15735 wxImage *arg1 = (wxImage *) 0 ;
15736 bool arg2 = (bool) true ;
15737 void *argp1 = 0 ;
15738 int res1 = 0 ;
15739 bool val2 ;
15740 int ecode2 = 0 ;
15741 PyObject * obj0 = 0 ;
15742 PyObject * obj1 = 0 ;
15743 char * kwnames[] = {
15744 (char *) "self",(char *) "mask", NULL
15745 };
15746
15747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
15748 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15749 if (!SWIG_IsOK(res1)) {
15750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
15751 }
15752 arg1 = reinterpret_cast< wxImage * >(argp1);
15753 if (obj1) {
15754 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15755 if (!SWIG_IsOK(ecode2)) {
15756 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
15757 }
15758 arg2 = static_cast< bool >(val2);
15759 }
15760 {
15761 PyThreadState* __tstate = wxPyBeginAllowThreads();
15762 (arg1)->SetMask(arg2);
15763 wxPyEndAllowThreads(__tstate);
15764 if (PyErr_Occurred()) SWIG_fail;
15765 }
15766 resultobj = SWIG_Py_Void();
15767 return resultobj;
15768 fail:
15769 return NULL;
15770 }
15771
15772
15773 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15774 PyObject *resultobj = 0;
15775 wxImage *arg1 = (wxImage *) 0 ;
15776 bool result;
15777 void *argp1 = 0 ;
15778 int res1 = 0 ;
15779 PyObject *swig_obj[1] ;
15780
15781 if (!args) SWIG_fail;
15782 swig_obj[0] = args;
15783 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15784 if (!SWIG_IsOK(res1)) {
15785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
15786 }
15787 arg1 = reinterpret_cast< wxImage * >(argp1);
15788 {
15789 PyThreadState* __tstate = wxPyBeginAllowThreads();
15790 result = (bool)(arg1)->HasMask();
15791 wxPyEndAllowThreads(__tstate);
15792 if (PyErr_Occurred()) SWIG_fail;
15793 }
15794 {
15795 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15796 }
15797 return resultobj;
15798 fail:
15799 return NULL;
15800 }
15801
15802
15803 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15804 PyObject *resultobj = 0;
15805 wxImage *arg1 = (wxImage *) 0 ;
15806 double arg2 ;
15807 wxPoint *arg3 = 0 ;
15808 bool arg4 = (bool) true ;
15809 wxPoint *arg5 = (wxPoint *) NULL ;
15810 SwigValueWrapper<wxImage > result;
15811 void *argp1 = 0 ;
15812 int res1 = 0 ;
15813 double val2 ;
15814 int ecode2 = 0 ;
15815 wxPoint temp3 ;
15816 bool val4 ;
15817 int ecode4 = 0 ;
15818 void *argp5 = 0 ;
15819 int res5 = 0 ;
15820 PyObject * obj0 = 0 ;
15821 PyObject * obj1 = 0 ;
15822 PyObject * obj2 = 0 ;
15823 PyObject * obj3 = 0 ;
15824 PyObject * obj4 = 0 ;
15825 char * kwnames[] = {
15826 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
15827 };
15828
15829 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
15830 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15831 if (!SWIG_IsOK(res1)) {
15832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
15833 }
15834 arg1 = reinterpret_cast< wxImage * >(argp1);
15835 ecode2 = SWIG_AsVal_double(obj1, &val2);
15836 if (!SWIG_IsOK(ecode2)) {
15837 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
15838 }
15839 arg2 = static_cast< double >(val2);
15840 {
15841 arg3 = &temp3;
15842 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15843 }
15844 if (obj3) {
15845 ecode4 = SWIG_AsVal_bool(obj3, &val4);
15846 if (!SWIG_IsOK(ecode4)) {
15847 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
15848 }
15849 arg4 = static_cast< bool >(val4);
15850 }
15851 if (obj4) {
15852 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
15853 if (!SWIG_IsOK(res5)) {
15854 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
15855 }
15856 arg5 = reinterpret_cast< wxPoint * >(argp5);
15857 }
15858 {
15859 PyThreadState* __tstate = wxPyBeginAllowThreads();
15860 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
15861 wxPyEndAllowThreads(__tstate);
15862 if (PyErr_Occurred()) SWIG_fail;
15863 }
15864 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15865 return resultobj;
15866 fail:
15867 return NULL;
15868 }
15869
15870
15871 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15872 PyObject *resultobj = 0;
15873 wxImage *arg1 = (wxImage *) 0 ;
15874 bool arg2 = (bool) true ;
15875 SwigValueWrapper<wxImage > result;
15876 void *argp1 = 0 ;
15877 int res1 = 0 ;
15878 bool val2 ;
15879 int ecode2 = 0 ;
15880 PyObject * obj0 = 0 ;
15881 PyObject * obj1 = 0 ;
15882 char * kwnames[] = {
15883 (char *) "self",(char *) "clockwise", NULL
15884 };
15885
15886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
15887 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15888 if (!SWIG_IsOK(res1)) {
15889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
15890 }
15891 arg1 = reinterpret_cast< wxImage * >(argp1);
15892 if (obj1) {
15893 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15894 if (!SWIG_IsOK(ecode2)) {
15895 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
15896 }
15897 arg2 = static_cast< bool >(val2);
15898 }
15899 {
15900 PyThreadState* __tstate = wxPyBeginAllowThreads();
15901 result = (arg1)->Rotate90(arg2);
15902 wxPyEndAllowThreads(__tstate);
15903 if (PyErr_Occurred()) SWIG_fail;
15904 }
15905 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15906 return resultobj;
15907 fail:
15908 return NULL;
15909 }
15910
15911
15912 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15913 PyObject *resultobj = 0;
15914 wxImage *arg1 = (wxImage *) 0 ;
15915 bool arg2 = (bool) true ;
15916 SwigValueWrapper<wxImage > result;
15917 void *argp1 = 0 ;
15918 int res1 = 0 ;
15919 bool val2 ;
15920 int ecode2 = 0 ;
15921 PyObject * obj0 = 0 ;
15922 PyObject * obj1 = 0 ;
15923 char * kwnames[] = {
15924 (char *) "self",(char *) "horizontally", NULL
15925 };
15926
15927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
15928 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15929 if (!SWIG_IsOK(res1)) {
15930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
15931 }
15932 arg1 = reinterpret_cast< wxImage * >(argp1);
15933 if (obj1) {
15934 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15935 if (!SWIG_IsOK(ecode2)) {
15936 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
15937 }
15938 arg2 = static_cast< bool >(val2);
15939 }
15940 {
15941 PyThreadState* __tstate = wxPyBeginAllowThreads();
15942 result = (arg1)->Mirror(arg2);
15943 wxPyEndAllowThreads(__tstate);
15944 if (PyErr_Occurred()) SWIG_fail;
15945 }
15946 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15947 return resultobj;
15948 fail:
15949 return NULL;
15950 }
15951
15952
15953 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15954 PyObject *resultobj = 0;
15955 wxImage *arg1 = (wxImage *) 0 ;
15956 byte arg2 ;
15957 byte arg3 ;
15958 byte arg4 ;
15959 byte arg5 ;
15960 byte arg6 ;
15961 byte arg7 ;
15962 void *argp1 = 0 ;
15963 int res1 = 0 ;
15964 unsigned char val2 ;
15965 int ecode2 = 0 ;
15966 unsigned char val3 ;
15967 int ecode3 = 0 ;
15968 unsigned char val4 ;
15969 int ecode4 = 0 ;
15970 unsigned char val5 ;
15971 int ecode5 = 0 ;
15972 unsigned char val6 ;
15973 int ecode6 = 0 ;
15974 unsigned char val7 ;
15975 int ecode7 = 0 ;
15976 PyObject * obj0 = 0 ;
15977 PyObject * obj1 = 0 ;
15978 PyObject * obj2 = 0 ;
15979 PyObject * obj3 = 0 ;
15980 PyObject * obj4 = 0 ;
15981 PyObject * obj5 = 0 ;
15982 PyObject * obj6 = 0 ;
15983 char * kwnames[] = {
15984 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
15985 };
15986
15987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
15988 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15989 if (!SWIG_IsOK(res1)) {
15990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
15991 }
15992 arg1 = reinterpret_cast< wxImage * >(argp1);
15993 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15994 if (!SWIG_IsOK(ecode2)) {
15995 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
15996 }
15997 arg2 = static_cast< byte >(val2);
15998 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15999 if (!SWIG_IsOK(ecode3)) {
16000 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
16001 }
16002 arg3 = static_cast< byte >(val3);
16003 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16004 if (!SWIG_IsOK(ecode4)) {
16005 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
16006 }
16007 arg4 = static_cast< byte >(val4);
16008 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16009 if (!SWIG_IsOK(ecode5)) {
16010 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
16011 }
16012 arg5 = static_cast< byte >(val5);
16013 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
16014 if (!SWIG_IsOK(ecode6)) {
16015 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
16016 }
16017 arg6 = static_cast< byte >(val6);
16018 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
16019 if (!SWIG_IsOK(ecode7)) {
16020 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
16021 }
16022 arg7 = static_cast< byte >(val7);
16023 {
16024 PyThreadState* __tstate = wxPyBeginAllowThreads();
16025 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
16026 wxPyEndAllowThreads(__tstate);
16027 if (PyErr_Occurred()) SWIG_fail;
16028 }
16029 resultobj = SWIG_Py_Void();
16030 return resultobj;
16031 fail:
16032 return NULL;
16033 }
16034
16035
16036 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16037 PyObject *resultobj = 0;
16038 wxImage *arg1 = (wxImage *) 0 ;
16039 double arg2 = (double) 0.299 ;
16040 double arg3 = (double) 0.587 ;
16041 double arg4 = (double) 0.114 ;
16042 SwigValueWrapper<wxImage > result;
16043 void *argp1 = 0 ;
16044 int res1 = 0 ;
16045 double val2 ;
16046 int ecode2 = 0 ;
16047 double val3 ;
16048 int ecode3 = 0 ;
16049 double val4 ;
16050 int ecode4 = 0 ;
16051 PyObject * obj0 = 0 ;
16052 PyObject * obj1 = 0 ;
16053 PyObject * obj2 = 0 ;
16054 PyObject * obj3 = 0 ;
16055 char * kwnames[] = {
16056 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
16057 };
16058
16059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16061 if (!SWIG_IsOK(res1)) {
16062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
16063 }
16064 arg1 = reinterpret_cast< wxImage * >(argp1);
16065 if (obj1) {
16066 ecode2 = SWIG_AsVal_double(obj1, &val2);
16067 if (!SWIG_IsOK(ecode2)) {
16068 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
16069 }
16070 arg2 = static_cast< double >(val2);
16071 }
16072 if (obj2) {
16073 ecode3 = SWIG_AsVal_double(obj2, &val3);
16074 if (!SWIG_IsOK(ecode3)) {
16075 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
16076 }
16077 arg3 = static_cast< double >(val3);
16078 }
16079 if (obj3) {
16080 ecode4 = SWIG_AsVal_double(obj3, &val4);
16081 if (!SWIG_IsOK(ecode4)) {
16082 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
16083 }
16084 arg4 = static_cast< double >(val4);
16085 }
16086 {
16087 PyThreadState* __tstate = wxPyBeginAllowThreads();
16088 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
16089 wxPyEndAllowThreads(__tstate);
16090 if (PyErr_Occurred()) SWIG_fail;
16091 }
16092 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16093 return resultobj;
16094 fail:
16095 return NULL;
16096 }
16097
16098
16099 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16100 PyObject *resultobj = 0;
16101 wxImage *arg1 = (wxImage *) 0 ;
16102 byte arg2 ;
16103 byte arg3 ;
16104 byte arg4 ;
16105 SwigValueWrapper<wxImage > result;
16106 void *argp1 = 0 ;
16107 int res1 = 0 ;
16108 unsigned char val2 ;
16109 int ecode2 = 0 ;
16110 unsigned char val3 ;
16111 int ecode3 = 0 ;
16112 unsigned char val4 ;
16113 int ecode4 = 0 ;
16114 PyObject * obj0 = 0 ;
16115 PyObject * obj1 = 0 ;
16116 PyObject * obj2 = 0 ;
16117 PyObject * obj3 = 0 ;
16118 char * kwnames[] = {
16119 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
16120 };
16121
16122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16123 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16124 if (!SWIG_IsOK(res1)) {
16125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
16126 }
16127 arg1 = reinterpret_cast< wxImage * >(argp1);
16128 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16129 if (!SWIG_IsOK(ecode2)) {
16130 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
16131 }
16132 arg2 = static_cast< byte >(val2);
16133 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16134 if (!SWIG_IsOK(ecode3)) {
16135 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
16136 }
16137 arg3 = static_cast< byte >(val3);
16138 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16139 if (!SWIG_IsOK(ecode4)) {
16140 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
16141 }
16142 arg4 = static_cast< byte >(val4);
16143 {
16144 PyThreadState* __tstate = wxPyBeginAllowThreads();
16145 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
16146 wxPyEndAllowThreads(__tstate);
16147 if (PyErr_Occurred()) SWIG_fail;
16148 }
16149 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16150 return resultobj;
16151 fail:
16152 return NULL;
16153 }
16154
16155
16156 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16157 PyObject *resultobj = 0;
16158 wxImage *arg1 = (wxImage *) 0 ;
16159 wxString *arg2 = 0 ;
16160 wxString *arg3 = 0 ;
16161 void *argp1 = 0 ;
16162 int res1 = 0 ;
16163 bool temp2 = false ;
16164 bool temp3 = false ;
16165 PyObject * obj0 = 0 ;
16166 PyObject * obj1 = 0 ;
16167 PyObject * obj2 = 0 ;
16168 char * kwnames[] = {
16169 (char *) "self",(char *) "name",(char *) "value", NULL
16170 };
16171
16172 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16173 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16174 if (!SWIG_IsOK(res1)) {
16175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
16176 }
16177 arg1 = reinterpret_cast< wxImage * >(argp1);
16178 {
16179 arg2 = wxString_in_helper(obj1);
16180 if (arg2 == NULL) SWIG_fail;
16181 temp2 = true;
16182 }
16183 {
16184 arg3 = wxString_in_helper(obj2);
16185 if (arg3 == NULL) SWIG_fail;
16186 temp3 = true;
16187 }
16188 {
16189 PyThreadState* __tstate = wxPyBeginAllowThreads();
16190 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
16191 wxPyEndAllowThreads(__tstate);
16192 if (PyErr_Occurred()) SWIG_fail;
16193 }
16194 resultobj = SWIG_Py_Void();
16195 {
16196 if (temp2)
16197 delete arg2;
16198 }
16199 {
16200 if (temp3)
16201 delete arg3;
16202 }
16203 return resultobj;
16204 fail:
16205 {
16206 if (temp2)
16207 delete arg2;
16208 }
16209 {
16210 if (temp3)
16211 delete arg3;
16212 }
16213 return NULL;
16214 }
16215
16216
16217 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16218 PyObject *resultobj = 0;
16219 wxImage *arg1 = (wxImage *) 0 ;
16220 wxString *arg2 = 0 ;
16221 int arg3 ;
16222 void *argp1 = 0 ;
16223 int res1 = 0 ;
16224 bool temp2 = false ;
16225 int val3 ;
16226 int ecode3 = 0 ;
16227 PyObject * obj0 = 0 ;
16228 PyObject * obj1 = 0 ;
16229 PyObject * obj2 = 0 ;
16230 char * kwnames[] = {
16231 (char *) "self",(char *) "name",(char *) "value", NULL
16232 };
16233
16234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16236 if (!SWIG_IsOK(res1)) {
16237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
16238 }
16239 arg1 = reinterpret_cast< wxImage * >(argp1);
16240 {
16241 arg2 = wxString_in_helper(obj1);
16242 if (arg2 == NULL) SWIG_fail;
16243 temp2 = true;
16244 }
16245 ecode3 = SWIG_AsVal_int(obj2, &val3);
16246 if (!SWIG_IsOK(ecode3)) {
16247 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
16248 }
16249 arg3 = static_cast< int >(val3);
16250 {
16251 PyThreadState* __tstate = wxPyBeginAllowThreads();
16252 (arg1)->SetOption((wxString const &)*arg2,arg3);
16253 wxPyEndAllowThreads(__tstate);
16254 if (PyErr_Occurred()) SWIG_fail;
16255 }
16256 resultobj = SWIG_Py_Void();
16257 {
16258 if (temp2)
16259 delete arg2;
16260 }
16261 return resultobj;
16262 fail:
16263 {
16264 if (temp2)
16265 delete arg2;
16266 }
16267 return NULL;
16268 }
16269
16270
16271 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16272 PyObject *resultobj = 0;
16273 wxImage *arg1 = (wxImage *) 0 ;
16274 wxString *arg2 = 0 ;
16275 wxString result;
16276 void *argp1 = 0 ;
16277 int res1 = 0 ;
16278 bool temp2 = false ;
16279 PyObject * obj0 = 0 ;
16280 PyObject * obj1 = 0 ;
16281 char * kwnames[] = {
16282 (char *) "self",(char *) "name", NULL
16283 };
16284
16285 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
16286 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16287 if (!SWIG_IsOK(res1)) {
16288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16289 }
16290 arg1 = reinterpret_cast< wxImage * >(argp1);
16291 {
16292 arg2 = wxString_in_helper(obj1);
16293 if (arg2 == NULL) SWIG_fail;
16294 temp2 = true;
16295 }
16296 {
16297 PyThreadState* __tstate = wxPyBeginAllowThreads();
16298 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
16299 wxPyEndAllowThreads(__tstate);
16300 if (PyErr_Occurred()) SWIG_fail;
16301 }
16302 {
16303 #if wxUSE_UNICODE
16304 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16305 #else
16306 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16307 #endif
16308 }
16309 {
16310 if (temp2)
16311 delete arg2;
16312 }
16313 return resultobj;
16314 fail:
16315 {
16316 if (temp2)
16317 delete arg2;
16318 }
16319 return NULL;
16320 }
16321
16322
16323 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16324 PyObject *resultobj = 0;
16325 wxImage *arg1 = (wxImage *) 0 ;
16326 wxString *arg2 = 0 ;
16327 int result;
16328 void *argp1 = 0 ;
16329 int res1 = 0 ;
16330 bool temp2 = false ;
16331 PyObject * obj0 = 0 ;
16332 PyObject * obj1 = 0 ;
16333 char * kwnames[] = {
16334 (char *) "self",(char *) "name", NULL
16335 };
16336
16337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
16338 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16339 if (!SWIG_IsOK(res1)) {
16340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
16341 }
16342 arg1 = reinterpret_cast< wxImage * >(argp1);
16343 {
16344 arg2 = wxString_in_helper(obj1);
16345 if (arg2 == NULL) SWIG_fail;
16346 temp2 = true;
16347 }
16348 {
16349 PyThreadState* __tstate = wxPyBeginAllowThreads();
16350 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
16351 wxPyEndAllowThreads(__tstate);
16352 if (PyErr_Occurred()) SWIG_fail;
16353 }
16354 resultobj = SWIG_From_int(static_cast< int >(result));
16355 {
16356 if (temp2)
16357 delete arg2;
16358 }
16359 return resultobj;
16360 fail:
16361 {
16362 if (temp2)
16363 delete arg2;
16364 }
16365 return NULL;
16366 }
16367
16368
16369 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16370 PyObject *resultobj = 0;
16371 wxImage *arg1 = (wxImage *) 0 ;
16372 wxString *arg2 = 0 ;
16373 bool result;
16374 void *argp1 = 0 ;
16375 int res1 = 0 ;
16376 bool temp2 = false ;
16377 PyObject * obj0 = 0 ;
16378 PyObject * obj1 = 0 ;
16379 char * kwnames[] = {
16380 (char *) "self",(char *) "name", NULL
16381 };
16382
16383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
16384 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16385 if (!SWIG_IsOK(res1)) {
16386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16387 }
16388 arg1 = reinterpret_cast< wxImage * >(argp1);
16389 {
16390 arg2 = wxString_in_helper(obj1);
16391 if (arg2 == NULL) SWIG_fail;
16392 temp2 = true;
16393 }
16394 {
16395 PyThreadState* __tstate = wxPyBeginAllowThreads();
16396 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
16397 wxPyEndAllowThreads(__tstate);
16398 if (PyErr_Occurred()) SWIG_fail;
16399 }
16400 {
16401 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16402 }
16403 {
16404 if (temp2)
16405 delete arg2;
16406 }
16407 return resultobj;
16408 fail:
16409 {
16410 if (temp2)
16411 delete arg2;
16412 }
16413 return NULL;
16414 }
16415
16416
16417 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16418 PyObject *resultobj = 0;
16419 wxImage *arg1 = (wxImage *) 0 ;
16420 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
16421 unsigned long result;
16422 void *argp1 = 0 ;
16423 int res1 = 0 ;
16424 unsigned long val2 ;
16425 int ecode2 = 0 ;
16426 PyObject * obj0 = 0 ;
16427 PyObject * obj1 = 0 ;
16428 char * kwnames[] = {
16429 (char *) "self",(char *) "stopafter", NULL
16430 };
16431
16432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
16433 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16434 if (!SWIG_IsOK(res1)) {
16435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
16436 }
16437 arg1 = reinterpret_cast< wxImage * >(argp1);
16438 if (obj1) {
16439 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
16440 if (!SWIG_IsOK(ecode2)) {
16441 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
16442 }
16443 arg2 = static_cast< unsigned long >(val2);
16444 }
16445 {
16446 PyThreadState* __tstate = wxPyBeginAllowThreads();
16447 result = (unsigned long)(arg1)->CountColours(arg2);
16448 wxPyEndAllowThreads(__tstate);
16449 if (PyErr_Occurred()) SWIG_fail;
16450 }
16451 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16452 return resultobj;
16453 fail:
16454 return NULL;
16455 }
16456
16457
16458 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16459 PyObject *resultobj = 0;
16460 wxImage *arg1 = (wxImage *) 0 ;
16461 wxImageHistogram *arg2 = 0 ;
16462 unsigned long result;
16463 void *argp1 = 0 ;
16464 int res1 = 0 ;
16465 void *argp2 = 0 ;
16466 int res2 = 0 ;
16467 PyObject * obj0 = 0 ;
16468 PyObject * obj1 = 0 ;
16469 char * kwnames[] = {
16470 (char *) "self",(char *) "h", NULL
16471 };
16472
16473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
16474 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16475 if (!SWIG_IsOK(res1)) {
16476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
16477 }
16478 arg1 = reinterpret_cast< wxImage * >(argp1);
16479 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
16480 if (!SWIG_IsOK(res2)) {
16481 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16482 }
16483 if (!argp2) {
16484 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16485 }
16486 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
16487 {
16488 PyThreadState* __tstate = wxPyBeginAllowThreads();
16489 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
16490 wxPyEndAllowThreads(__tstate);
16491 if (PyErr_Occurred()) SWIG_fail;
16492 }
16493 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16494 return resultobj;
16495 fail:
16496 return NULL;
16497 }
16498
16499
16500 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16501 PyObject *resultobj = 0;
16502 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16503 void *argp1 = 0 ;
16504 int res1 = 0 ;
16505 PyObject * obj0 = 0 ;
16506 char * kwnames[] = {
16507 (char *) "handler", NULL
16508 };
16509
16510 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
16511 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16512 if (!SWIG_IsOK(res1)) {
16513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16514 }
16515 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16516 {
16517 PyThreadState* __tstate = wxPyBeginAllowThreads();
16518 wxImage::AddHandler(arg1);
16519 wxPyEndAllowThreads(__tstate);
16520 if (PyErr_Occurred()) SWIG_fail;
16521 }
16522 resultobj = SWIG_Py_Void();
16523 return resultobj;
16524 fail:
16525 return NULL;
16526 }
16527
16528
16529 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16530 PyObject *resultobj = 0;
16531 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16532 void *argp1 = 0 ;
16533 int res1 = 0 ;
16534 PyObject * obj0 = 0 ;
16535 char * kwnames[] = {
16536 (char *) "handler", NULL
16537 };
16538
16539 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
16540 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16541 if (!SWIG_IsOK(res1)) {
16542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16543 }
16544 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16545 {
16546 PyThreadState* __tstate = wxPyBeginAllowThreads();
16547 wxImage::InsertHandler(arg1);
16548 wxPyEndAllowThreads(__tstate);
16549 if (PyErr_Occurred()) SWIG_fail;
16550 }
16551 resultobj = SWIG_Py_Void();
16552 return resultobj;
16553 fail:
16554 return NULL;
16555 }
16556
16557
16558 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16559 PyObject *resultobj = 0;
16560 wxString *arg1 = 0 ;
16561 bool result;
16562 bool temp1 = false ;
16563 PyObject * obj0 = 0 ;
16564 char * kwnames[] = {
16565 (char *) "name", NULL
16566 };
16567
16568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
16569 {
16570 arg1 = wxString_in_helper(obj0);
16571 if (arg1 == NULL) SWIG_fail;
16572 temp1 = true;
16573 }
16574 {
16575 PyThreadState* __tstate = wxPyBeginAllowThreads();
16576 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
16577 wxPyEndAllowThreads(__tstate);
16578 if (PyErr_Occurred()) SWIG_fail;
16579 }
16580 {
16581 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16582 }
16583 {
16584 if (temp1)
16585 delete arg1;
16586 }
16587 return resultobj;
16588 fail:
16589 {
16590 if (temp1)
16591 delete arg1;
16592 }
16593 return NULL;
16594 }
16595
16596
16597 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16598 PyObject *resultobj = 0;
16599 PyObject *result = 0 ;
16600
16601 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
16602 {
16603 PyThreadState* __tstate = wxPyBeginAllowThreads();
16604 result = (PyObject *)wxImage_GetHandlers();
16605 wxPyEndAllowThreads(__tstate);
16606 if (PyErr_Occurred()) SWIG_fail;
16607 }
16608 resultobj = result;
16609 return resultobj;
16610 fail:
16611 return NULL;
16612 }
16613
16614
16615 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16616 PyObject *resultobj = 0;
16617 wxString result;
16618
16619 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
16620 {
16621 PyThreadState* __tstate = wxPyBeginAllowThreads();
16622 result = wxImage::GetImageExtWildcard();
16623 wxPyEndAllowThreads(__tstate);
16624 if (PyErr_Occurred()) SWIG_fail;
16625 }
16626 {
16627 #if wxUSE_UNICODE
16628 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16629 #else
16630 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16631 #endif
16632 }
16633 return resultobj;
16634 fail:
16635 return NULL;
16636 }
16637
16638
16639 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16640 PyObject *resultobj = 0;
16641 wxImage *arg1 = (wxImage *) 0 ;
16642 int arg2 = (int) -1 ;
16643 wxBitmap result;
16644 void *argp1 = 0 ;
16645 int res1 = 0 ;
16646 int val2 ;
16647 int ecode2 = 0 ;
16648 PyObject * obj0 = 0 ;
16649 PyObject * obj1 = 0 ;
16650 char * kwnames[] = {
16651 (char *) "self",(char *) "depth", NULL
16652 };
16653
16654 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
16655 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16656 if (!SWIG_IsOK(res1)) {
16657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16658 }
16659 arg1 = reinterpret_cast< wxImage * >(argp1);
16660 if (obj1) {
16661 ecode2 = SWIG_AsVal_int(obj1, &val2);
16662 if (!SWIG_IsOK(ecode2)) {
16663 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
16664 }
16665 arg2 = static_cast< int >(val2);
16666 }
16667 {
16668 if (!wxPyCheckForApp()) SWIG_fail;
16669 PyThreadState* __tstate = wxPyBeginAllowThreads();
16670 result = wxImage_ConvertToBitmap(arg1,arg2);
16671 wxPyEndAllowThreads(__tstate);
16672 if (PyErr_Occurred()) SWIG_fail;
16673 }
16674 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16675 return resultobj;
16676 fail:
16677 return NULL;
16678 }
16679
16680
16681 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16682 PyObject *resultobj = 0;
16683 wxImage *arg1 = (wxImage *) 0 ;
16684 byte arg2 ;
16685 byte arg3 ;
16686 byte arg4 ;
16687 wxBitmap result;
16688 void *argp1 = 0 ;
16689 int res1 = 0 ;
16690 unsigned char val2 ;
16691 int ecode2 = 0 ;
16692 unsigned char val3 ;
16693 int ecode3 = 0 ;
16694 unsigned char val4 ;
16695 int ecode4 = 0 ;
16696 PyObject * obj0 = 0 ;
16697 PyObject * obj1 = 0 ;
16698 PyObject * obj2 = 0 ;
16699 PyObject * obj3 = 0 ;
16700 char * kwnames[] = {
16701 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
16702 };
16703
16704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16705 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16706 if (!SWIG_IsOK(res1)) {
16707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16708 }
16709 arg1 = reinterpret_cast< wxImage * >(argp1);
16710 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16711 if (!SWIG_IsOK(ecode2)) {
16712 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
16713 }
16714 arg2 = static_cast< byte >(val2);
16715 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16716 if (!SWIG_IsOK(ecode3)) {
16717 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
16718 }
16719 arg3 = static_cast< byte >(val3);
16720 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16721 if (!SWIG_IsOK(ecode4)) {
16722 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
16723 }
16724 arg4 = static_cast< byte >(val4);
16725 {
16726 if (!wxPyCheckForApp()) SWIG_fail;
16727 PyThreadState* __tstate = wxPyBeginAllowThreads();
16728 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
16729 wxPyEndAllowThreads(__tstate);
16730 if (PyErr_Occurred()) SWIG_fail;
16731 }
16732 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16733 return resultobj;
16734 fail:
16735 return NULL;
16736 }
16737
16738
16739 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16740 PyObject *resultobj = 0;
16741 wxImage *arg1 = (wxImage *) 0 ;
16742 double arg2 ;
16743 void *argp1 = 0 ;
16744 int res1 = 0 ;
16745 double val2 ;
16746 int ecode2 = 0 ;
16747 PyObject * obj0 = 0 ;
16748 PyObject * obj1 = 0 ;
16749 char * kwnames[] = {
16750 (char *) "self",(char *) "angle", NULL
16751 };
16752
16753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
16754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16755 if (!SWIG_IsOK(res1)) {
16756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
16757 }
16758 arg1 = reinterpret_cast< wxImage * >(argp1);
16759 ecode2 = SWIG_AsVal_double(obj1, &val2);
16760 if (!SWIG_IsOK(ecode2)) {
16761 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
16762 }
16763 arg2 = static_cast< double >(val2);
16764 {
16765 PyThreadState* __tstate = wxPyBeginAllowThreads();
16766 (arg1)->RotateHue(arg2);
16767 wxPyEndAllowThreads(__tstate);
16768 if (PyErr_Occurred()) SWIG_fail;
16769 }
16770 resultobj = SWIG_Py_Void();
16771 return resultobj;
16772 fail:
16773 return NULL;
16774 }
16775
16776
16777 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16778 PyObject *resultobj = 0;
16779 wxImage_RGBValue arg1 ;
16780 wxImage_HSVValue result;
16781 void *argp1 ;
16782 int res1 = 0 ;
16783 PyObject * obj0 = 0 ;
16784 char * kwnames[] = {
16785 (char *) "rgb", NULL
16786 };
16787
16788 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
16789 {
16790 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
16791 if (!SWIG_IsOK(res1)) {
16792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16793 }
16794 if (!argp1) {
16795 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16796 } else {
16797 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
16798 arg1 = *temp;
16799 if (SWIG_IsNewObj(res1)) delete temp;
16800 }
16801 }
16802 {
16803 PyThreadState* __tstate = wxPyBeginAllowThreads();
16804 result = wxImage::RGBtoHSV(arg1);
16805 wxPyEndAllowThreads(__tstate);
16806 if (PyErr_Occurred()) SWIG_fail;
16807 }
16808 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
16809 return resultobj;
16810 fail:
16811 return NULL;
16812 }
16813
16814
16815 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16816 PyObject *resultobj = 0;
16817 wxImage_HSVValue arg1 ;
16818 wxImage_RGBValue result;
16819 void *argp1 ;
16820 int res1 = 0 ;
16821 PyObject * obj0 = 0 ;
16822 char * kwnames[] = {
16823 (char *) "hsv", NULL
16824 };
16825
16826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
16827 {
16828 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
16829 if (!SWIG_IsOK(res1)) {
16830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
16831 }
16832 if (!argp1) {
16833 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
16834 } else {
16835 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
16836 arg1 = *temp;
16837 if (SWIG_IsNewObj(res1)) delete temp;
16838 }
16839 }
16840 {
16841 PyThreadState* __tstate = wxPyBeginAllowThreads();
16842 result = wxImage::HSVtoRGB(arg1);
16843 wxPyEndAllowThreads(__tstate);
16844 if (PyErr_Occurred()) SWIG_fail;
16845 }
16846 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
16847 return resultobj;
16848 fail:
16849 return NULL;
16850 }
16851
16852
16853 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16854 PyObject *obj;
16855 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16856 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
16857 return SWIG_Py_Void();
16858 }
16859
16860 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16861 return SWIG_Python_InitShadowInstance(args);
16862 }
16863
16864 SWIGINTERN int NullImage_set(PyObject *) {
16865 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
16866 return 1;
16867 }
16868
16869
16870 SWIGINTERN PyObject *NullImage_get(void) {
16871 PyObject *pyobj = 0;
16872
16873 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
16874 return pyobj;
16875 }
16876
16877
16878 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
16879 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
16880 return 1;
16881 }
16882
16883
16884 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
16885 PyObject *pyobj = 0;
16886
16887 {
16888 #if wxUSE_UNICODE
16889 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
16890 #else
16891 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
16892 #endif
16893 }
16894 return pyobj;
16895 }
16896
16897
16898 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
16899 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
16900 return 1;
16901 }
16902
16903
16904 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
16905 PyObject *pyobj = 0;
16906
16907 {
16908 #if wxUSE_UNICODE
16909 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
16910 #else
16911 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
16912 #endif
16913 }
16914 return pyobj;
16915 }
16916
16917
16918 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
16919 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
16920 return 1;
16921 }
16922
16923
16924 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
16925 PyObject *pyobj = 0;
16926
16927 {
16928 #if wxUSE_UNICODE
16929 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
16930 #else
16931 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
16932 #endif
16933 }
16934 return pyobj;
16935 }
16936
16937
16938 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
16939 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
16940 return 1;
16941 }
16942
16943
16944 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
16945 PyObject *pyobj = 0;
16946
16947 {
16948 #if wxUSE_UNICODE
16949 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
16950 #else
16951 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
16952 #endif
16953 }
16954 return pyobj;
16955 }
16956
16957
16958 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
16959 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
16960 return 1;
16961 }
16962
16963
16964 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
16965 PyObject *pyobj = 0;
16966
16967 {
16968 #if wxUSE_UNICODE
16969 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
16970 #else
16971 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
16972 #endif
16973 }
16974 return pyobj;
16975 }
16976
16977
16978 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
16979 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
16980 return 1;
16981 }
16982
16983
16984 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
16985 PyObject *pyobj = 0;
16986
16987 {
16988 #if wxUSE_UNICODE
16989 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
16990 #else
16991 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
16992 #endif
16993 }
16994 return pyobj;
16995 }
16996
16997
16998 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
16999 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
17000 return 1;
17001 }
17002
17003
17004 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
17005 PyObject *pyobj = 0;
17006
17007 {
17008 #if wxUSE_UNICODE
17009 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17010 #else
17011 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17012 #endif
17013 }
17014 return pyobj;
17015 }
17016
17017
17018 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
17019 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
17020 return 1;
17021 }
17022
17023
17024 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
17025 PyObject *pyobj = 0;
17026
17027 {
17028 #if wxUSE_UNICODE
17029 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17030 #else
17031 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17032 #endif
17033 }
17034 return pyobj;
17035 }
17036
17037
17038 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
17039 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
17040 return 1;
17041 }
17042
17043
17044 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
17045 PyObject *pyobj = 0;
17046
17047 {
17048 #if wxUSE_UNICODE
17049 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17050 #else
17051 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17052 #endif
17053 }
17054 return pyobj;
17055 }
17056
17057
17058 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
17059 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
17060 return 1;
17061 }
17062
17063
17064 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
17065 PyObject *pyobj = 0;
17066
17067 {
17068 #if wxUSE_UNICODE
17069 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17070 #else
17071 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17072 #endif
17073 }
17074 return pyobj;
17075 }
17076
17077
17078 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
17079 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
17080 return 1;
17081 }
17082
17083
17084 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
17085 PyObject *pyobj = 0;
17086
17087 {
17088 #if wxUSE_UNICODE
17089 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17090 #else
17091 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17092 #endif
17093 }
17094 return pyobj;
17095 }
17096
17097
17098 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
17099 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
17100 return 1;
17101 }
17102
17103
17104 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
17105 PyObject *pyobj = 0;
17106
17107 {
17108 #if wxUSE_UNICODE
17109 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17110 #else
17111 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17112 #endif
17113 }
17114 return pyobj;
17115 }
17116
17117
17118 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
17119 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
17120 return 1;
17121 }
17122
17123
17124 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
17125 PyObject *pyobj = 0;
17126
17127 {
17128 #if wxUSE_UNICODE
17129 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17130 #else
17131 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17132 #endif
17133 }
17134 return pyobj;
17135 }
17136
17137
17138 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
17139 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
17140 return 1;
17141 }
17142
17143
17144 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
17145 PyObject *pyobj = 0;
17146
17147 {
17148 #if wxUSE_UNICODE
17149 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17150 #else
17151 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17152 #endif
17153 }
17154 return pyobj;
17155 }
17156
17157
17158 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
17159 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
17160 return 1;
17161 }
17162
17163
17164 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
17165 PyObject *pyobj = 0;
17166
17167 {
17168 #if wxUSE_UNICODE
17169 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17170 #else
17171 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17172 #endif
17173 }
17174 return pyobj;
17175 }
17176
17177
17178 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17179 PyObject *resultobj = 0;
17180 wxBMPHandler *result = 0 ;
17181
17182 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
17183 {
17184 PyThreadState* __tstate = wxPyBeginAllowThreads();
17185 result = (wxBMPHandler *)new wxBMPHandler();
17186 wxPyEndAllowThreads(__tstate);
17187 if (PyErr_Occurred()) SWIG_fail;
17188 }
17189 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
17190 return resultobj;
17191 fail:
17192 return NULL;
17193 }
17194
17195
17196 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17197 PyObject *obj;
17198 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17199 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
17200 return SWIG_Py_Void();
17201 }
17202
17203 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17204 return SWIG_Python_InitShadowInstance(args);
17205 }
17206
17207 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17208 PyObject *resultobj = 0;
17209 wxICOHandler *result = 0 ;
17210
17211 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
17212 {
17213 PyThreadState* __tstate = wxPyBeginAllowThreads();
17214 result = (wxICOHandler *)new wxICOHandler();
17215 wxPyEndAllowThreads(__tstate);
17216 if (PyErr_Occurred()) SWIG_fail;
17217 }
17218 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
17219 return resultobj;
17220 fail:
17221 return NULL;
17222 }
17223
17224
17225 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17226 PyObject *obj;
17227 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17228 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
17229 return SWIG_Py_Void();
17230 }
17231
17232 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17233 return SWIG_Python_InitShadowInstance(args);
17234 }
17235
17236 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17237 PyObject *resultobj = 0;
17238 wxCURHandler *result = 0 ;
17239
17240 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
17241 {
17242 PyThreadState* __tstate = wxPyBeginAllowThreads();
17243 result = (wxCURHandler *)new wxCURHandler();
17244 wxPyEndAllowThreads(__tstate);
17245 if (PyErr_Occurred()) SWIG_fail;
17246 }
17247 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
17248 return resultobj;
17249 fail:
17250 return NULL;
17251 }
17252
17253
17254 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17255 PyObject *obj;
17256 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17257 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
17258 return SWIG_Py_Void();
17259 }
17260
17261 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17262 return SWIG_Python_InitShadowInstance(args);
17263 }
17264
17265 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17266 PyObject *resultobj = 0;
17267 wxANIHandler *result = 0 ;
17268
17269 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
17270 {
17271 PyThreadState* __tstate = wxPyBeginAllowThreads();
17272 result = (wxANIHandler *)new wxANIHandler();
17273 wxPyEndAllowThreads(__tstate);
17274 if (PyErr_Occurred()) SWIG_fail;
17275 }
17276 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
17277 return resultobj;
17278 fail:
17279 return NULL;
17280 }
17281
17282
17283 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17284 PyObject *obj;
17285 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17286 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
17287 return SWIG_Py_Void();
17288 }
17289
17290 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17291 return SWIG_Python_InitShadowInstance(args);
17292 }
17293
17294 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17295 PyObject *resultobj = 0;
17296 wxPNGHandler *result = 0 ;
17297
17298 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
17299 {
17300 PyThreadState* __tstate = wxPyBeginAllowThreads();
17301 result = (wxPNGHandler *)new wxPNGHandler();
17302 wxPyEndAllowThreads(__tstate);
17303 if (PyErr_Occurred()) SWIG_fail;
17304 }
17305 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
17306 return resultobj;
17307 fail:
17308 return NULL;
17309 }
17310
17311
17312 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17313 PyObject *obj;
17314 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17315 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
17316 return SWIG_Py_Void();
17317 }
17318
17319 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17320 return SWIG_Python_InitShadowInstance(args);
17321 }
17322
17323 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17324 PyObject *resultobj = 0;
17325 wxGIFHandler *result = 0 ;
17326
17327 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
17328 {
17329 PyThreadState* __tstate = wxPyBeginAllowThreads();
17330 result = (wxGIFHandler *)new wxGIFHandler();
17331 wxPyEndAllowThreads(__tstate);
17332 if (PyErr_Occurred()) SWIG_fail;
17333 }
17334 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
17335 return resultobj;
17336 fail:
17337 return NULL;
17338 }
17339
17340
17341 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17342 PyObject *obj;
17343 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17344 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
17345 return SWIG_Py_Void();
17346 }
17347
17348 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17349 return SWIG_Python_InitShadowInstance(args);
17350 }
17351
17352 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17353 PyObject *resultobj = 0;
17354 wxPCXHandler *result = 0 ;
17355
17356 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
17357 {
17358 PyThreadState* __tstate = wxPyBeginAllowThreads();
17359 result = (wxPCXHandler *)new wxPCXHandler();
17360 wxPyEndAllowThreads(__tstate);
17361 if (PyErr_Occurred()) SWIG_fail;
17362 }
17363 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
17364 return resultobj;
17365 fail:
17366 return NULL;
17367 }
17368
17369
17370 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17371 PyObject *obj;
17372 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17373 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
17374 return SWIG_Py_Void();
17375 }
17376
17377 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17378 return SWIG_Python_InitShadowInstance(args);
17379 }
17380
17381 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17382 PyObject *resultobj = 0;
17383 wxJPEGHandler *result = 0 ;
17384
17385 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
17386 {
17387 PyThreadState* __tstate = wxPyBeginAllowThreads();
17388 result = (wxJPEGHandler *)new wxJPEGHandler();
17389 wxPyEndAllowThreads(__tstate);
17390 if (PyErr_Occurred()) SWIG_fail;
17391 }
17392 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
17393 return resultobj;
17394 fail:
17395 return NULL;
17396 }
17397
17398
17399 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17400 PyObject *obj;
17401 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17402 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
17403 return SWIG_Py_Void();
17404 }
17405
17406 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17407 return SWIG_Python_InitShadowInstance(args);
17408 }
17409
17410 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17411 PyObject *resultobj = 0;
17412 wxPNMHandler *result = 0 ;
17413
17414 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
17415 {
17416 PyThreadState* __tstate = wxPyBeginAllowThreads();
17417 result = (wxPNMHandler *)new wxPNMHandler();
17418 wxPyEndAllowThreads(__tstate);
17419 if (PyErr_Occurred()) SWIG_fail;
17420 }
17421 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
17422 return resultobj;
17423 fail:
17424 return NULL;
17425 }
17426
17427
17428 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17429 PyObject *obj;
17430 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17431 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
17432 return SWIG_Py_Void();
17433 }
17434
17435 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17436 return SWIG_Python_InitShadowInstance(args);
17437 }
17438
17439 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17440 PyObject *resultobj = 0;
17441 wxXPMHandler *result = 0 ;
17442
17443 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
17444 {
17445 PyThreadState* __tstate = wxPyBeginAllowThreads();
17446 result = (wxXPMHandler *)new wxXPMHandler();
17447 wxPyEndAllowThreads(__tstate);
17448 if (PyErr_Occurred()) SWIG_fail;
17449 }
17450 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
17451 return resultobj;
17452 fail:
17453 return NULL;
17454 }
17455
17456
17457 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17458 PyObject *obj;
17459 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17460 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
17461 return SWIG_Py_Void();
17462 }
17463
17464 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17465 return SWIG_Python_InitShadowInstance(args);
17466 }
17467
17468 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17469 PyObject *resultobj = 0;
17470 wxTIFFHandler *result = 0 ;
17471
17472 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
17473 {
17474 PyThreadState* __tstate = wxPyBeginAllowThreads();
17475 result = (wxTIFFHandler *)new wxTIFFHandler();
17476 wxPyEndAllowThreads(__tstate);
17477 if (PyErr_Occurred()) SWIG_fail;
17478 }
17479 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
17480 return resultobj;
17481 fail:
17482 return NULL;
17483 }
17484
17485
17486 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17487 PyObject *obj;
17488 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17489 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
17490 return SWIG_Py_Void();
17491 }
17492
17493 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17494 return SWIG_Python_InitShadowInstance(args);
17495 }
17496
17497 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17498 PyObject *resultobj = 0;
17499 wxImage *arg1 = 0 ;
17500 wxImage *arg2 = 0 ;
17501 int arg3 = (int) 236 ;
17502 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
17503 bool result;
17504 void *argp1 = 0 ;
17505 int res1 = 0 ;
17506 void *argp2 = 0 ;
17507 int res2 = 0 ;
17508 int val3 ;
17509 int ecode3 = 0 ;
17510 int val4 ;
17511 int ecode4 = 0 ;
17512 PyObject * obj0 = 0 ;
17513 PyObject * obj1 = 0 ;
17514 PyObject * obj2 = 0 ;
17515 PyObject * obj3 = 0 ;
17516 char * kwnames[] = {
17517 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
17518 };
17519
17520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17521 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
17522 if (!SWIG_IsOK(res1)) {
17523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17524 }
17525 if (!argp1) {
17526 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17527 }
17528 arg1 = reinterpret_cast< wxImage * >(argp1);
17529 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
17530 if (!SWIG_IsOK(res2)) {
17531 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17532 }
17533 if (!argp2) {
17534 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17535 }
17536 arg2 = reinterpret_cast< wxImage * >(argp2);
17537 if (obj2) {
17538 ecode3 = SWIG_AsVal_int(obj2, &val3);
17539 if (!SWIG_IsOK(ecode3)) {
17540 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
17541 }
17542 arg3 = static_cast< int >(val3);
17543 }
17544 if (obj3) {
17545 ecode4 = SWIG_AsVal_int(obj3, &val4);
17546 if (!SWIG_IsOK(ecode4)) {
17547 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
17548 }
17549 arg4 = static_cast< int >(val4);
17550 }
17551 {
17552 PyThreadState* __tstate = wxPyBeginAllowThreads();
17553 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
17554 wxPyEndAllowThreads(__tstate);
17555 if (PyErr_Occurred()) SWIG_fail;
17556 }
17557 {
17558 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17559 }
17560 return resultobj;
17561 fail:
17562 return NULL;
17563 }
17564
17565
17566 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17567 PyObject *obj;
17568 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17569 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
17570 return SWIG_Py_Void();
17571 }
17572
17573 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17574 PyObject *resultobj = 0;
17575 wxEvtHandler *result = 0 ;
17576
17577 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
17578 {
17579 PyThreadState* __tstate = wxPyBeginAllowThreads();
17580 result = (wxEvtHandler *)new wxEvtHandler();
17581 wxPyEndAllowThreads(__tstate);
17582 if (PyErr_Occurred()) SWIG_fail;
17583 }
17584 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
17585 return resultobj;
17586 fail:
17587 return NULL;
17588 }
17589
17590
17591 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17592 PyObject *resultobj = 0;
17593 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17594 wxEvtHandler *result = 0 ;
17595 void *argp1 = 0 ;
17596 int res1 = 0 ;
17597 PyObject *swig_obj[1] ;
17598
17599 if (!args) SWIG_fail;
17600 swig_obj[0] = args;
17601 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17602 if (!SWIG_IsOK(res1)) {
17603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17604 }
17605 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17606 {
17607 PyThreadState* __tstate = wxPyBeginAllowThreads();
17608 result = (wxEvtHandler *)(arg1)->GetNextHandler();
17609 wxPyEndAllowThreads(__tstate);
17610 if (PyErr_Occurred()) SWIG_fail;
17611 }
17612 {
17613 resultobj = wxPyMake_wxObject(result, 0);
17614 }
17615 return resultobj;
17616 fail:
17617 return NULL;
17618 }
17619
17620
17621 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17622 PyObject *resultobj = 0;
17623 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17624 wxEvtHandler *result = 0 ;
17625 void *argp1 = 0 ;
17626 int res1 = 0 ;
17627 PyObject *swig_obj[1] ;
17628
17629 if (!args) SWIG_fail;
17630 swig_obj[0] = args;
17631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17632 if (!SWIG_IsOK(res1)) {
17633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17634 }
17635 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17636 {
17637 PyThreadState* __tstate = wxPyBeginAllowThreads();
17638 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
17639 wxPyEndAllowThreads(__tstate);
17640 if (PyErr_Occurred()) SWIG_fail;
17641 }
17642 {
17643 resultobj = wxPyMake_wxObject(result, 0);
17644 }
17645 return resultobj;
17646 fail:
17647 return NULL;
17648 }
17649
17650
17651 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17652 PyObject *resultobj = 0;
17653 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17654 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17655 void *argp1 = 0 ;
17656 int res1 = 0 ;
17657 void *argp2 = 0 ;
17658 int res2 = 0 ;
17659 PyObject * obj0 = 0 ;
17660 PyObject * obj1 = 0 ;
17661 char * kwnames[] = {
17662 (char *) "self",(char *) "handler", NULL
17663 };
17664
17665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17666 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17667 if (!SWIG_IsOK(res1)) {
17668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17669 }
17670 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17671 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17672 if (!SWIG_IsOK(res2)) {
17673 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17674 }
17675 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17676 {
17677 PyThreadState* __tstate = wxPyBeginAllowThreads();
17678 (arg1)->SetNextHandler(arg2);
17679 wxPyEndAllowThreads(__tstate);
17680 if (PyErr_Occurred()) SWIG_fail;
17681 }
17682 resultobj = SWIG_Py_Void();
17683 return resultobj;
17684 fail:
17685 return NULL;
17686 }
17687
17688
17689 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17690 PyObject *resultobj = 0;
17691 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17692 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17693 void *argp1 = 0 ;
17694 int res1 = 0 ;
17695 void *argp2 = 0 ;
17696 int res2 = 0 ;
17697 PyObject * obj0 = 0 ;
17698 PyObject * obj1 = 0 ;
17699 char * kwnames[] = {
17700 (char *) "self",(char *) "handler", NULL
17701 };
17702
17703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17705 if (!SWIG_IsOK(res1)) {
17706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17707 }
17708 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17709 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17710 if (!SWIG_IsOK(res2)) {
17711 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17712 }
17713 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17714 {
17715 PyThreadState* __tstate = wxPyBeginAllowThreads();
17716 (arg1)->SetPreviousHandler(arg2);
17717 wxPyEndAllowThreads(__tstate);
17718 if (PyErr_Occurred()) SWIG_fail;
17719 }
17720 resultobj = SWIG_Py_Void();
17721 return resultobj;
17722 fail:
17723 return NULL;
17724 }
17725
17726
17727 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17728 PyObject *resultobj = 0;
17729 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17730 bool result;
17731 void *argp1 = 0 ;
17732 int res1 = 0 ;
17733 PyObject *swig_obj[1] ;
17734
17735 if (!args) SWIG_fail;
17736 swig_obj[0] = args;
17737 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17738 if (!SWIG_IsOK(res1)) {
17739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17740 }
17741 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17742 {
17743 PyThreadState* __tstate = wxPyBeginAllowThreads();
17744 result = (bool)(arg1)->GetEvtHandlerEnabled();
17745 wxPyEndAllowThreads(__tstate);
17746 if (PyErr_Occurred()) SWIG_fail;
17747 }
17748 {
17749 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17750 }
17751 return resultobj;
17752 fail:
17753 return NULL;
17754 }
17755
17756
17757 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17758 PyObject *resultobj = 0;
17759 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17760 bool arg2 ;
17761 void *argp1 = 0 ;
17762 int res1 = 0 ;
17763 bool val2 ;
17764 int ecode2 = 0 ;
17765 PyObject * obj0 = 0 ;
17766 PyObject * obj1 = 0 ;
17767 char * kwnames[] = {
17768 (char *) "self",(char *) "enabled", NULL
17769 };
17770
17771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
17772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17773 if (!SWIG_IsOK(res1)) {
17774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17775 }
17776 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17777 ecode2 = SWIG_AsVal_bool(obj1, &val2);
17778 if (!SWIG_IsOK(ecode2)) {
17779 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
17780 }
17781 arg2 = static_cast< bool >(val2);
17782 {
17783 PyThreadState* __tstate = wxPyBeginAllowThreads();
17784 (arg1)->SetEvtHandlerEnabled(arg2);
17785 wxPyEndAllowThreads(__tstate);
17786 if (PyErr_Occurred()) SWIG_fail;
17787 }
17788 resultobj = SWIG_Py_Void();
17789 return resultobj;
17790 fail:
17791 return NULL;
17792 }
17793
17794
17795 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17796 PyObject *resultobj = 0;
17797 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17798 wxEvent *arg2 = 0 ;
17799 bool result;
17800 void *argp1 = 0 ;
17801 int res1 = 0 ;
17802 void *argp2 = 0 ;
17803 int res2 = 0 ;
17804 PyObject * obj0 = 0 ;
17805 PyObject * obj1 = 0 ;
17806 char * kwnames[] = {
17807 (char *) "self",(char *) "event", NULL
17808 };
17809
17810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
17811 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17812 if (!SWIG_IsOK(res1)) {
17813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17814 }
17815 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17816 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
17817 if (!SWIG_IsOK(res2)) {
17818 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17819 }
17820 if (!argp2) {
17821 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17822 }
17823 arg2 = reinterpret_cast< wxEvent * >(argp2);
17824 {
17825 PyThreadState* __tstate = wxPyBeginAllowThreads();
17826 result = (bool)(arg1)->ProcessEvent(*arg2);
17827 wxPyEndAllowThreads(__tstate);
17828 if (PyErr_Occurred()) SWIG_fail;
17829 }
17830 {
17831 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17832 }
17833 return resultobj;
17834 fail:
17835 return NULL;
17836 }
17837
17838
17839 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17840 PyObject *resultobj = 0;
17841 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17842 wxEvent *arg2 = 0 ;
17843 void *argp1 = 0 ;
17844 int res1 = 0 ;
17845 void *argp2 = 0 ;
17846 int res2 = 0 ;
17847 PyObject * obj0 = 0 ;
17848 PyObject * obj1 = 0 ;
17849 char * kwnames[] = {
17850 (char *) "self",(char *) "event", NULL
17851 };
17852
17853 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
17854 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17855 if (!SWIG_IsOK(res1)) {
17856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17857 }
17858 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17859 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
17860 if (!SWIG_IsOK(res2)) {
17861 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17862 }
17863 if (!argp2) {
17864 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17865 }
17866 arg2 = reinterpret_cast< wxEvent * >(argp2);
17867 {
17868 PyThreadState* __tstate = wxPyBeginAllowThreads();
17869 (arg1)->AddPendingEvent(*arg2);
17870 wxPyEndAllowThreads(__tstate);
17871 if (PyErr_Occurred()) SWIG_fail;
17872 }
17873 resultobj = SWIG_Py_Void();
17874 return resultobj;
17875 fail:
17876 return NULL;
17877 }
17878
17879
17880 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17881 PyObject *resultobj = 0;
17882 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17883 void *argp1 = 0 ;
17884 int res1 = 0 ;
17885 PyObject *swig_obj[1] ;
17886
17887 if (!args) SWIG_fail;
17888 swig_obj[0] = args;
17889 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17890 if (!SWIG_IsOK(res1)) {
17891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17892 }
17893 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17894 {
17895 PyThreadState* __tstate = wxPyBeginAllowThreads();
17896 (arg1)->ProcessPendingEvents();
17897 wxPyEndAllowThreads(__tstate);
17898 if (PyErr_Occurred()) SWIG_fail;
17899 }
17900 resultobj = SWIG_Py_Void();
17901 return resultobj;
17902 fail:
17903 return NULL;
17904 }
17905
17906
17907 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17908 PyObject *resultobj = 0;
17909 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17910 int arg2 ;
17911 int arg3 ;
17912 int arg4 ;
17913 PyObject *arg5 = (PyObject *) 0 ;
17914 void *argp1 = 0 ;
17915 int res1 = 0 ;
17916 int val2 ;
17917 int ecode2 = 0 ;
17918 int val3 ;
17919 int ecode3 = 0 ;
17920 int val4 ;
17921 int ecode4 = 0 ;
17922 PyObject * obj0 = 0 ;
17923 PyObject * obj1 = 0 ;
17924 PyObject * obj2 = 0 ;
17925 PyObject * obj3 = 0 ;
17926 PyObject * obj4 = 0 ;
17927 char * kwnames[] = {
17928 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
17929 };
17930
17931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17933 if (!SWIG_IsOK(res1)) {
17934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17935 }
17936 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17937 ecode2 = SWIG_AsVal_int(obj1, &val2);
17938 if (!SWIG_IsOK(ecode2)) {
17939 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
17940 }
17941 arg2 = static_cast< int >(val2);
17942 ecode3 = SWIG_AsVal_int(obj2, &val3);
17943 if (!SWIG_IsOK(ecode3)) {
17944 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
17945 }
17946 arg3 = static_cast< int >(val3);
17947 ecode4 = SWIG_AsVal_int(obj3, &val4);
17948 if (!SWIG_IsOK(ecode4)) {
17949 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
17950 }
17951 arg4 = static_cast< int >(val4);
17952 arg5 = obj4;
17953 {
17954 PyThreadState* __tstate = wxPyBeginAllowThreads();
17955 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
17956 wxPyEndAllowThreads(__tstate);
17957 if (PyErr_Occurred()) SWIG_fail;
17958 }
17959 resultobj = SWIG_Py_Void();
17960 return resultobj;
17961 fail:
17962 return NULL;
17963 }
17964
17965
17966 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17967 PyObject *resultobj = 0;
17968 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17969 int arg2 ;
17970 int arg3 = (int) -1 ;
17971 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
17972 bool result;
17973 void *argp1 = 0 ;
17974 int res1 = 0 ;
17975 int val2 ;
17976 int ecode2 = 0 ;
17977 int val3 ;
17978 int ecode3 = 0 ;
17979 int val4 ;
17980 int ecode4 = 0 ;
17981 PyObject * obj0 = 0 ;
17982 PyObject * obj1 = 0 ;
17983 PyObject * obj2 = 0 ;
17984 PyObject * obj3 = 0 ;
17985 char * kwnames[] = {
17986 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
17987 };
17988
17989 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17990 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17991 if (!SWIG_IsOK(res1)) {
17992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17993 }
17994 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17995 ecode2 = SWIG_AsVal_int(obj1, &val2);
17996 if (!SWIG_IsOK(ecode2)) {
17997 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
17998 }
17999 arg2 = static_cast< int >(val2);
18000 if (obj2) {
18001 ecode3 = SWIG_AsVal_int(obj2, &val3);
18002 if (!SWIG_IsOK(ecode3)) {
18003 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
18004 }
18005 arg3 = static_cast< int >(val3);
18006 }
18007 if (obj3) {
18008 ecode4 = SWIG_AsVal_int(obj3, &val4);
18009 if (!SWIG_IsOK(ecode4)) {
18010 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
18011 }
18012 arg4 = static_cast< wxEventType >(val4);
18013 }
18014 {
18015 PyThreadState* __tstate = wxPyBeginAllowThreads();
18016 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
18017 wxPyEndAllowThreads(__tstate);
18018 if (PyErr_Occurred()) SWIG_fail;
18019 }
18020 {
18021 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18022 }
18023 return resultobj;
18024 fail:
18025 return NULL;
18026 }
18027
18028
18029 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18030 PyObject *resultobj = 0;
18031 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18032 PyObject *arg2 = (PyObject *) 0 ;
18033 bool arg3 = (bool) true ;
18034 void *argp1 = 0 ;
18035 int res1 = 0 ;
18036 bool val3 ;
18037 int ecode3 = 0 ;
18038 PyObject * obj0 = 0 ;
18039 PyObject * obj1 = 0 ;
18040 PyObject * obj2 = 0 ;
18041 char * kwnames[] = {
18042 (char *) "self",(char *) "_self",(char *) "incref", NULL
18043 };
18044
18045 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18046 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18047 if (!SWIG_IsOK(res1)) {
18048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18049 }
18050 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18051 arg2 = obj1;
18052 if (obj2) {
18053 ecode3 = SWIG_AsVal_bool(obj2, &val3);
18054 if (!SWIG_IsOK(ecode3)) {
18055 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
18056 }
18057 arg3 = static_cast< bool >(val3);
18058 }
18059 {
18060 PyThreadState* __tstate = wxPyBeginAllowThreads();
18061 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
18062 wxPyEndAllowThreads(__tstate);
18063 if (PyErr_Occurred()) SWIG_fail;
18064 }
18065 resultobj = SWIG_Py_Void();
18066 return resultobj;
18067 fail:
18068 return NULL;
18069 }
18070
18071
18072 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18073 PyObject *obj;
18074 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18075 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
18076 return SWIG_Py_Void();
18077 }
18078
18079 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18080 return SWIG_Python_InitShadowInstance(args);
18081 }
18082
18083 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18084 PyObject *resultobj = 0;
18085 wxEventType result;
18086
18087 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
18088 {
18089 PyThreadState* __tstate = wxPyBeginAllowThreads();
18090 result = (wxEventType)wxNewEventType();
18091 wxPyEndAllowThreads(__tstate);
18092 if (PyErr_Occurred()) SWIG_fail;
18093 }
18094 resultobj = SWIG_From_int(static_cast< int >(result));
18095 return resultobj;
18096 fail:
18097 return NULL;
18098 }
18099
18100
18101 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18102 PyObject *resultobj = 0;
18103 wxEvent *arg1 = (wxEvent *) 0 ;
18104 void *argp1 = 0 ;
18105 int res1 = 0 ;
18106 PyObject *swig_obj[1] ;
18107
18108 if (!args) SWIG_fail;
18109 swig_obj[0] = args;
18110 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
18111 if (!SWIG_IsOK(res1)) {
18112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
18113 }
18114 arg1 = reinterpret_cast< wxEvent * >(argp1);
18115 {
18116 PyThreadState* __tstate = wxPyBeginAllowThreads();
18117 delete arg1;
18118
18119 wxPyEndAllowThreads(__tstate);
18120 if (PyErr_Occurred()) SWIG_fail;
18121 }
18122 resultobj = SWIG_Py_Void();
18123 return resultobj;
18124 fail:
18125 return NULL;
18126 }
18127
18128
18129 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18130 PyObject *resultobj = 0;
18131 wxEvent *arg1 = (wxEvent *) 0 ;
18132 wxEventType arg2 ;
18133 void *argp1 = 0 ;
18134 int res1 = 0 ;
18135 int val2 ;
18136 int ecode2 = 0 ;
18137 PyObject * obj0 = 0 ;
18138 PyObject * obj1 = 0 ;
18139 char * kwnames[] = {
18140 (char *) "self",(char *) "typ", NULL
18141 };
18142
18143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
18144 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18145 if (!SWIG_IsOK(res1)) {
18146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
18147 }
18148 arg1 = reinterpret_cast< wxEvent * >(argp1);
18149 ecode2 = SWIG_AsVal_int(obj1, &val2);
18150 if (!SWIG_IsOK(ecode2)) {
18151 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
18152 }
18153 arg2 = static_cast< wxEventType >(val2);
18154 {
18155 PyThreadState* __tstate = wxPyBeginAllowThreads();
18156 (arg1)->SetEventType(arg2);
18157 wxPyEndAllowThreads(__tstate);
18158 if (PyErr_Occurred()) SWIG_fail;
18159 }
18160 resultobj = SWIG_Py_Void();
18161 return resultobj;
18162 fail:
18163 return NULL;
18164 }
18165
18166
18167 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18168 PyObject *resultobj = 0;
18169 wxEvent *arg1 = (wxEvent *) 0 ;
18170 wxEventType result;
18171 void *argp1 = 0 ;
18172 int res1 = 0 ;
18173 PyObject *swig_obj[1] ;
18174
18175 if (!args) SWIG_fail;
18176 swig_obj[0] = args;
18177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18178 if (!SWIG_IsOK(res1)) {
18179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
18180 }
18181 arg1 = reinterpret_cast< wxEvent * >(argp1);
18182 {
18183 PyThreadState* __tstate = wxPyBeginAllowThreads();
18184 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
18185 wxPyEndAllowThreads(__tstate);
18186 if (PyErr_Occurred()) SWIG_fail;
18187 }
18188 resultobj = SWIG_From_int(static_cast< int >(result));
18189 return resultobj;
18190 fail:
18191 return NULL;
18192 }
18193
18194
18195 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18196 PyObject *resultobj = 0;
18197 wxEvent *arg1 = (wxEvent *) 0 ;
18198 wxObject *result = 0 ;
18199 void *argp1 = 0 ;
18200 int res1 = 0 ;
18201 PyObject *swig_obj[1] ;
18202
18203 if (!args) SWIG_fail;
18204 swig_obj[0] = args;
18205 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18206 if (!SWIG_IsOK(res1)) {
18207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
18208 }
18209 arg1 = reinterpret_cast< wxEvent * >(argp1);
18210 {
18211 PyThreadState* __tstate = wxPyBeginAllowThreads();
18212 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
18213 wxPyEndAllowThreads(__tstate);
18214 if (PyErr_Occurred()) SWIG_fail;
18215 }
18216 {
18217 resultobj = wxPyMake_wxObject(result, (bool)0);
18218 }
18219 return resultobj;
18220 fail:
18221 return NULL;
18222 }
18223
18224
18225 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18226 PyObject *resultobj = 0;
18227 wxEvent *arg1 = (wxEvent *) 0 ;
18228 wxObject *arg2 = (wxObject *) 0 ;
18229 void *argp1 = 0 ;
18230 int res1 = 0 ;
18231 void *argp2 = 0 ;
18232 int res2 = 0 ;
18233 PyObject * obj0 = 0 ;
18234 PyObject * obj1 = 0 ;
18235 char * kwnames[] = {
18236 (char *) "self",(char *) "obj", NULL
18237 };
18238
18239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
18240 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18241 if (!SWIG_IsOK(res1)) {
18242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
18243 }
18244 arg1 = reinterpret_cast< wxEvent * >(argp1);
18245 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
18246 if (!SWIG_IsOK(res2)) {
18247 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
18248 }
18249 arg2 = reinterpret_cast< wxObject * >(argp2);
18250 {
18251 PyThreadState* __tstate = wxPyBeginAllowThreads();
18252 (arg1)->SetEventObject(arg2);
18253 wxPyEndAllowThreads(__tstate);
18254 if (PyErr_Occurred()) SWIG_fail;
18255 }
18256 resultobj = SWIG_Py_Void();
18257 return resultobj;
18258 fail:
18259 return NULL;
18260 }
18261
18262
18263 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18264 PyObject *resultobj = 0;
18265 wxEvent *arg1 = (wxEvent *) 0 ;
18266 long result;
18267 void *argp1 = 0 ;
18268 int res1 = 0 ;
18269 PyObject *swig_obj[1] ;
18270
18271 if (!args) SWIG_fail;
18272 swig_obj[0] = args;
18273 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18274 if (!SWIG_IsOK(res1)) {
18275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
18276 }
18277 arg1 = reinterpret_cast< wxEvent * >(argp1);
18278 {
18279 PyThreadState* __tstate = wxPyBeginAllowThreads();
18280 result = (long)((wxEvent const *)arg1)->GetTimestamp();
18281 wxPyEndAllowThreads(__tstate);
18282 if (PyErr_Occurred()) SWIG_fail;
18283 }
18284 resultobj = SWIG_From_long(static_cast< long >(result));
18285 return resultobj;
18286 fail:
18287 return NULL;
18288 }
18289
18290
18291 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18292 PyObject *resultobj = 0;
18293 wxEvent *arg1 = (wxEvent *) 0 ;
18294 long arg2 = (long) 0 ;
18295 void *argp1 = 0 ;
18296 int res1 = 0 ;
18297 long val2 ;
18298 int ecode2 = 0 ;
18299 PyObject * obj0 = 0 ;
18300 PyObject * obj1 = 0 ;
18301 char * kwnames[] = {
18302 (char *) "self",(char *) "ts", NULL
18303 };
18304
18305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
18306 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18307 if (!SWIG_IsOK(res1)) {
18308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
18309 }
18310 arg1 = reinterpret_cast< wxEvent * >(argp1);
18311 if (obj1) {
18312 ecode2 = SWIG_AsVal_long(obj1, &val2);
18313 if (!SWIG_IsOK(ecode2)) {
18314 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
18315 }
18316 arg2 = static_cast< long >(val2);
18317 }
18318 {
18319 PyThreadState* __tstate = wxPyBeginAllowThreads();
18320 (arg1)->SetTimestamp(arg2);
18321 wxPyEndAllowThreads(__tstate);
18322 if (PyErr_Occurred()) SWIG_fail;
18323 }
18324 resultobj = SWIG_Py_Void();
18325 return resultobj;
18326 fail:
18327 return NULL;
18328 }
18329
18330
18331 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18332 PyObject *resultobj = 0;
18333 wxEvent *arg1 = (wxEvent *) 0 ;
18334 int result;
18335 void *argp1 = 0 ;
18336 int res1 = 0 ;
18337 PyObject *swig_obj[1] ;
18338
18339 if (!args) SWIG_fail;
18340 swig_obj[0] = args;
18341 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18342 if (!SWIG_IsOK(res1)) {
18343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
18344 }
18345 arg1 = reinterpret_cast< wxEvent * >(argp1);
18346 {
18347 PyThreadState* __tstate = wxPyBeginAllowThreads();
18348 result = (int)((wxEvent const *)arg1)->GetId();
18349 wxPyEndAllowThreads(__tstate);
18350 if (PyErr_Occurred()) SWIG_fail;
18351 }
18352 resultobj = SWIG_From_int(static_cast< int >(result));
18353 return resultobj;
18354 fail:
18355 return NULL;
18356 }
18357
18358
18359 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18360 PyObject *resultobj = 0;
18361 wxEvent *arg1 = (wxEvent *) 0 ;
18362 int arg2 ;
18363 void *argp1 = 0 ;
18364 int res1 = 0 ;
18365 int val2 ;
18366 int ecode2 = 0 ;
18367 PyObject * obj0 = 0 ;
18368 PyObject * obj1 = 0 ;
18369 char * kwnames[] = {
18370 (char *) "self",(char *) "Id", NULL
18371 };
18372
18373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
18374 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18375 if (!SWIG_IsOK(res1)) {
18376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
18377 }
18378 arg1 = reinterpret_cast< wxEvent * >(argp1);
18379 ecode2 = SWIG_AsVal_int(obj1, &val2);
18380 if (!SWIG_IsOK(ecode2)) {
18381 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
18382 }
18383 arg2 = static_cast< int >(val2);
18384 {
18385 PyThreadState* __tstate = wxPyBeginAllowThreads();
18386 (arg1)->SetId(arg2);
18387 wxPyEndAllowThreads(__tstate);
18388 if (PyErr_Occurred()) SWIG_fail;
18389 }
18390 resultobj = SWIG_Py_Void();
18391 return resultobj;
18392 fail:
18393 return NULL;
18394 }
18395
18396
18397 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18398 PyObject *resultobj = 0;
18399 wxEvent *arg1 = (wxEvent *) 0 ;
18400 bool result;
18401 void *argp1 = 0 ;
18402 int res1 = 0 ;
18403 PyObject *swig_obj[1] ;
18404
18405 if (!args) SWIG_fail;
18406 swig_obj[0] = args;
18407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18408 if (!SWIG_IsOK(res1)) {
18409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
18410 }
18411 arg1 = reinterpret_cast< wxEvent * >(argp1);
18412 {
18413 PyThreadState* __tstate = wxPyBeginAllowThreads();
18414 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
18415 wxPyEndAllowThreads(__tstate);
18416 if (PyErr_Occurred()) SWIG_fail;
18417 }
18418 {
18419 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18420 }
18421 return resultobj;
18422 fail:
18423 return NULL;
18424 }
18425
18426
18427 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18428 PyObject *resultobj = 0;
18429 wxEvent *arg1 = (wxEvent *) 0 ;
18430 bool arg2 = (bool) true ;
18431 void *argp1 = 0 ;
18432 int res1 = 0 ;
18433 bool val2 ;
18434 int ecode2 = 0 ;
18435 PyObject * obj0 = 0 ;
18436 PyObject * obj1 = 0 ;
18437 char * kwnames[] = {
18438 (char *) "self",(char *) "skip", NULL
18439 };
18440
18441 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
18442 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18443 if (!SWIG_IsOK(res1)) {
18444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
18445 }
18446 arg1 = reinterpret_cast< wxEvent * >(argp1);
18447 if (obj1) {
18448 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18449 if (!SWIG_IsOK(ecode2)) {
18450 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
18451 }
18452 arg2 = static_cast< bool >(val2);
18453 }
18454 {
18455 PyThreadState* __tstate = wxPyBeginAllowThreads();
18456 (arg1)->Skip(arg2);
18457 wxPyEndAllowThreads(__tstate);
18458 if (PyErr_Occurred()) SWIG_fail;
18459 }
18460 resultobj = SWIG_Py_Void();
18461 return resultobj;
18462 fail:
18463 return NULL;
18464 }
18465
18466
18467 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18468 PyObject *resultobj = 0;
18469 wxEvent *arg1 = (wxEvent *) 0 ;
18470 bool result;
18471 void *argp1 = 0 ;
18472 int res1 = 0 ;
18473 PyObject *swig_obj[1] ;
18474
18475 if (!args) SWIG_fail;
18476 swig_obj[0] = args;
18477 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18478 if (!SWIG_IsOK(res1)) {
18479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
18480 }
18481 arg1 = reinterpret_cast< wxEvent * >(argp1);
18482 {
18483 PyThreadState* __tstate = wxPyBeginAllowThreads();
18484 result = (bool)((wxEvent const *)arg1)->GetSkipped();
18485 wxPyEndAllowThreads(__tstate);
18486 if (PyErr_Occurred()) SWIG_fail;
18487 }
18488 {
18489 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18490 }
18491 return resultobj;
18492 fail:
18493 return NULL;
18494 }
18495
18496
18497 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18498 PyObject *resultobj = 0;
18499 wxEvent *arg1 = (wxEvent *) 0 ;
18500 bool result;
18501 void *argp1 = 0 ;
18502 int res1 = 0 ;
18503 PyObject *swig_obj[1] ;
18504
18505 if (!args) SWIG_fail;
18506 swig_obj[0] = args;
18507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18508 if (!SWIG_IsOK(res1)) {
18509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
18510 }
18511 arg1 = reinterpret_cast< wxEvent * >(argp1);
18512 {
18513 PyThreadState* __tstate = wxPyBeginAllowThreads();
18514 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
18515 wxPyEndAllowThreads(__tstate);
18516 if (PyErr_Occurred()) SWIG_fail;
18517 }
18518 {
18519 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18520 }
18521 return resultobj;
18522 fail:
18523 return NULL;
18524 }
18525
18526
18527 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18528 PyObject *resultobj = 0;
18529 wxEvent *arg1 = (wxEvent *) 0 ;
18530 int result;
18531 void *argp1 = 0 ;
18532 int res1 = 0 ;
18533 PyObject *swig_obj[1] ;
18534
18535 if (!args) SWIG_fail;
18536 swig_obj[0] = args;
18537 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18538 if (!SWIG_IsOK(res1)) {
18539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18540 }
18541 arg1 = reinterpret_cast< wxEvent * >(argp1);
18542 {
18543 PyThreadState* __tstate = wxPyBeginAllowThreads();
18544 result = (int)(arg1)->StopPropagation();
18545 wxPyEndAllowThreads(__tstate);
18546 if (PyErr_Occurred()) SWIG_fail;
18547 }
18548 resultobj = SWIG_From_int(static_cast< int >(result));
18549 return resultobj;
18550 fail:
18551 return NULL;
18552 }
18553
18554
18555 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18556 PyObject *resultobj = 0;
18557 wxEvent *arg1 = (wxEvent *) 0 ;
18558 int arg2 ;
18559 void *argp1 = 0 ;
18560 int res1 = 0 ;
18561 int val2 ;
18562 int ecode2 = 0 ;
18563 PyObject * obj0 = 0 ;
18564 PyObject * obj1 = 0 ;
18565 char * kwnames[] = {
18566 (char *) "self",(char *) "propagationLevel", NULL
18567 };
18568
18569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
18570 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18571 if (!SWIG_IsOK(res1)) {
18572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18573 }
18574 arg1 = reinterpret_cast< wxEvent * >(argp1);
18575 ecode2 = SWIG_AsVal_int(obj1, &val2);
18576 if (!SWIG_IsOK(ecode2)) {
18577 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
18578 }
18579 arg2 = static_cast< int >(val2);
18580 {
18581 PyThreadState* __tstate = wxPyBeginAllowThreads();
18582 (arg1)->ResumePropagation(arg2);
18583 wxPyEndAllowThreads(__tstate);
18584 if (PyErr_Occurred()) SWIG_fail;
18585 }
18586 resultobj = SWIG_Py_Void();
18587 return resultobj;
18588 fail:
18589 return NULL;
18590 }
18591
18592
18593 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18594 PyObject *resultobj = 0;
18595 wxEvent *arg1 = (wxEvent *) 0 ;
18596 wxEvent *result = 0 ;
18597 void *argp1 = 0 ;
18598 int res1 = 0 ;
18599 PyObject *swig_obj[1] ;
18600
18601 if (!args) SWIG_fail;
18602 swig_obj[0] = args;
18603 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18604 if (!SWIG_IsOK(res1)) {
18605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
18606 }
18607 arg1 = reinterpret_cast< wxEvent * >(argp1);
18608 {
18609 PyThreadState* __tstate = wxPyBeginAllowThreads();
18610 result = (wxEvent *)(arg1)->Clone();
18611 wxPyEndAllowThreads(__tstate);
18612 if (PyErr_Occurred()) SWIG_fail;
18613 }
18614 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
18615 return resultobj;
18616 fail:
18617 return NULL;
18618 }
18619
18620
18621 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18622 PyObject *obj;
18623 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18624 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
18625 return SWIG_Py_Void();
18626 }
18627
18628 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18629 PyObject *resultobj = 0;
18630 wxEvent *arg1 = 0 ;
18631 wxPropagationDisabler *result = 0 ;
18632 void *argp1 = 0 ;
18633 int res1 = 0 ;
18634 PyObject * obj0 = 0 ;
18635 char * kwnames[] = {
18636 (char *) "event", NULL
18637 };
18638
18639 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
18640 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18641 if (!SWIG_IsOK(res1)) {
18642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18643 }
18644 if (!argp1) {
18645 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18646 }
18647 arg1 = reinterpret_cast< wxEvent * >(argp1);
18648 {
18649 PyThreadState* __tstate = wxPyBeginAllowThreads();
18650 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
18651 wxPyEndAllowThreads(__tstate);
18652 if (PyErr_Occurred()) SWIG_fail;
18653 }
18654 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
18655 return resultobj;
18656 fail:
18657 return NULL;
18658 }
18659
18660
18661 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18662 PyObject *resultobj = 0;
18663 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
18664 void *argp1 = 0 ;
18665 int res1 = 0 ;
18666 PyObject *swig_obj[1] ;
18667
18668 if (!args) SWIG_fail;
18669 swig_obj[0] = args;
18670 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
18671 if (!SWIG_IsOK(res1)) {
18672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
18673 }
18674 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
18675 {
18676 PyThreadState* __tstate = wxPyBeginAllowThreads();
18677 delete arg1;
18678
18679 wxPyEndAllowThreads(__tstate);
18680 if (PyErr_Occurred()) SWIG_fail;
18681 }
18682 resultobj = SWIG_Py_Void();
18683 return resultobj;
18684 fail:
18685 return NULL;
18686 }
18687
18688
18689 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18690 PyObject *obj;
18691 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18692 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
18693 return SWIG_Py_Void();
18694 }
18695
18696 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18697 return SWIG_Python_InitShadowInstance(args);
18698 }
18699
18700 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18701 PyObject *resultobj = 0;
18702 wxEvent *arg1 = 0 ;
18703 wxPropagateOnce *result = 0 ;
18704 void *argp1 = 0 ;
18705 int res1 = 0 ;
18706 PyObject * obj0 = 0 ;
18707 char * kwnames[] = {
18708 (char *) "event", NULL
18709 };
18710
18711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
18712 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18713 if (!SWIG_IsOK(res1)) {
18714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18715 }
18716 if (!argp1) {
18717 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18718 }
18719 arg1 = reinterpret_cast< wxEvent * >(argp1);
18720 {
18721 PyThreadState* __tstate = wxPyBeginAllowThreads();
18722 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
18723 wxPyEndAllowThreads(__tstate);
18724 if (PyErr_Occurred()) SWIG_fail;
18725 }
18726 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
18727 return resultobj;
18728 fail:
18729 return NULL;
18730 }
18731
18732
18733 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18734 PyObject *resultobj = 0;
18735 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
18736 void *argp1 = 0 ;
18737 int res1 = 0 ;
18738 PyObject *swig_obj[1] ;
18739
18740 if (!args) SWIG_fail;
18741 swig_obj[0] = args;
18742 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
18743 if (!SWIG_IsOK(res1)) {
18744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
18745 }
18746 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
18747 {
18748 PyThreadState* __tstate = wxPyBeginAllowThreads();
18749 delete arg1;
18750
18751 wxPyEndAllowThreads(__tstate);
18752 if (PyErr_Occurred()) SWIG_fail;
18753 }
18754 resultobj = SWIG_Py_Void();
18755 return resultobj;
18756 fail:
18757 return NULL;
18758 }
18759
18760
18761 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18762 PyObject *obj;
18763 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18764 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
18765 return SWIG_Py_Void();
18766 }
18767
18768 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18769 return SWIG_Python_InitShadowInstance(args);
18770 }
18771
18772 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18773 PyObject *resultobj = 0;
18774 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
18775 int arg2 = (int) 0 ;
18776 wxCommandEvent *result = 0 ;
18777 int val1 ;
18778 int ecode1 = 0 ;
18779 int val2 ;
18780 int ecode2 = 0 ;
18781 PyObject * obj0 = 0 ;
18782 PyObject * obj1 = 0 ;
18783 char * kwnames[] = {
18784 (char *) "commandType",(char *) "winid", NULL
18785 };
18786
18787 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18788 if (obj0) {
18789 ecode1 = SWIG_AsVal_int(obj0, &val1);
18790 if (!SWIG_IsOK(ecode1)) {
18791 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
18792 }
18793 arg1 = static_cast< wxEventType >(val1);
18794 }
18795 if (obj1) {
18796 ecode2 = SWIG_AsVal_int(obj1, &val2);
18797 if (!SWIG_IsOK(ecode2)) {
18798 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
18799 }
18800 arg2 = static_cast< int >(val2);
18801 }
18802 {
18803 PyThreadState* __tstate = wxPyBeginAllowThreads();
18804 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
18805 wxPyEndAllowThreads(__tstate);
18806 if (PyErr_Occurred()) SWIG_fail;
18807 }
18808 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
18809 return resultobj;
18810 fail:
18811 return NULL;
18812 }
18813
18814
18815 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18816 PyObject *resultobj = 0;
18817 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18818 int result;
18819 void *argp1 = 0 ;
18820 int res1 = 0 ;
18821 PyObject *swig_obj[1] ;
18822
18823 if (!args) SWIG_fail;
18824 swig_obj[0] = args;
18825 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18826 if (!SWIG_IsOK(res1)) {
18827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18828 }
18829 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18830 {
18831 PyThreadState* __tstate = wxPyBeginAllowThreads();
18832 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
18833 wxPyEndAllowThreads(__tstate);
18834 if (PyErr_Occurred()) SWIG_fail;
18835 }
18836 resultobj = SWIG_From_int(static_cast< int >(result));
18837 return resultobj;
18838 fail:
18839 return NULL;
18840 }
18841
18842
18843 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18844 PyObject *resultobj = 0;
18845 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18846 wxString *arg2 = 0 ;
18847 void *argp1 = 0 ;
18848 int res1 = 0 ;
18849 bool temp2 = false ;
18850 PyObject * obj0 = 0 ;
18851 PyObject * obj1 = 0 ;
18852 char * kwnames[] = {
18853 (char *) "self",(char *) "s", NULL
18854 };
18855
18856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
18857 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18858 if (!SWIG_IsOK(res1)) {
18859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
18860 }
18861 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18862 {
18863 arg2 = wxString_in_helper(obj1);
18864 if (arg2 == NULL) SWIG_fail;
18865 temp2 = true;
18866 }
18867 {
18868 PyThreadState* __tstate = wxPyBeginAllowThreads();
18869 (arg1)->SetString((wxString const &)*arg2);
18870 wxPyEndAllowThreads(__tstate);
18871 if (PyErr_Occurred()) SWIG_fail;
18872 }
18873 resultobj = SWIG_Py_Void();
18874 {
18875 if (temp2)
18876 delete arg2;
18877 }
18878 return resultobj;
18879 fail:
18880 {
18881 if (temp2)
18882 delete arg2;
18883 }
18884 return NULL;
18885 }
18886
18887
18888 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18889 PyObject *resultobj = 0;
18890 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18891 wxString result;
18892 void *argp1 = 0 ;
18893 int res1 = 0 ;
18894 PyObject *swig_obj[1] ;
18895
18896 if (!args) SWIG_fail;
18897 swig_obj[0] = args;
18898 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18899 if (!SWIG_IsOK(res1)) {
18900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18901 }
18902 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18903 {
18904 PyThreadState* __tstate = wxPyBeginAllowThreads();
18905 result = ((wxCommandEvent const *)arg1)->GetString();
18906 wxPyEndAllowThreads(__tstate);
18907 if (PyErr_Occurred()) SWIG_fail;
18908 }
18909 {
18910 #if wxUSE_UNICODE
18911 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18912 #else
18913 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18914 #endif
18915 }
18916 return resultobj;
18917 fail:
18918 return NULL;
18919 }
18920
18921
18922 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18923 PyObject *resultobj = 0;
18924 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18925 bool result;
18926 void *argp1 = 0 ;
18927 int res1 = 0 ;
18928 PyObject *swig_obj[1] ;
18929
18930 if (!args) SWIG_fail;
18931 swig_obj[0] = args;
18932 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18933 if (!SWIG_IsOK(res1)) {
18934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18935 }
18936 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18937 {
18938 PyThreadState* __tstate = wxPyBeginAllowThreads();
18939 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
18940 wxPyEndAllowThreads(__tstate);
18941 if (PyErr_Occurred()) SWIG_fail;
18942 }
18943 {
18944 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18945 }
18946 return resultobj;
18947 fail:
18948 return NULL;
18949 }
18950
18951
18952 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18953 PyObject *resultobj = 0;
18954 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18955 bool result;
18956 void *argp1 = 0 ;
18957 int res1 = 0 ;
18958 PyObject *swig_obj[1] ;
18959
18960 if (!args) SWIG_fail;
18961 swig_obj[0] = args;
18962 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18963 if (!SWIG_IsOK(res1)) {
18964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18965 }
18966 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18967 {
18968 PyThreadState* __tstate = wxPyBeginAllowThreads();
18969 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
18970 wxPyEndAllowThreads(__tstate);
18971 if (PyErr_Occurred()) SWIG_fail;
18972 }
18973 {
18974 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18975 }
18976 return resultobj;
18977 fail:
18978 return NULL;
18979 }
18980
18981
18982 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18983 PyObject *resultobj = 0;
18984 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18985 long arg2 ;
18986 void *argp1 = 0 ;
18987 int res1 = 0 ;
18988 long val2 ;
18989 int ecode2 = 0 ;
18990 PyObject * obj0 = 0 ;
18991 PyObject * obj1 = 0 ;
18992 char * kwnames[] = {
18993 (char *) "self",(char *) "extraLong", NULL
18994 };
18995
18996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
18997 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18998 if (!SWIG_IsOK(res1)) {
18999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19000 }
19001 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19002 ecode2 = SWIG_AsVal_long(obj1, &val2);
19003 if (!SWIG_IsOK(ecode2)) {
19004 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
19005 }
19006 arg2 = static_cast< long >(val2);
19007 {
19008 PyThreadState* __tstate = wxPyBeginAllowThreads();
19009 (arg1)->SetExtraLong(arg2);
19010 wxPyEndAllowThreads(__tstate);
19011 if (PyErr_Occurred()) SWIG_fail;
19012 }
19013 resultobj = SWIG_Py_Void();
19014 return resultobj;
19015 fail:
19016 return NULL;
19017 }
19018
19019
19020 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19021 PyObject *resultobj = 0;
19022 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19023 long result;
19024 void *argp1 = 0 ;
19025 int res1 = 0 ;
19026 PyObject *swig_obj[1] ;
19027
19028 if (!args) SWIG_fail;
19029 swig_obj[0] = args;
19030 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19031 if (!SWIG_IsOK(res1)) {
19032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19033 }
19034 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19035 {
19036 PyThreadState* __tstate = wxPyBeginAllowThreads();
19037 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
19038 wxPyEndAllowThreads(__tstate);
19039 if (PyErr_Occurred()) SWIG_fail;
19040 }
19041 resultobj = SWIG_From_long(static_cast< long >(result));
19042 return resultobj;
19043 fail:
19044 return NULL;
19045 }
19046
19047
19048 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19049 PyObject *resultobj = 0;
19050 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19051 int arg2 ;
19052 void *argp1 = 0 ;
19053 int res1 = 0 ;
19054 int val2 ;
19055 int ecode2 = 0 ;
19056 PyObject * obj0 = 0 ;
19057 PyObject * obj1 = 0 ;
19058 char * kwnames[] = {
19059 (char *) "self",(char *) "i", NULL
19060 };
19061
19062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
19063 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19064 if (!SWIG_IsOK(res1)) {
19065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19066 }
19067 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19068 ecode2 = SWIG_AsVal_int(obj1, &val2);
19069 if (!SWIG_IsOK(ecode2)) {
19070 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
19071 }
19072 arg2 = static_cast< int >(val2);
19073 {
19074 PyThreadState* __tstate = wxPyBeginAllowThreads();
19075 (arg1)->SetInt(arg2);
19076 wxPyEndAllowThreads(__tstate);
19077 if (PyErr_Occurred()) SWIG_fail;
19078 }
19079 resultobj = SWIG_Py_Void();
19080 return resultobj;
19081 fail:
19082 return NULL;
19083 }
19084
19085
19086 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19087 PyObject *resultobj = 0;
19088 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19089 long result;
19090 void *argp1 = 0 ;
19091 int res1 = 0 ;
19092 PyObject *swig_obj[1] ;
19093
19094 if (!args) SWIG_fail;
19095 swig_obj[0] = args;
19096 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19097 if (!SWIG_IsOK(res1)) {
19098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19099 }
19100 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19101 {
19102 PyThreadState* __tstate = wxPyBeginAllowThreads();
19103 result = (long)((wxCommandEvent const *)arg1)->GetInt();
19104 wxPyEndAllowThreads(__tstate);
19105 if (PyErr_Occurred()) SWIG_fail;
19106 }
19107 resultobj = SWIG_From_long(static_cast< long >(result));
19108 return resultobj;
19109 fail:
19110 return NULL;
19111 }
19112
19113
19114 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19115 PyObject *resultobj = 0;
19116 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19117 PyObject *result = 0 ;
19118 void *argp1 = 0 ;
19119 int res1 = 0 ;
19120 PyObject *swig_obj[1] ;
19121
19122 if (!args) SWIG_fail;
19123 swig_obj[0] = args;
19124 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19125 if (!SWIG_IsOK(res1)) {
19126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19127 }
19128 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19129 {
19130 PyThreadState* __tstate = wxPyBeginAllowThreads();
19131 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
19132 wxPyEndAllowThreads(__tstate);
19133 if (PyErr_Occurred()) SWIG_fail;
19134 }
19135 resultobj = result;
19136 return resultobj;
19137 fail:
19138 return NULL;
19139 }
19140
19141
19142 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19143 PyObject *resultobj = 0;
19144 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19145 PyObject *arg2 = (PyObject *) 0 ;
19146 void *argp1 = 0 ;
19147 int res1 = 0 ;
19148 PyObject * obj0 = 0 ;
19149 PyObject * obj1 = 0 ;
19150 char * kwnames[] = {
19151 (char *) "self",(char *) "clientData", NULL
19152 };
19153
19154 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
19155 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19156 if (!SWIG_IsOK(res1)) {
19157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19158 }
19159 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19160 arg2 = obj1;
19161 {
19162 PyThreadState* __tstate = wxPyBeginAllowThreads();
19163 wxCommandEvent_SetClientData(arg1,arg2);
19164 wxPyEndAllowThreads(__tstate);
19165 if (PyErr_Occurred()) SWIG_fail;
19166 }
19167 resultobj = SWIG_Py_Void();
19168 return resultobj;
19169 fail:
19170 return NULL;
19171 }
19172
19173
19174 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19175 PyObject *resultobj = 0;
19176 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19177 wxEvent *result = 0 ;
19178 void *argp1 = 0 ;
19179 int res1 = 0 ;
19180 PyObject *swig_obj[1] ;
19181
19182 if (!args) SWIG_fail;
19183 swig_obj[0] = args;
19184 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19185 if (!SWIG_IsOK(res1)) {
19186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19187 }
19188 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19189 {
19190 PyThreadState* __tstate = wxPyBeginAllowThreads();
19191 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
19192 wxPyEndAllowThreads(__tstate);
19193 if (PyErr_Occurred()) SWIG_fail;
19194 }
19195 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
19196 return resultobj;
19197 fail:
19198 return NULL;
19199 }
19200
19201
19202 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19203 PyObject *obj;
19204 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19205 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
19206 return SWIG_Py_Void();
19207 }
19208
19209 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19210 return SWIG_Python_InitShadowInstance(args);
19211 }
19212
19213 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19214 PyObject *resultobj = 0;
19215 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19216 int arg2 = (int) 0 ;
19217 wxNotifyEvent *result = 0 ;
19218 int val1 ;
19219 int ecode1 = 0 ;
19220 int val2 ;
19221 int ecode2 = 0 ;
19222 PyObject * obj0 = 0 ;
19223 PyObject * obj1 = 0 ;
19224 char * kwnames[] = {
19225 (char *) "commandType",(char *) "winid", NULL
19226 };
19227
19228 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19229 if (obj0) {
19230 ecode1 = SWIG_AsVal_int(obj0, &val1);
19231 if (!SWIG_IsOK(ecode1)) {
19232 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19233 }
19234 arg1 = static_cast< wxEventType >(val1);
19235 }
19236 if (obj1) {
19237 ecode2 = SWIG_AsVal_int(obj1, &val2);
19238 if (!SWIG_IsOK(ecode2)) {
19239 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
19240 }
19241 arg2 = static_cast< int >(val2);
19242 }
19243 {
19244 PyThreadState* __tstate = wxPyBeginAllowThreads();
19245 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
19246 wxPyEndAllowThreads(__tstate);
19247 if (PyErr_Occurred()) SWIG_fail;
19248 }
19249 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
19250 return resultobj;
19251 fail:
19252 return NULL;
19253 }
19254
19255
19256 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19257 PyObject *resultobj = 0;
19258 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19259 void *argp1 = 0 ;
19260 int res1 = 0 ;
19261 PyObject *swig_obj[1] ;
19262
19263 if (!args) SWIG_fail;
19264 swig_obj[0] = args;
19265 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19266 if (!SWIG_IsOK(res1)) {
19267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19268 }
19269 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19270 {
19271 PyThreadState* __tstate = wxPyBeginAllowThreads();
19272 (arg1)->Veto();
19273 wxPyEndAllowThreads(__tstate);
19274 if (PyErr_Occurred()) SWIG_fail;
19275 }
19276 resultobj = SWIG_Py_Void();
19277 return resultobj;
19278 fail:
19279 return NULL;
19280 }
19281
19282
19283 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19284 PyObject *resultobj = 0;
19285 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19286 void *argp1 = 0 ;
19287 int res1 = 0 ;
19288 PyObject *swig_obj[1] ;
19289
19290 if (!args) SWIG_fail;
19291 swig_obj[0] = args;
19292 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19293 if (!SWIG_IsOK(res1)) {
19294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19295 }
19296 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19297 {
19298 PyThreadState* __tstate = wxPyBeginAllowThreads();
19299 (arg1)->Allow();
19300 wxPyEndAllowThreads(__tstate);
19301 if (PyErr_Occurred()) SWIG_fail;
19302 }
19303 resultobj = SWIG_Py_Void();
19304 return resultobj;
19305 fail:
19306 return NULL;
19307 }
19308
19309
19310 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19311 PyObject *resultobj = 0;
19312 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19313 bool result;
19314 void *argp1 = 0 ;
19315 int res1 = 0 ;
19316 PyObject *swig_obj[1] ;
19317
19318 if (!args) SWIG_fail;
19319 swig_obj[0] = args;
19320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19321 if (!SWIG_IsOK(res1)) {
19322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19323 }
19324 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19325 {
19326 PyThreadState* __tstate = wxPyBeginAllowThreads();
19327 result = (bool)(arg1)->IsAllowed();
19328 wxPyEndAllowThreads(__tstate);
19329 if (PyErr_Occurred()) SWIG_fail;
19330 }
19331 {
19332 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19333 }
19334 return resultobj;
19335 fail:
19336 return NULL;
19337 }
19338
19339
19340 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19341 PyObject *obj;
19342 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19343 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
19344 return SWIG_Py_Void();
19345 }
19346
19347 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19348 return SWIG_Python_InitShadowInstance(args);
19349 }
19350
19351 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19352 PyObject *resultobj = 0;
19353 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19354 int arg2 = (int) 0 ;
19355 int arg3 = (int) 0 ;
19356 int arg4 = (int) 0 ;
19357 wxScrollEvent *result = 0 ;
19358 int val1 ;
19359 int ecode1 = 0 ;
19360 int val2 ;
19361 int ecode2 = 0 ;
19362 int val3 ;
19363 int ecode3 = 0 ;
19364 int val4 ;
19365 int ecode4 = 0 ;
19366 PyObject * obj0 = 0 ;
19367 PyObject * obj1 = 0 ;
19368 PyObject * obj2 = 0 ;
19369 PyObject * obj3 = 0 ;
19370 char * kwnames[] = {
19371 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
19372 };
19373
19374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19375 if (obj0) {
19376 ecode1 = SWIG_AsVal_int(obj0, &val1);
19377 if (!SWIG_IsOK(ecode1)) {
19378 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19379 }
19380 arg1 = static_cast< wxEventType >(val1);
19381 }
19382 if (obj1) {
19383 ecode2 = SWIG_AsVal_int(obj1, &val2);
19384 if (!SWIG_IsOK(ecode2)) {
19385 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
19386 }
19387 arg2 = static_cast< int >(val2);
19388 }
19389 if (obj2) {
19390 ecode3 = SWIG_AsVal_int(obj2, &val3);
19391 if (!SWIG_IsOK(ecode3)) {
19392 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
19393 }
19394 arg3 = static_cast< int >(val3);
19395 }
19396 if (obj3) {
19397 ecode4 = SWIG_AsVal_int(obj3, &val4);
19398 if (!SWIG_IsOK(ecode4)) {
19399 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
19400 }
19401 arg4 = static_cast< int >(val4);
19402 }
19403 {
19404 PyThreadState* __tstate = wxPyBeginAllowThreads();
19405 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
19406 wxPyEndAllowThreads(__tstate);
19407 if (PyErr_Occurred()) SWIG_fail;
19408 }
19409 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
19410 return resultobj;
19411 fail:
19412 return NULL;
19413 }
19414
19415
19416 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19417 PyObject *resultobj = 0;
19418 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19419 int result;
19420 void *argp1 = 0 ;
19421 int res1 = 0 ;
19422 PyObject *swig_obj[1] ;
19423
19424 if (!args) SWIG_fail;
19425 swig_obj[0] = args;
19426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19427 if (!SWIG_IsOK(res1)) {
19428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19429 }
19430 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19431 {
19432 PyThreadState* __tstate = wxPyBeginAllowThreads();
19433 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
19434 wxPyEndAllowThreads(__tstate);
19435 if (PyErr_Occurred()) SWIG_fail;
19436 }
19437 resultobj = SWIG_From_int(static_cast< int >(result));
19438 return resultobj;
19439 fail:
19440 return NULL;
19441 }
19442
19443
19444 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19445 PyObject *resultobj = 0;
19446 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19447 int result;
19448 void *argp1 = 0 ;
19449 int res1 = 0 ;
19450 PyObject *swig_obj[1] ;
19451
19452 if (!args) SWIG_fail;
19453 swig_obj[0] = args;
19454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19455 if (!SWIG_IsOK(res1)) {
19456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19457 }
19458 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19459 {
19460 PyThreadState* __tstate = wxPyBeginAllowThreads();
19461 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
19462 wxPyEndAllowThreads(__tstate);
19463 if (PyErr_Occurred()) SWIG_fail;
19464 }
19465 resultobj = SWIG_From_int(static_cast< int >(result));
19466 return resultobj;
19467 fail:
19468 return NULL;
19469 }
19470
19471
19472 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19473 PyObject *resultobj = 0;
19474 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19475 int arg2 ;
19476 void *argp1 = 0 ;
19477 int res1 = 0 ;
19478 int val2 ;
19479 int ecode2 = 0 ;
19480 PyObject * obj0 = 0 ;
19481 PyObject * obj1 = 0 ;
19482 char * kwnames[] = {
19483 (char *) "self",(char *) "orient", NULL
19484 };
19485
19486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19487 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19488 if (!SWIG_IsOK(res1)) {
19489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19490 }
19491 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19492 ecode2 = SWIG_AsVal_int(obj1, &val2);
19493 if (!SWIG_IsOK(ecode2)) {
19494 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19495 }
19496 arg2 = static_cast< int >(val2);
19497 {
19498 PyThreadState* __tstate = wxPyBeginAllowThreads();
19499 (arg1)->SetOrientation(arg2);
19500 wxPyEndAllowThreads(__tstate);
19501 if (PyErr_Occurred()) SWIG_fail;
19502 }
19503 resultobj = SWIG_Py_Void();
19504 return resultobj;
19505 fail:
19506 return NULL;
19507 }
19508
19509
19510 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19511 PyObject *resultobj = 0;
19512 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19513 int arg2 ;
19514 void *argp1 = 0 ;
19515 int res1 = 0 ;
19516 int val2 ;
19517 int ecode2 = 0 ;
19518 PyObject * obj0 = 0 ;
19519 PyObject * obj1 = 0 ;
19520 char * kwnames[] = {
19521 (char *) "self",(char *) "pos", NULL
19522 };
19523
19524 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19525 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19526 if (!SWIG_IsOK(res1)) {
19527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19528 }
19529 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19530 ecode2 = SWIG_AsVal_int(obj1, &val2);
19531 if (!SWIG_IsOK(ecode2)) {
19532 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19533 }
19534 arg2 = static_cast< int >(val2);
19535 {
19536 PyThreadState* __tstate = wxPyBeginAllowThreads();
19537 (arg1)->SetPosition(arg2);
19538 wxPyEndAllowThreads(__tstate);
19539 if (PyErr_Occurred()) SWIG_fail;
19540 }
19541 resultobj = SWIG_Py_Void();
19542 return resultobj;
19543 fail:
19544 return NULL;
19545 }
19546
19547
19548 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19549 PyObject *obj;
19550 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19551 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
19552 return SWIG_Py_Void();
19553 }
19554
19555 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19556 return SWIG_Python_InitShadowInstance(args);
19557 }
19558
19559 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19560 PyObject *resultobj = 0;
19561 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19562 int arg2 = (int) 0 ;
19563 int arg3 = (int) 0 ;
19564 wxScrollWinEvent *result = 0 ;
19565 int val1 ;
19566 int ecode1 = 0 ;
19567 int val2 ;
19568 int ecode2 = 0 ;
19569 int val3 ;
19570 int ecode3 = 0 ;
19571 PyObject * obj0 = 0 ;
19572 PyObject * obj1 = 0 ;
19573 PyObject * obj2 = 0 ;
19574 char * kwnames[] = {
19575 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
19576 };
19577
19578 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19579 if (obj0) {
19580 ecode1 = SWIG_AsVal_int(obj0, &val1);
19581 if (!SWIG_IsOK(ecode1)) {
19582 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19583 }
19584 arg1 = static_cast< wxEventType >(val1);
19585 }
19586 if (obj1) {
19587 ecode2 = SWIG_AsVal_int(obj1, &val2);
19588 if (!SWIG_IsOK(ecode2)) {
19589 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
19590 }
19591 arg2 = static_cast< int >(val2);
19592 }
19593 if (obj2) {
19594 ecode3 = SWIG_AsVal_int(obj2, &val3);
19595 if (!SWIG_IsOK(ecode3)) {
19596 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
19597 }
19598 arg3 = static_cast< int >(val3);
19599 }
19600 {
19601 PyThreadState* __tstate = wxPyBeginAllowThreads();
19602 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
19603 wxPyEndAllowThreads(__tstate);
19604 if (PyErr_Occurred()) SWIG_fail;
19605 }
19606 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
19607 return resultobj;
19608 fail:
19609 return NULL;
19610 }
19611
19612
19613 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19614 PyObject *resultobj = 0;
19615 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19616 int result;
19617 void *argp1 = 0 ;
19618 int res1 = 0 ;
19619 PyObject *swig_obj[1] ;
19620
19621 if (!args) SWIG_fail;
19622 swig_obj[0] = args;
19623 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19624 if (!SWIG_IsOK(res1)) {
19625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19626 }
19627 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19628 {
19629 PyThreadState* __tstate = wxPyBeginAllowThreads();
19630 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
19631 wxPyEndAllowThreads(__tstate);
19632 if (PyErr_Occurred()) SWIG_fail;
19633 }
19634 resultobj = SWIG_From_int(static_cast< int >(result));
19635 return resultobj;
19636 fail:
19637 return NULL;
19638 }
19639
19640
19641 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19642 PyObject *resultobj = 0;
19643 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19644 int result;
19645 void *argp1 = 0 ;
19646 int res1 = 0 ;
19647 PyObject *swig_obj[1] ;
19648
19649 if (!args) SWIG_fail;
19650 swig_obj[0] = args;
19651 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19652 if (!SWIG_IsOK(res1)) {
19653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19654 }
19655 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19656 {
19657 PyThreadState* __tstate = wxPyBeginAllowThreads();
19658 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
19659 wxPyEndAllowThreads(__tstate);
19660 if (PyErr_Occurred()) SWIG_fail;
19661 }
19662 resultobj = SWIG_From_int(static_cast< int >(result));
19663 return resultobj;
19664 fail:
19665 return NULL;
19666 }
19667
19668
19669 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19670 PyObject *resultobj = 0;
19671 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19672 int arg2 ;
19673 void *argp1 = 0 ;
19674 int res1 = 0 ;
19675 int val2 ;
19676 int ecode2 = 0 ;
19677 PyObject * obj0 = 0 ;
19678 PyObject * obj1 = 0 ;
19679 char * kwnames[] = {
19680 (char *) "self",(char *) "orient", NULL
19681 };
19682
19683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19684 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19685 if (!SWIG_IsOK(res1)) {
19686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19687 }
19688 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19689 ecode2 = SWIG_AsVal_int(obj1, &val2);
19690 if (!SWIG_IsOK(ecode2)) {
19691 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19692 }
19693 arg2 = static_cast< int >(val2);
19694 {
19695 PyThreadState* __tstate = wxPyBeginAllowThreads();
19696 (arg1)->SetOrientation(arg2);
19697 wxPyEndAllowThreads(__tstate);
19698 if (PyErr_Occurred()) SWIG_fail;
19699 }
19700 resultobj = SWIG_Py_Void();
19701 return resultobj;
19702 fail:
19703 return NULL;
19704 }
19705
19706
19707 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19708 PyObject *resultobj = 0;
19709 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19710 int arg2 ;
19711 void *argp1 = 0 ;
19712 int res1 = 0 ;
19713 int val2 ;
19714 int ecode2 = 0 ;
19715 PyObject * obj0 = 0 ;
19716 PyObject * obj1 = 0 ;
19717 char * kwnames[] = {
19718 (char *) "self",(char *) "pos", NULL
19719 };
19720
19721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19722 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19723 if (!SWIG_IsOK(res1)) {
19724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19725 }
19726 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19727 ecode2 = SWIG_AsVal_int(obj1, &val2);
19728 if (!SWIG_IsOK(ecode2)) {
19729 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19730 }
19731 arg2 = static_cast< int >(val2);
19732 {
19733 PyThreadState* __tstate = wxPyBeginAllowThreads();
19734 (arg1)->SetPosition(arg2);
19735 wxPyEndAllowThreads(__tstate);
19736 if (PyErr_Occurred()) SWIG_fail;
19737 }
19738 resultobj = SWIG_Py_Void();
19739 return resultobj;
19740 fail:
19741 return NULL;
19742 }
19743
19744
19745 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19746 PyObject *obj;
19747 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19748 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
19749 return SWIG_Py_Void();
19750 }
19751
19752 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19753 return SWIG_Python_InitShadowInstance(args);
19754 }
19755
19756 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19757 PyObject *resultobj = 0;
19758 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19759 wxMouseEvent *result = 0 ;
19760 int val1 ;
19761 int ecode1 = 0 ;
19762 PyObject * obj0 = 0 ;
19763 char * kwnames[] = {
19764 (char *) "mouseType", NULL
19765 };
19766
19767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
19768 if (obj0) {
19769 ecode1 = SWIG_AsVal_int(obj0, &val1);
19770 if (!SWIG_IsOK(ecode1)) {
19771 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19772 }
19773 arg1 = static_cast< wxEventType >(val1);
19774 }
19775 {
19776 PyThreadState* __tstate = wxPyBeginAllowThreads();
19777 result = (wxMouseEvent *)new wxMouseEvent(arg1);
19778 wxPyEndAllowThreads(__tstate);
19779 if (PyErr_Occurred()) SWIG_fail;
19780 }
19781 {
19782 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
19783 }
19784 return resultobj;
19785 fail:
19786 return NULL;
19787 }
19788
19789
19790 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19791 PyObject *resultobj = 0;
19792 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19793 bool result;
19794 void *argp1 = 0 ;
19795 int res1 = 0 ;
19796 PyObject *swig_obj[1] ;
19797
19798 if (!args) SWIG_fail;
19799 swig_obj[0] = args;
19800 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19801 if (!SWIG_IsOK(res1)) {
19802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19803 }
19804 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19805 {
19806 PyThreadState* __tstate = wxPyBeginAllowThreads();
19807 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
19808 wxPyEndAllowThreads(__tstate);
19809 if (PyErr_Occurred()) SWIG_fail;
19810 }
19811 {
19812 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19813 }
19814 return resultobj;
19815 fail:
19816 return NULL;
19817 }
19818
19819
19820 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19821 PyObject *resultobj = 0;
19822 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19823 int arg2 = (int) wxMOUSE_BTN_ANY ;
19824 bool result;
19825 void *argp1 = 0 ;
19826 int res1 = 0 ;
19827 int val2 ;
19828 int ecode2 = 0 ;
19829 PyObject * obj0 = 0 ;
19830 PyObject * obj1 = 0 ;
19831 char * kwnames[] = {
19832 (char *) "self",(char *) "but", NULL
19833 };
19834
19835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
19836 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19837 if (!SWIG_IsOK(res1)) {
19838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19839 }
19840 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19841 if (obj1) {
19842 ecode2 = SWIG_AsVal_int(obj1, &val2);
19843 if (!SWIG_IsOK(ecode2)) {
19844 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
19845 }
19846 arg2 = static_cast< int >(val2);
19847 }
19848 {
19849 PyThreadState* __tstate = wxPyBeginAllowThreads();
19850 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
19851 wxPyEndAllowThreads(__tstate);
19852 if (PyErr_Occurred()) SWIG_fail;
19853 }
19854 {
19855 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19856 }
19857 return resultobj;
19858 fail:
19859 return NULL;
19860 }
19861
19862
19863 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19864 PyObject *resultobj = 0;
19865 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19866 int arg2 = (int) wxMOUSE_BTN_ANY ;
19867 bool result;
19868 void *argp1 = 0 ;
19869 int res1 = 0 ;
19870 int val2 ;
19871 int ecode2 = 0 ;
19872 PyObject * obj0 = 0 ;
19873 PyObject * obj1 = 0 ;
19874 char * kwnames[] = {
19875 (char *) "self",(char *) "but", NULL
19876 };
19877
19878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
19879 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19880 if (!SWIG_IsOK(res1)) {
19881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19882 }
19883 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19884 if (obj1) {
19885 ecode2 = SWIG_AsVal_int(obj1, &val2);
19886 if (!SWIG_IsOK(ecode2)) {
19887 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
19888 }
19889 arg2 = static_cast< int >(val2);
19890 }
19891 {
19892 PyThreadState* __tstate = wxPyBeginAllowThreads();
19893 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
19894 wxPyEndAllowThreads(__tstate);
19895 if (PyErr_Occurred()) SWIG_fail;
19896 }
19897 {
19898 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19899 }
19900 return resultobj;
19901 fail:
19902 return NULL;
19903 }
19904
19905
19906 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19907 PyObject *resultobj = 0;
19908 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19909 int arg2 = (int) wxMOUSE_BTN_ANY ;
19910 bool result;
19911 void *argp1 = 0 ;
19912 int res1 = 0 ;
19913 int val2 ;
19914 int ecode2 = 0 ;
19915 PyObject * obj0 = 0 ;
19916 PyObject * obj1 = 0 ;
19917 char * kwnames[] = {
19918 (char *) "self",(char *) "but", NULL
19919 };
19920
19921 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
19922 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19923 if (!SWIG_IsOK(res1)) {
19924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19925 }
19926 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19927 if (obj1) {
19928 ecode2 = SWIG_AsVal_int(obj1, &val2);
19929 if (!SWIG_IsOK(ecode2)) {
19930 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
19931 }
19932 arg2 = static_cast< int >(val2);
19933 }
19934 {
19935 PyThreadState* __tstate = wxPyBeginAllowThreads();
19936 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
19937 wxPyEndAllowThreads(__tstate);
19938 if (PyErr_Occurred()) SWIG_fail;
19939 }
19940 {
19941 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19942 }
19943 return resultobj;
19944 fail:
19945 return NULL;
19946 }
19947
19948
19949 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19950 PyObject *resultobj = 0;
19951 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19952 int arg2 ;
19953 bool result;
19954 void *argp1 = 0 ;
19955 int res1 = 0 ;
19956 int val2 ;
19957 int ecode2 = 0 ;
19958 PyObject * obj0 = 0 ;
19959 PyObject * obj1 = 0 ;
19960 char * kwnames[] = {
19961 (char *) "self",(char *) "button", NULL
19962 };
19963
19964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
19965 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19966 if (!SWIG_IsOK(res1)) {
19967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19968 }
19969 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19970 ecode2 = SWIG_AsVal_int(obj1, &val2);
19971 if (!SWIG_IsOK(ecode2)) {
19972 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
19973 }
19974 arg2 = static_cast< int >(val2);
19975 {
19976 PyThreadState* __tstate = wxPyBeginAllowThreads();
19977 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
19978 wxPyEndAllowThreads(__tstate);
19979 if (PyErr_Occurred()) SWIG_fail;
19980 }
19981 {
19982 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19983 }
19984 return resultobj;
19985 fail:
19986 return NULL;
19987 }
19988
19989
19990 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19991 PyObject *resultobj = 0;
19992 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19993 int arg2 ;
19994 bool result;
19995 void *argp1 = 0 ;
19996 int res1 = 0 ;
19997 int val2 ;
19998 int ecode2 = 0 ;
19999 PyObject * obj0 = 0 ;
20000 PyObject * obj1 = 0 ;
20001 char * kwnames[] = {
20002 (char *) "self",(char *) "but", NULL
20003 };
20004
20005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
20006 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20007 if (!SWIG_IsOK(res1)) {
20008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20009 }
20010 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20011 ecode2 = SWIG_AsVal_int(obj1, &val2);
20012 if (!SWIG_IsOK(ecode2)) {
20013 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
20014 }
20015 arg2 = static_cast< int >(val2);
20016 {
20017 PyThreadState* __tstate = wxPyBeginAllowThreads();
20018 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
20019 wxPyEndAllowThreads(__tstate);
20020 if (PyErr_Occurred()) SWIG_fail;
20021 }
20022 {
20023 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20024 }
20025 return resultobj;
20026 fail:
20027 return NULL;
20028 }
20029
20030
20031 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20032 PyObject *resultobj = 0;
20033 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20034 int result;
20035 void *argp1 = 0 ;
20036 int res1 = 0 ;
20037 PyObject *swig_obj[1] ;
20038
20039 if (!args) SWIG_fail;
20040 swig_obj[0] = args;
20041 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20042 if (!SWIG_IsOK(res1)) {
20043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20044 }
20045 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20046 {
20047 PyThreadState* __tstate = wxPyBeginAllowThreads();
20048 result = (int)((wxMouseEvent const *)arg1)->GetButton();
20049 wxPyEndAllowThreads(__tstate);
20050 if (PyErr_Occurred()) SWIG_fail;
20051 }
20052 resultobj = SWIG_From_int(static_cast< int >(result));
20053 return resultobj;
20054 fail:
20055 return NULL;
20056 }
20057
20058
20059 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20060 PyObject *resultobj = 0;
20061 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20062 bool result;
20063 void *argp1 = 0 ;
20064 int res1 = 0 ;
20065 PyObject *swig_obj[1] ;
20066
20067 if (!args) SWIG_fail;
20068 swig_obj[0] = args;
20069 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20070 if (!SWIG_IsOK(res1)) {
20071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20072 }
20073 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20074 {
20075 PyThreadState* __tstate = wxPyBeginAllowThreads();
20076 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
20077 wxPyEndAllowThreads(__tstate);
20078 if (PyErr_Occurred()) SWIG_fail;
20079 }
20080 {
20081 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20082 }
20083 return resultobj;
20084 fail:
20085 return NULL;
20086 }
20087
20088
20089 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20090 PyObject *resultobj = 0;
20091 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20092 bool result;
20093 void *argp1 = 0 ;
20094 int res1 = 0 ;
20095 PyObject *swig_obj[1] ;
20096
20097 if (!args) SWIG_fail;
20098 swig_obj[0] = args;
20099 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20100 if (!SWIG_IsOK(res1)) {
20101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20102 }
20103 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20104 {
20105 PyThreadState* __tstate = wxPyBeginAllowThreads();
20106 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
20107 wxPyEndAllowThreads(__tstate);
20108 if (PyErr_Occurred()) SWIG_fail;
20109 }
20110 {
20111 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20112 }
20113 return resultobj;
20114 fail:
20115 return NULL;
20116 }
20117
20118
20119 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20120 PyObject *resultobj = 0;
20121 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20122 bool result;
20123 void *argp1 = 0 ;
20124 int res1 = 0 ;
20125 PyObject *swig_obj[1] ;
20126
20127 if (!args) SWIG_fail;
20128 swig_obj[0] = args;
20129 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20130 if (!SWIG_IsOK(res1)) {
20131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20132 }
20133 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20134 {
20135 PyThreadState* __tstate = wxPyBeginAllowThreads();
20136 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
20137 wxPyEndAllowThreads(__tstate);
20138 if (PyErr_Occurred()) SWIG_fail;
20139 }
20140 {
20141 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20142 }
20143 return resultobj;
20144 fail:
20145 return NULL;
20146 }
20147
20148
20149 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20150 PyObject *resultobj = 0;
20151 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20152 bool result;
20153 void *argp1 = 0 ;
20154 int res1 = 0 ;
20155 PyObject *swig_obj[1] ;
20156
20157 if (!args) SWIG_fail;
20158 swig_obj[0] = args;
20159 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20160 if (!SWIG_IsOK(res1)) {
20161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20162 }
20163 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20164 {
20165 PyThreadState* __tstate = wxPyBeginAllowThreads();
20166 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
20167 wxPyEndAllowThreads(__tstate);
20168 if (PyErr_Occurred()) SWIG_fail;
20169 }
20170 {
20171 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20172 }
20173 return resultobj;
20174 fail:
20175 return NULL;
20176 }
20177
20178
20179 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20180 PyObject *resultobj = 0;
20181 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20182 bool result;
20183 void *argp1 = 0 ;
20184 int res1 = 0 ;
20185 PyObject *swig_obj[1] ;
20186
20187 if (!args) SWIG_fail;
20188 swig_obj[0] = args;
20189 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20190 if (!SWIG_IsOK(res1)) {
20191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20192 }
20193 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20194 {
20195 PyThreadState* __tstate = wxPyBeginAllowThreads();
20196 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
20197 wxPyEndAllowThreads(__tstate);
20198 if (PyErr_Occurred()) SWIG_fail;
20199 }
20200 {
20201 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20202 }
20203 return resultobj;
20204 fail:
20205 return NULL;
20206 }
20207
20208
20209 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20210 PyObject *resultobj = 0;
20211 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20212 bool result;
20213 void *argp1 = 0 ;
20214 int res1 = 0 ;
20215 PyObject *swig_obj[1] ;
20216
20217 if (!args) SWIG_fail;
20218 swig_obj[0] = args;
20219 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20220 if (!SWIG_IsOK(res1)) {
20221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20222 }
20223 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20224 {
20225 PyThreadState* __tstate = wxPyBeginAllowThreads();
20226 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
20227 wxPyEndAllowThreads(__tstate);
20228 if (PyErr_Occurred()) SWIG_fail;
20229 }
20230 {
20231 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20232 }
20233 return resultobj;
20234 fail:
20235 return NULL;
20236 }
20237
20238
20239 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20240 PyObject *resultobj = 0;
20241 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20242 bool result;
20243 void *argp1 = 0 ;
20244 int res1 = 0 ;
20245 PyObject *swig_obj[1] ;
20246
20247 if (!args) SWIG_fail;
20248 swig_obj[0] = args;
20249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20250 if (!SWIG_IsOK(res1)) {
20251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20252 }
20253 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20254 {
20255 PyThreadState* __tstate = wxPyBeginAllowThreads();
20256 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
20257 wxPyEndAllowThreads(__tstate);
20258 if (PyErr_Occurred()) SWIG_fail;
20259 }
20260 {
20261 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20262 }
20263 return resultobj;
20264 fail:
20265 return NULL;
20266 }
20267
20268
20269 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20270 PyObject *resultobj = 0;
20271 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20272 bool result;
20273 void *argp1 = 0 ;
20274 int res1 = 0 ;
20275 PyObject *swig_obj[1] ;
20276
20277 if (!args) SWIG_fail;
20278 swig_obj[0] = args;
20279 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20280 if (!SWIG_IsOK(res1)) {
20281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20282 }
20283 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20284 {
20285 PyThreadState* __tstate = wxPyBeginAllowThreads();
20286 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
20287 wxPyEndAllowThreads(__tstate);
20288 if (PyErr_Occurred()) SWIG_fail;
20289 }
20290 {
20291 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20292 }
20293 return resultobj;
20294 fail:
20295 return NULL;
20296 }
20297
20298
20299 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20300 PyObject *resultobj = 0;
20301 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20302 bool result;
20303 void *argp1 = 0 ;
20304 int res1 = 0 ;
20305 PyObject *swig_obj[1] ;
20306
20307 if (!args) SWIG_fail;
20308 swig_obj[0] = args;
20309 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20310 if (!SWIG_IsOK(res1)) {
20311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20312 }
20313 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20314 {
20315 PyThreadState* __tstate = wxPyBeginAllowThreads();
20316 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
20317 wxPyEndAllowThreads(__tstate);
20318 if (PyErr_Occurred()) SWIG_fail;
20319 }
20320 {
20321 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20322 }
20323 return resultobj;
20324 fail:
20325 return NULL;
20326 }
20327
20328
20329 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20330 PyObject *resultobj = 0;
20331 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20332 bool result;
20333 void *argp1 = 0 ;
20334 int res1 = 0 ;
20335 PyObject *swig_obj[1] ;
20336
20337 if (!args) SWIG_fail;
20338 swig_obj[0] = args;
20339 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20340 if (!SWIG_IsOK(res1)) {
20341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20342 }
20343 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20344 {
20345 PyThreadState* __tstate = wxPyBeginAllowThreads();
20346 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
20347 wxPyEndAllowThreads(__tstate);
20348 if (PyErr_Occurred()) SWIG_fail;
20349 }
20350 {
20351 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20352 }
20353 return resultobj;
20354 fail:
20355 return NULL;
20356 }
20357
20358
20359 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20360 PyObject *resultobj = 0;
20361 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20362 bool result;
20363 void *argp1 = 0 ;
20364 int res1 = 0 ;
20365 PyObject *swig_obj[1] ;
20366
20367 if (!args) SWIG_fail;
20368 swig_obj[0] = args;
20369 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20370 if (!SWIG_IsOK(res1)) {
20371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20372 }
20373 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20374 {
20375 PyThreadState* __tstate = wxPyBeginAllowThreads();
20376 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
20377 wxPyEndAllowThreads(__tstate);
20378 if (PyErr_Occurred()) SWIG_fail;
20379 }
20380 {
20381 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20382 }
20383 return resultobj;
20384 fail:
20385 return NULL;
20386 }
20387
20388
20389 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20390 PyObject *resultobj = 0;
20391 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20392 bool result;
20393 void *argp1 = 0 ;
20394 int res1 = 0 ;
20395 PyObject *swig_obj[1] ;
20396
20397 if (!args) SWIG_fail;
20398 swig_obj[0] = args;
20399 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20400 if (!SWIG_IsOK(res1)) {
20401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20402 }
20403 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20404 {
20405 PyThreadState* __tstate = wxPyBeginAllowThreads();
20406 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
20407 wxPyEndAllowThreads(__tstate);
20408 if (PyErr_Occurred()) SWIG_fail;
20409 }
20410 {
20411 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20412 }
20413 return resultobj;
20414 fail:
20415 return NULL;
20416 }
20417
20418
20419 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20420 PyObject *resultobj = 0;
20421 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20422 bool result;
20423 void *argp1 = 0 ;
20424 int res1 = 0 ;
20425 PyObject *swig_obj[1] ;
20426
20427 if (!args) SWIG_fail;
20428 swig_obj[0] = args;
20429 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20430 if (!SWIG_IsOK(res1)) {
20431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20432 }
20433 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20434 {
20435 PyThreadState* __tstate = wxPyBeginAllowThreads();
20436 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
20437 wxPyEndAllowThreads(__tstate);
20438 if (PyErr_Occurred()) SWIG_fail;
20439 }
20440 {
20441 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20442 }
20443 return resultobj;
20444 fail:
20445 return NULL;
20446 }
20447
20448
20449 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20450 PyObject *resultobj = 0;
20451 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20452 bool result;
20453 void *argp1 = 0 ;
20454 int res1 = 0 ;
20455 PyObject *swig_obj[1] ;
20456
20457 if (!args) SWIG_fail;
20458 swig_obj[0] = args;
20459 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20460 if (!SWIG_IsOK(res1)) {
20461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20462 }
20463 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20464 {
20465 PyThreadState* __tstate = wxPyBeginAllowThreads();
20466 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
20467 wxPyEndAllowThreads(__tstate);
20468 if (PyErr_Occurred()) SWIG_fail;
20469 }
20470 {
20471 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20472 }
20473 return resultobj;
20474 fail:
20475 return NULL;
20476 }
20477
20478
20479 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20480 PyObject *resultobj = 0;
20481 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20482 bool result;
20483 void *argp1 = 0 ;
20484 int res1 = 0 ;
20485 PyObject *swig_obj[1] ;
20486
20487 if (!args) SWIG_fail;
20488 swig_obj[0] = args;
20489 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20490 if (!SWIG_IsOK(res1)) {
20491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20492 }
20493 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20494 {
20495 PyThreadState* __tstate = wxPyBeginAllowThreads();
20496 result = (bool)(arg1)->LeftIsDown();
20497 wxPyEndAllowThreads(__tstate);
20498 if (PyErr_Occurred()) SWIG_fail;
20499 }
20500 {
20501 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20502 }
20503 return resultobj;
20504 fail:
20505 return NULL;
20506 }
20507
20508
20509 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20510 PyObject *resultobj = 0;
20511 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20512 bool result;
20513 void *argp1 = 0 ;
20514 int res1 = 0 ;
20515 PyObject *swig_obj[1] ;
20516
20517 if (!args) SWIG_fail;
20518 swig_obj[0] = args;
20519 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20520 if (!SWIG_IsOK(res1)) {
20521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20522 }
20523 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20524 {
20525 PyThreadState* __tstate = wxPyBeginAllowThreads();
20526 result = (bool)(arg1)->MiddleIsDown();
20527 wxPyEndAllowThreads(__tstate);
20528 if (PyErr_Occurred()) SWIG_fail;
20529 }
20530 {
20531 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20532 }
20533 return resultobj;
20534 fail:
20535 return NULL;
20536 }
20537
20538
20539 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20540 PyObject *resultobj = 0;
20541 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20542 bool result;
20543 void *argp1 = 0 ;
20544 int res1 = 0 ;
20545 PyObject *swig_obj[1] ;
20546
20547 if (!args) SWIG_fail;
20548 swig_obj[0] = args;
20549 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20550 if (!SWIG_IsOK(res1)) {
20551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20552 }
20553 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20554 {
20555 PyThreadState* __tstate = wxPyBeginAllowThreads();
20556 result = (bool)(arg1)->RightIsDown();
20557 wxPyEndAllowThreads(__tstate);
20558 if (PyErr_Occurred()) SWIG_fail;
20559 }
20560 {
20561 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20562 }
20563 return resultobj;
20564 fail:
20565 return NULL;
20566 }
20567
20568
20569 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20570 PyObject *resultobj = 0;
20571 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20572 bool result;
20573 void *argp1 = 0 ;
20574 int res1 = 0 ;
20575 PyObject *swig_obj[1] ;
20576
20577 if (!args) SWIG_fail;
20578 swig_obj[0] = args;
20579 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20580 if (!SWIG_IsOK(res1)) {
20581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20582 }
20583 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20584 {
20585 PyThreadState* __tstate = wxPyBeginAllowThreads();
20586 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
20587 wxPyEndAllowThreads(__tstate);
20588 if (PyErr_Occurred()) SWIG_fail;
20589 }
20590 {
20591 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20592 }
20593 return resultobj;
20594 fail:
20595 return NULL;
20596 }
20597
20598
20599 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20600 PyObject *resultobj = 0;
20601 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20602 bool result;
20603 void *argp1 = 0 ;
20604 int res1 = 0 ;
20605 PyObject *swig_obj[1] ;
20606
20607 if (!args) SWIG_fail;
20608 swig_obj[0] = args;
20609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20610 if (!SWIG_IsOK(res1)) {
20611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20612 }
20613 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20614 {
20615 PyThreadState* __tstate = wxPyBeginAllowThreads();
20616 result = (bool)((wxMouseEvent const *)arg1)->Moving();
20617 wxPyEndAllowThreads(__tstate);
20618 if (PyErr_Occurred()) SWIG_fail;
20619 }
20620 {
20621 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20622 }
20623 return resultobj;
20624 fail:
20625 return NULL;
20626 }
20627
20628
20629 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20630 PyObject *resultobj = 0;
20631 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20632 bool result;
20633 void *argp1 = 0 ;
20634 int res1 = 0 ;
20635 PyObject *swig_obj[1] ;
20636
20637 if (!args) SWIG_fail;
20638 swig_obj[0] = args;
20639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20640 if (!SWIG_IsOK(res1)) {
20641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20642 }
20643 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20644 {
20645 PyThreadState* __tstate = wxPyBeginAllowThreads();
20646 result = (bool)((wxMouseEvent const *)arg1)->Entering();
20647 wxPyEndAllowThreads(__tstate);
20648 if (PyErr_Occurred()) SWIG_fail;
20649 }
20650 {
20651 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20652 }
20653 return resultobj;
20654 fail:
20655 return NULL;
20656 }
20657
20658
20659 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20660 PyObject *resultobj = 0;
20661 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20662 bool result;
20663 void *argp1 = 0 ;
20664 int res1 = 0 ;
20665 PyObject *swig_obj[1] ;
20666
20667 if (!args) SWIG_fail;
20668 swig_obj[0] = args;
20669 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20670 if (!SWIG_IsOK(res1)) {
20671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20672 }
20673 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20674 {
20675 PyThreadState* __tstate = wxPyBeginAllowThreads();
20676 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
20677 wxPyEndAllowThreads(__tstate);
20678 if (PyErr_Occurred()) SWIG_fail;
20679 }
20680 {
20681 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20682 }
20683 return resultobj;
20684 fail:
20685 return NULL;
20686 }
20687
20688
20689 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20690 PyObject *resultobj = 0;
20691 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20692 wxPoint result;
20693 void *argp1 = 0 ;
20694 int res1 = 0 ;
20695 PyObject *swig_obj[1] ;
20696
20697 if (!args) SWIG_fail;
20698 swig_obj[0] = args;
20699 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20700 if (!SWIG_IsOK(res1)) {
20701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20702 }
20703 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20704 {
20705 PyThreadState* __tstate = wxPyBeginAllowThreads();
20706 result = (arg1)->GetPosition();
20707 wxPyEndAllowThreads(__tstate);
20708 if (PyErr_Occurred()) SWIG_fail;
20709 }
20710 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20711 return resultobj;
20712 fail:
20713 return NULL;
20714 }
20715
20716
20717 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20718 PyObject *resultobj = 0;
20719 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20720 long *arg2 = (long *) 0 ;
20721 long *arg3 = (long *) 0 ;
20722 void *argp1 = 0 ;
20723 int res1 = 0 ;
20724 long temp2 ;
20725 int res2 = SWIG_TMPOBJ ;
20726 long temp3 ;
20727 int res3 = SWIG_TMPOBJ ;
20728 PyObject *swig_obj[1] ;
20729
20730 arg2 = &temp2;
20731 arg3 = &temp3;
20732 if (!args) SWIG_fail;
20733 swig_obj[0] = args;
20734 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20735 if (!SWIG_IsOK(res1)) {
20736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20737 }
20738 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20739 {
20740 PyThreadState* __tstate = wxPyBeginAllowThreads();
20741 (arg1)->GetPosition(arg2,arg3);
20742 wxPyEndAllowThreads(__tstate);
20743 if (PyErr_Occurred()) SWIG_fail;
20744 }
20745 resultobj = SWIG_Py_Void();
20746 if (SWIG_IsTmpObj(res2)) {
20747 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
20748 } else {
20749 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20750 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
20751 }
20752 if (SWIG_IsTmpObj(res3)) {
20753 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
20754 } else {
20755 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20756 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
20757 }
20758 return resultobj;
20759 fail:
20760 return NULL;
20761 }
20762
20763
20764 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20765 PyObject *resultobj = 0;
20766 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20767 wxDC *arg2 = 0 ;
20768 wxPoint result;
20769 void *argp1 = 0 ;
20770 int res1 = 0 ;
20771 void *argp2 = 0 ;
20772 int res2 = 0 ;
20773 PyObject * obj0 = 0 ;
20774 PyObject * obj1 = 0 ;
20775 char * kwnames[] = {
20776 (char *) "self",(char *) "dc", NULL
20777 };
20778
20779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
20780 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20781 if (!SWIG_IsOK(res1)) {
20782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20783 }
20784 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20785 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
20786 if (!SWIG_IsOK(res2)) {
20787 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
20788 }
20789 if (!argp2) {
20790 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
20791 }
20792 arg2 = reinterpret_cast< wxDC * >(argp2);
20793 {
20794 PyThreadState* __tstate = wxPyBeginAllowThreads();
20795 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
20796 wxPyEndAllowThreads(__tstate);
20797 if (PyErr_Occurred()) SWIG_fail;
20798 }
20799 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20800 return resultobj;
20801 fail:
20802 return NULL;
20803 }
20804
20805
20806 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20807 PyObject *resultobj = 0;
20808 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20809 int result;
20810 void *argp1 = 0 ;
20811 int res1 = 0 ;
20812 PyObject *swig_obj[1] ;
20813
20814 if (!args) SWIG_fail;
20815 swig_obj[0] = args;
20816 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20817 if (!SWIG_IsOK(res1)) {
20818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20819 }
20820 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20821 {
20822 PyThreadState* __tstate = wxPyBeginAllowThreads();
20823 result = (int)((wxMouseEvent const *)arg1)->GetX();
20824 wxPyEndAllowThreads(__tstate);
20825 if (PyErr_Occurred()) SWIG_fail;
20826 }
20827 resultobj = SWIG_From_int(static_cast< int >(result));
20828 return resultobj;
20829 fail:
20830 return NULL;
20831 }
20832
20833
20834 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20835 PyObject *resultobj = 0;
20836 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20837 int result;
20838 void *argp1 = 0 ;
20839 int res1 = 0 ;
20840 PyObject *swig_obj[1] ;
20841
20842 if (!args) SWIG_fail;
20843 swig_obj[0] = args;
20844 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20845 if (!SWIG_IsOK(res1)) {
20846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20847 }
20848 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20849 {
20850 PyThreadState* __tstate = wxPyBeginAllowThreads();
20851 result = (int)((wxMouseEvent const *)arg1)->GetY();
20852 wxPyEndAllowThreads(__tstate);
20853 if (PyErr_Occurred()) SWIG_fail;
20854 }
20855 resultobj = SWIG_From_int(static_cast< int >(result));
20856 return resultobj;
20857 fail:
20858 return NULL;
20859 }
20860
20861
20862 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20863 PyObject *resultobj = 0;
20864 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20865 int result;
20866 void *argp1 = 0 ;
20867 int res1 = 0 ;
20868 PyObject *swig_obj[1] ;
20869
20870 if (!args) SWIG_fail;
20871 swig_obj[0] = args;
20872 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20873 if (!SWIG_IsOK(res1)) {
20874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20875 }
20876 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20877 {
20878 PyThreadState* __tstate = wxPyBeginAllowThreads();
20879 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
20880 wxPyEndAllowThreads(__tstate);
20881 if (PyErr_Occurred()) SWIG_fail;
20882 }
20883 resultobj = SWIG_From_int(static_cast< int >(result));
20884 return resultobj;
20885 fail:
20886 return NULL;
20887 }
20888
20889
20890 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20891 PyObject *resultobj = 0;
20892 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20893 int result;
20894 void *argp1 = 0 ;
20895 int res1 = 0 ;
20896 PyObject *swig_obj[1] ;
20897
20898 if (!args) SWIG_fail;
20899 swig_obj[0] = args;
20900 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20901 if (!SWIG_IsOK(res1)) {
20902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20903 }
20904 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20905 {
20906 PyThreadState* __tstate = wxPyBeginAllowThreads();
20907 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
20908 wxPyEndAllowThreads(__tstate);
20909 if (PyErr_Occurred()) SWIG_fail;
20910 }
20911 resultobj = SWIG_From_int(static_cast< int >(result));
20912 return resultobj;
20913 fail:
20914 return NULL;
20915 }
20916
20917
20918 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20919 PyObject *resultobj = 0;
20920 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20921 int result;
20922 void *argp1 = 0 ;
20923 int res1 = 0 ;
20924 PyObject *swig_obj[1] ;
20925
20926 if (!args) SWIG_fail;
20927 swig_obj[0] = args;
20928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20929 if (!SWIG_IsOK(res1)) {
20930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20931 }
20932 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20933 {
20934 PyThreadState* __tstate = wxPyBeginAllowThreads();
20935 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
20936 wxPyEndAllowThreads(__tstate);
20937 if (PyErr_Occurred()) SWIG_fail;
20938 }
20939 resultobj = SWIG_From_int(static_cast< int >(result));
20940 return resultobj;
20941 fail:
20942 return NULL;
20943 }
20944
20945
20946 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20947 PyObject *resultobj = 0;
20948 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20949 bool result;
20950 void *argp1 = 0 ;
20951 int res1 = 0 ;
20952 PyObject *swig_obj[1] ;
20953
20954 if (!args) SWIG_fail;
20955 swig_obj[0] = args;
20956 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20957 if (!SWIG_IsOK(res1)) {
20958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20959 }
20960 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20961 {
20962 PyThreadState* __tstate = wxPyBeginAllowThreads();
20963 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
20964 wxPyEndAllowThreads(__tstate);
20965 if (PyErr_Occurred()) SWIG_fail;
20966 }
20967 {
20968 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20969 }
20970 return resultobj;
20971 fail:
20972 return NULL;
20973 }
20974
20975
20976 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20977 PyObject *resultobj = 0;
20978 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20979 int arg2 ;
20980 void *argp1 = 0 ;
20981 int res1 = 0 ;
20982 int val2 ;
20983 int ecode2 = 0 ;
20984 PyObject *swig_obj[2] ;
20985
20986 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
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_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20990 }
20991 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20992 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
20993 if (!SWIG_IsOK(ecode2)) {
20994 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
20995 }
20996 arg2 = static_cast< int >(val2);
20997 if (arg1) (arg1)->m_x = arg2;
20998
20999 resultobj = SWIG_Py_Void();
21000 return resultobj;
21001 fail:
21002 return NULL;
21003 }
21004
21005
21006 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21007 PyObject *resultobj = 0;
21008 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21009 int result;
21010 void *argp1 = 0 ;
21011 int res1 = 0 ;
21012 PyObject *swig_obj[1] ;
21013
21014 if (!args) SWIG_fail;
21015 swig_obj[0] = args;
21016 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21017 if (!SWIG_IsOK(res1)) {
21018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21019 }
21020 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21021 result = (int) ((arg1)->m_x);
21022 resultobj = SWIG_From_int(static_cast< int >(result));
21023 return resultobj;
21024 fail:
21025 return NULL;
21026 }
21027
21028
21029 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21030 PyObject *resultobj = 0;
21031 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21032 int arg2 ;
21033 void *argp1 = 0 ;
21034 int res1 = 0 ;
21035 int val2 ;
21036 int ecode2 = 0 ;
21037 PyObject *swig_obj[2] ;
21038
21039 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
21040 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21041 if (!SWIG_IsOK(res1)) {
21042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21043 }
21044 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21045 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21046 if (!SWIG_IsOK(ecode2)) {
21047 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
21048 }
21049 arg2 = static_cast< int >(val2);
21050 if (arg1) (arg1)->m_y = arg2;
21051
21052 resultobj = SWIG_Py_Void();
21053 return resultobj;
21054 fail:
21055 return NULL;
21056 }
21057
21058
21059 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21060 PyObject *resultobj = 0;
21061 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21062 int result;
21063 void *argp1 = 0 ;
21064 int res1 = 0 ;
21065 PyObject *swig_obj[1] ;
21066
21067 if (!args) SWIG_fail;
21068 swig_obj[0] = args;
21069 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21070 if (!SWIG_IsOK(res1)) {
21071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21072 }
21073 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21074 result = (int) ((arg1)->m_y);
21075 resultobj = SWIG_From_int(static_cast< int >(result));
21076 return resultobj;
21077 fail:
21078 return NULL;
21079 }
21080
21081
21082 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21083 PyObject *resultobj = 0;
21084 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21085 bool arg2 ;
21086 void *argp1 = 0 ;
21087 int res1 = 0 ;
21088 bool val2 ;
21089 int ecode2 = 0 ;
21090 PyObject *swig_obj[2] ;
21091
21092 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
21093 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21094 if (!SWIG_IsOK(res1)) {
21095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21096 }
21097 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21098 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21099 if (!SWIG_IsOK(ecode2)) {
21100 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
21101 }
21102 arg2 = static_cast< bool >(val2);
21103 if (arg1) (arg1)->m_leftDown = arg2;
21104
21105 resultobj = SWIG_Py_Void();
21106 return resultobj;
21107 fail:
21108 return NULL;
21109 }
21110
21111
21112 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21113 PyObject *resultobj = 0;
21114 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21115 bool result;
21116 void *argp1 = 0 ;
21117 int res1 = 0 ;
21118 PyObject *swig_obj[1] ;
21119
21120 if (!args) SWIG_fail;
21121 swig_obj[0] = args;
21122 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21123 if (!SWIG_IsOK(res1)) {
21124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21125 }
21126 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21127 result = (bool) ((arg1)->m_leftDown);
21128 {
21129 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21130 }
21131 return resultobj;
21132 fail:
21133 return NULL;
21134 }
21135
21136
21137 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21138 PyObject *resultobj = 0;
21139 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21140 bool arg2 ;
21141 void *argp1 = 0 ;
21142 int res1 = 0 ;
21143 bool val2 ;
21144 int ecode2 = 0 ;
21145 PyObject *swig_obj[2] ;
21146
21147 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
21148 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21149 if (!SWIG_IsOK(res1)) {
21150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21151 }
21152 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21153 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21154 if (!SWIG_IsOK(ecode2)) {
21155 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
21156 }
21157 arg2 = static_cast< bool >(val2);
21158 if (arg1) (arg1)->m_middleDown = arg2;
21159
21160 resultobj = SWIG_Py_Void();
21161 return resultobj;
21162 fail:
21163 return NULL;
21164 }
21165
21166
21167 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21168 PyObject *resultobj = 0;
21169 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21170 bool result;
21171 void *argp1 = 0 ;
21172 int res1 = 0 ;
21173 PyObject *swig_obj[1] ;
21174
21175 if (!args) SWIG_fail;
21176 swig_obj[0] = args;
21177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21178 if (!SWIG_IsOK(res1)) {
21179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21180 }
21181 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21182 result = (bool) ((arg1)->m_middleDown);
21183 {
21184 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21185 }
21186 return resultobj;
21187 fail:
21188 return NULL;
21189 }
21190
21191
21192 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21193 PyObject *resultobj = 0;
21194 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21195 bool arg2 ;
21196 void *argp1 = 0 ;
21197 int res1 = 0 ;
21198 bool val2 ;
21199 int ecode2 = 0 ;
21200 PyObject *swig_obj[2] ;
21201
21202 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
21203 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21204 if (!SWIG_IsOK(res1)) {
21205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21206 }
21207 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21208 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21209 if (!SWIG_IsOK(ecode2)) {
21210 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
21211 }
21212 arg2 = static_cast< bool >(val2);
21213 if (arg1) (arg1)->m_rightDown = arg2;
21214
21215 resultobj = SWIG_Py_Void();
21216 return resultobj;
21217 fail:
21218 return NULL;
21219 }
21220
21221
21222 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21223 PyObject *resultobj = 0;
21224 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21225 bool result;
21226 void *argp1 = 0 ;
21227 int res1 = 0 ;
21228 PyObject *swig_obj[1] ;
21229
21230 if (!args) SWIG_fail;
21231 swig_obj[0] = args;
21232 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21233 if (!SWIG_IsOK(res1)) {
21234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21235 }
21236 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21237 result = (bool) ((arg1)->m_rightDown);
21238 {
21239 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21240 }
21241 return resultobj;
21242 fail:
21243 return NULL;
21244 }
21245
21246
21247 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21248 PyObject *resultobj = 0;
21249 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21250 bool arg2 ;
21251 void *argp1 = 0 ;
21252 int res1 = 0 ;
21253 bool val2 ;
21254 int ecode2 = 0 ;
21255 PyObject *swig_obj[2] ;
21256
21257 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
21258 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21259 if (!SWIG_IsOK(res1)) {
21260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21261 }
21262 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21263 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21264 if (!SWIG_IsOK(ecode2)) {
21265 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
21266 }
21267 arg2 = static_cast< bool >(val2);
21268 if (arg1) (arg1)->m_controlDown = arg2;
21269
21270 resultobj = SWIG_Py_Void();
21271 return resultobj;
21272 fail:
21273 return NULL;
21274 }
21275
21276
21277 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21278 PyObject *resultobj = 0;
21279 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21280 bool result;
21281 void *argp1 = 0 ;
21282 int res1 = 0 ;
21283 PyObject *swig_obj[1] ;
21284
21285 if (!args) SWIG_fail;
21286 swig_obj[0] = args;
21287 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21288 if (!SWIG_IsOK(res1)) {
21289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21290 }
21291 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21292 result = (bool) ((arg1)->m_controlDown);
21293 {
21294 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21295 }
21296 return resultobj;
21297 fail:
21298 return NULL;
21299 }
21300
21301
21302 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21303 PyObject *resultobj = 0;
21304 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21305 bool arg2 ;
21306 void *argp1 = 0 ;
21307 int res1 = 0 ;
21308 bool val2 ;
21309 int ecode2 = 0 ;
21310 PyObject *swig_obj[2] ;
21311
21312 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
21313 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21314 if (!SWIG_IsOK(res1)) {
21315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21316 }
21317 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21318 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21319 if (!SWIG_IsOK(ecode2)) {
21320 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
21321 }
21322 arg2 = static_cast< bool >(val2);
21323 if (arg1) (arg1)->m_shiftDown = arg2;
21324
21325 resultobj = SWIG_Py_Void();
21326 return resultobj;
21327 fail:
21328 return NULL;
21329 }
21330
21331
21332 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21333 PyObject *resultobj = 0;
21334 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21335 bool result;
21336 void *argp1 = 0 ;
21337 int res1 = 0 ;
21338 PyObject *swig_obj[1] ;
21339
21340 if (!args) SWIG_fail;
21341 swig_obj[0] = args;
21342 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21343 if (!SWIG_IsOK(res1)) {
21344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21345 }
21346 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21347 result = (bool) ((arg1)->m_shiftDown);
21348 {
21349 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21350 }
21351 return resultobj;
21352 fail:
21353 return NULL;
21354 }
21355
21356
21357 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21358 PyObject *resultobj = 0;
21359 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21360 bool arg2 ;
21361 void *argp1 = 0 ;
21362 int res1 = 0 ;
21363 bool val2 ;
21364 int ecode2 = 0 ;
21365 PyObject *swig_obj[2] ;
21366
21367 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
21368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21369 if (!SWIG_IsOK(res1)) {
21370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21371 }
21372 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21373 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21374 if (!SWIG_IsOK(ecode2)) {
21375 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
21376 }
21377 arg2 = static_cast< bool >(val2);
21378 if (arg1) (arg1)->m_altDown = arg2;
21379
21380 resultobj = SWIG_Py_Void();
21381 return resultobj;
21382 fail:
21383 return NULL;
21384 }
21385
21386
21387 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21388 PyObject *resultobj = 0;
21389 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21390 bool result;
21391 void *argp1 = 0 ;
21392 int res1 = 0 ;
21393 PyObject *swig_obj[1] ;
21394
21395 if (!args) SWIG_fail;
21396 swig_obj[0] = args;
21397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21398 if (!SWIG_IsOK(res1)) {
21399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21400 }
21401 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21402 result = (bool) ((arg1)->m_altDown);
21403 {
21404 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21405 }
21406 return resultobj;
21407 fail:
21408 return NULL;
21409 }
21410
21411
21412 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21413 PyObject *resultobj = 0;
21414 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21415 bool arg2 ;
21416 void *argp1 = 0 ;
21417 int res1 = 0 ;
21418 bool val2 ;
21419 int ecode2 = 0 ;
21420 PyObject *swig_obj[2] ;
21421
21422 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
21423 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21424 if (!SWIG_IsOK(res1)) {
21425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21426 }
21427 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21428 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21429 if (!SWIG_IsOK(ecode2)) {
21430 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
21431 }
21432 arg2 = static_cast< bool >(val2);
21433 if (arg1) (arg1)->m_metaDown = arg2;
21434
21435 resultobj = SWIG_Py_Void();
21436 return resultobj;
21437 fail:
21438 return NULL;
21439 }
21440
21441
21442 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21443 PyObject *resultobj = 0;
21444 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21445 bool result;
21446 void *argp1 = 0 ;
21447 int res1 = 0 ;
21448 PyObject *swig_obj[1] ;
21449
21450 if (!args) SWIG_fail;
21451 swig_obj[0] = args;
21452 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21453 if (!SWIG_IsOK(res1)) {
21454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21455 }
21456 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21457 result = (bool) ((arg1)->m_metaDown);
21458 {
21459 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21460 }
21461 return resultobj;
21462 fail:
21463 return NULL;
21464 }
21465
21466
21467 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21468 PyObject *resultobj = 0;
21469 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21470 int arg2 ;
21471 void *argp1 = 0 ;
21472 int res1 = 0 ;
21473 int val2 ;
21474 int ecode2 = 0 ;
21475 PyObject *swig_obj[2] ;
21476
21477 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
21478 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21479 if (!SWIG_IsOK(res1)) {
21480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21481 }
21482 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21483 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21484 if (!SWIG_IsOK(ecode2)) {
21485 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
21486 }
21487 arg2 = static_cast< int >(val2);
21488 if (arg1) (arg1)->m_wheelRotation = arg2;
21489
21490 resultobj = SWIG_Py_Void();
21491 return resultobj;
21492 fail:
21493 return NULL;
21494 }
21495
21496
21497 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21498 PyObject *resultobj = 0;
21499 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21500 int result;
21501 void *argp1 = 0 ;
21502 int res1 = 0 ;
21503 PyObject *swig_obj[1] ;
21504
21505 if (!args) SWIG_fail;
21506 swig_obj[0] = args;
21507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21508 if (!SWIG_IsOK(res1)) {
21509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21510 }
21511 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21512 result = (int) ((arg1)->m_wheelRotation);
21513 resultobj = SWIG_From_int(static_cast< int >(result));
21514 return resultobj;
21515 fail:
21516 return NULL;
21517 }
21518
21519
21520 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21521 PyObject *resultobj = 0;
21522 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21523 int arg2 ;
21524 void *argp1 = 0 ;
21525 int res1 = 0 ;
21526 int val2 ;
21527 int ecode2 = 0 ;
21528 PyObject *swig_obj[2] ;
21529
21530 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
21531 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21532 if (!SWIG_IsOK(res1)) {
21533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21534 }
21535 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21536 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21537 if (!SWIG_IsOK(ecode2)) {
21538 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
21539 }
21540 arg2 = static_cast< int >(val2);
21541 if (arg1) (arg1)->m_wheelDelta = arg2;
21542
21543 resultobj = SWIG_Py_Void();
21544 return resultobj;
21545 fail:
21546 return NULL;
21547 }
21548
21549
21550 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21551 PyObject *resultobj = 0;
21552 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21553 int result;
21554 void *argp1 = 0 ;
21555 int res1 = 0 ;
21556 PyObject *swig_obj[1] ;
21557
21558 if (!args) SWIG_fail;
21559 swig_obj[0] = args;
21560 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21561 if (!SWIG_IsOK(res1)) {
21562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21563 }
21564 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21565 result = (int) ((arg1)->m_wheelDelta);
21566 resultobj = SWIG_From_int(static_cast< int >(result));
21567 return resultobj;
21568 fail:
21569 return NULL;
21570 }
21571
21572
21573 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21574 PyObject *resultobj = 0;
21575 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21576 int arg2 ;
21577 void *argp1 = 0 ;
21578 int res1 = 0 ;
21579 int val2 ;
21580 int ecode2 = 0 ;
21581 PyObject *swig_obj[2] ;
21582
21583 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
21584 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21585 if (!SWIG_IsOK(res1)) {
21586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21587 }
21588 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21589 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21590 if (!SWIG_IsOK(ecode2)) {
21591 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
21592 }
21593 arg2 = static_cast< int >(val2);
21594 if (arg1) (arg1)->m_linesPerAction = arg2;
21595
21596 resultobj = SWIG_Py_Void();
21597 return resultobj;
21598 fail:
21599 return NULL;
21600 }
21601
21602
21603 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21604 PyObject *resultobj = 0;
21605 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21606 int result;
21607 void *argp1 = 0 ;
21608 int res1 = 0 ;
21609 PyObject *swig_obj[1] ;
21610
21611 if (!args) SWIG_fail;
21612 swig_obj[0] = args;
21613 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21614 if (!SWIG_IsOK(res1)) {
21615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21616 }
21617 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21618 result = (int) ((arg1)->m_linesPerAction);
21619 resultobj = SWIG_From_int(static_cast< int >(result));
21620 return resultobj;
21621 fail:
21622 return NULL;
21623 }
21624
21625
21626 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21627 PyObject *obj;
21628 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21629 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
21630 return SWIG_Py_Void();
21631 }
21632
21633 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21634 return SWIG_Python_InitShadowInstance(args);
21635 }
21636
21637 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21638 PyObject *resultobj = 0;
21639 int arg1 = (int) 0 ;
21640 int arg2 = (int) 0 ;
21641 wxSetCursorEvent *result = 0 ;
21642 int val1 ;
21643 int ecode1 = 0 ;
21644 int val2 ;
21645 int ecode2 = 0 ;
21646 PyObject * obj0 = 0 ;
21647 PyObject * obj1 = 0 ;
21648 char * kwnames[] = {
21649 (char *) "x",(char *) "y", NULL
21650 };
21651
21652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21653 if (obj0) {
21654 ecode1 = SWIG_AsVal_int(obj0, &val1);
21655 if (!SWIG_IsOK(ecode1)) {
21656 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
21657 }
21658 arg1 = static_cast< int >(val1);
21659 }
21660 if (obj1) {
21661 ecode2 = SWIG_AsVal_int(obj1, &val2);
21662 if (!SWIG_IsOK(ecode2)) {
21663 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
21664 }
21665 arg2 = static_cast< int >(val2);
21666 }
21667 {
21668 PyThreadState* __tstate = wxPyBeginAllowThreads();
21669 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
21670 wxPyEndAllowThreads(__tstate);
21671 if (PyErr_Occurred()) SWIG_fail;
21672 }
21673 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
21674 return resultobj;
21675 fail:
21676 return NULL;
21677 }
21678
21679
21680 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21681 PyObject *resultobj = 0;
21682 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21683 int result;
21684 void *argp1 = 0 ;
21685 int res1 = 0 ;
21686 PyObject *swig_obj[1] ;
21687
21688 if (!args) SWIG_fail;
21689 swig_obj[0] = args;
21690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21691 if (!SWIG_IsOK(res1)) {
21692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21693 }
21694 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21695 {
21696 PyThreadState* __tstate = wxPyBeginAllowThreads();
21697 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
21698 wxPyEndAllowThreads(__tstate);
21699 if (PyErr_Occurred()) SWIG_fail;
21700 }
21701 resultobj = SWIG_From_int(static_cast< int >(result));
21702 return resultobj;
21703 fail:
21704 return NULL;
21705 }
21706
21707
21708 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21709 PyObject *resultobj = 0;
21710 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21711 int result;
21712 void *argp1 = 0 ;
21713 int res1 = 0 ;
21714 PyObject *swig_obj[1] ;
21715
21716 if (!args) SWIG_fail;
21717 swig_obj[0] = args;
21718 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21719 if (!SWIG_IsOK(res1)) {
21720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21721 }
21722 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21723 {
21724 PyThreadState* __tstate = wxPyBeginAllowThreads();
21725 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
21726 wxPyEndAllowThreads(__tstate);
21727 if (PyErr_Occurred()) SWIG_fail;
21728 }
21729 resultobj = SWIG_From_int(static_cast< int >(result));
21730 return resultobj;
21731 fail:
21732 return NULL;
21733 }
21734
21735
21736 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21737 PyObject *resultobj = 0;
21738 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21739 wxCursor *arg2 = 0 ;
21740 void *argp1 = 0 ;
21741 int res1 = 0 ;
21742 void *argp2 = 0 ;
21743 int res2 = 0 ;
21744 PyObject * obj0 = 0 ;
21745 PyObject * obj1 = 0 ;
21746 char * kwnames[] = {
21747 (char *) "self",(char *) "cursor", NULL
21748 };
21749
21750 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
21751 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21752 if (!SWIG_IsOK(res1)) {
21753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
21754 }
21755 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21756 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
21757 if (!SWIG_IsOK(res2)) {
21758 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21759 }
21760 if (!argp2) {
21761 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21762 }
21763 arg2 = reinterpret_cast< wxCursor * >(argp2);
21764 {
21765 PyThreadState* __tstate = wxPyBeginAllowThreads();
21766 (arg1)->SetCursor((wxCursor const &)*arg2);
21767 wxPyEndAllowThreads(__tstate);
21768 if (PyErr_Occurred()) SWIG_fail;
21769 }
21770 resultobj = SWIG_Py_Void();
21771 return resultobj;
21772 fail:
21773 return NULL;
21774 }
21775
21776
21777 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21778 PyObject *resultobj = 0;
21779 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21780 wxCursor *result = 0 ;
21781 void *argp1 = 0 ;
21782 int res1 = 0 ;
21783 PyObject *swig_obj[1] ;
21784
21785 if (!args) SWIG_fail;
21786 swig_obj[0] = args;
21787 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21788 if (!SWIG_IsOK(res1)) {
21789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21790 }
21791 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21792 {
21793 PyThreadState* __tstate = wxPyBeginAllowThreads();
21794 {
21795 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
21796 result = (wxCursor *) &_result_ref;
21797 }
21798 wxPyEndAllowThreads(__tstate);
21799 if (PyErr_Occurred()) SWIG_fail;
21800 }
21801 {
21802 wxCursor* resultptr = new wxCursor(*result);
21803 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
21804 }
21805 return resultobj;
21806 fail:
21807 return NULL;
21808 }
21809
21810
21811 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21812 PyObject *resultobj = 0;
21813 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21814 bool result;
21815 void *argp1 = 0 ;
21816 int res1 = 0 ;
21817 PyObject *swig_obj[1] ;
21818
21819 if (!args) SWIG_fail;
21820 swig_obj[0] = args;
21821 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21822 if (!SWIG_IsOK(res1)) {
21823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21824 }
21825 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21826 {
21827 PyThreadState* __tstate = wxPyBeginAllowThreads();
21828 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
21829 wxPyEndAllowThreads(__tstate);
21830 if (PyErr_Occurred()) SWIG_fail;
21831 }
21832 {
21833 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21834 }
21835 return resultobj;
21836 fail:
21837 return NULL;
21838 }
21839
21840
21841 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21842 PyObject *obj;
21843 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21844 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
21845 return SWIG_Py_Void();
21846 }
21847
21848 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21849 return SWIG_Python_InitShadowInstance(args);
21850 }
21851
21852 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21853 PyObject *resultobj = 0;
21854 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21855 wxKeyEvent *result = 0 ;
21856 int val1 ;
21857 int ecode1 = 0 ;
21858 PyObject * obj0 = 0 ;
21859 char * kwnames[] = {
21860 (char *) "eventType", NULL
21861 };
21862
21863 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
21864 if (obj0) {
21865 ecode1 = SWIG_AsVal_int(obj0, &val1);
21866 if (!SWIG_IsOK(ecode1)) {
21867 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
21868 }
21869 arg1 = static_cast< wxEventType >(val1);
21870 }
21871 {
21872 PyThreadState* __tstate = wxPyBeginAllowThreads();
21873 result = (wxKeyEvent *)new wxKeyEvent(arg1);
21874 wxPyEndAllowThreads(__tstate);
21875 if (PyErr_Occurred()) SWIG_fail;
21876 }
21877 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
21878 return resultobj;
21879 fail:
21880 return NULL;
21881 }
21882
21883
21884 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21885 PyObject *resultobj = 0;
21886 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21887 int result;
21888 void *argp1 = 0 ;
21889 int res1 = 0 ;
21890 PyObject *swig_obj[1] ;
21891
21892 if (!args) SWIG_fail;
21893 swig_obj[0] = args;
21894 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21895 if (!SWIG_IsOK(res1)) {
21896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21897 }
21898 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21899 {
21900 PyThreadState* __tstate = wxPyBeginAllowThreads();
21901 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
21902 wxPyEndAllowThreads(__tstate);
21903 if (PyErr_Occurred()) SWIG_fail;
21904 }
21905 resultobj = SWIG_From_int(static_cast< int >(result));
21906 return resultobj;
21907 fail:
21908 return NULL;
21909 }
21910
21911
21912 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21913 PyObject *resultobj = 0;
21914 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21915 bool result;
21916 void *argp1 = 0 ;
21917 int res1 = 0 ;
21918 PyObject *swig_obj[1] ;
21919
21920 if (!args) SWIG_fail;
21921 swig_obj[0] = args;
21922 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21923 if (!SWIG_IsOK(res1)) {
21924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21925 }
21926 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21927 {
21928 PyThreadState* __tstate = wxPyBeginAllowThreads();
21929 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
21930 wxPyEndAllowThreads(__tstate);
21931 if (PyErr_Occurred()) SWIG_fail;
21932 }
21933 {
21934 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21935 }
21936 return resultobj;
21937 fail:
21938 return NULL;
21939 }
21940
21941
21942 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21943 PyObject *resultobj = 0;
21944 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21945 bool result;
21946 void *argp1 = 0 ;
21947 int res1 = 0 ;
21948 PyObject *swig_obj[1] ;
21949
21950 if (!args) SWIG_fail;
21951 swig_obj[0] = args;
21952 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21953 if (!SWIG_IsOK(res1)) {
21954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21955 }
21956 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21957 {
21958 PyThreadState* __tstate = wxPyBeginAllowThreads();
21959 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
21960 wxPyEndAllowThreads(__tstate);
21961 if (PyErr_Occurred()) SWIG_fail;
21962 }
21963 {
21964 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21965 }
21966 return resultobj;
21967 fail:
21968 return NULL;
21969 }
21970
21971
21972 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21973 PyObject *resultobj = 0;
21974 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21975 bool result;
21976 void *argp1 = 0 ;
21977 int res1 = 0 ;
21978 PyObject *swig_obj[1] ;
21979
21980 if (!args) SWIG_fail;
21981 swig_obj[0] = args;
21982 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21983 if (!SWIG_IsOK(res1)) {
21984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21985 }
21986 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21987 {
21988 PyThreadState* __tstate = wxPyBeginAllowThreads();
21989 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
21990 wxPyEndAllowThreads(__tstate);
21991 if (PyErr_Occurred()) SWIG_fail;
21992 }
21993 {
21994 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21995 }
21996 return resultobj;
21997 fail:
21998 return NULL;
21999 }
22000
22001
22002 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22003 PyObject *resultobj = 0;
22004 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22005 bool result;
22006 void *argp1 = 0 ;
22007 int res1 = 0 ;
22008 PyObject *swig_obj[1] ;
22009
22010 if (!args) SWIG_fail;
22011 swig_obj[0] = args;
22012 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22013 if (!SWIG_IsOK(res1)) {
22014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22015 }
22016 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22017 {
22018 PyThreadState* __tstate = wxPyBeginAllowThreads();
22019 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
22020 wxPyEndAllowThreads(__tstate);
22021 if (PyErr_Occurred()) SWIG_fail;
22022 }
22023 {
22024 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22025 }
22026 return resultobj;
22027 fail:
22028 return NULL;
22029 }
22030
22031
22032 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22033 PyObject *resultobj = 0;
22034 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22035 bool result;
22036 void *argp1 = 0 ;
22037 int res1 = 0 ;
22038 PyObject *swig_obj[1] ;
22039
22040 if (!args) SWIG_fail;
22041 swig_obj[0] = args;
22042 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22043 if (!SWIG_IsOK(res1)) {
22044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22045 }
22046 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22047 {
22048 PyThreadState* __tstate = wxPyBeginAllowThreads();
22049 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
22050 wxPyEndAllowThreads(__tstate);
22051 if (PyErr_Occurred()) SWIG_fail;
22052 }
22053 {
22054 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22055 }
22056 return resultobj;
22057 fail:
22058 return NULL;
22059 }
22060
22061
22062 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22063 PyObject *resultobj = 0;
22064 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22065 bool result;
22066 void *argp1 = 0 ;
22067 int res1 = 0 ;
22068 PyObject *swig_obj[1] ;
22069
22070 if (!args) SWIG_fail;
22071 swig_obj[0] = args;
22072 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22073 if (!SWIG_IsOK(res1)) {
22074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22075 }
22076 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22077 {
22078 PyThreadState* __tstate = wxPyBeginAllowThreads();
22079 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
22080 wxPyEndAllowThreads(__tstate);
22081 if (PyErr_Occurred()) SWIG_fail;
22082 }
22083 {
22084 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22085 }
22086 return resultobj;
22087 fail:
22088 return NULL;
22089 }
22090
22091
22092 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22093 PyObject *resultobj = 0;
22094 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22095 int result;
22096 void *argp1 = 0 ;
22097 int res1 = 0 ;
22098 PyObject *swig_obj[1] ;
22099
22100 if (!args) SWIG_fail;
22101 swig_obj[0] = args;
22102 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22103 if (!SWIG_IsOK(res1)) {
22104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22105 }
22106 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22107 {
22108 PyThreadState* __tstate = wxPyBeginAllowThreads();
22109 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
22110 wxPyEndAllowThreads(__tstate);
22111 if (PyErr_Occurred()) SWIG_fail;
22112 }
22113 resultobj = SWIG_From_int(static_cast< int >(result));
22114 return resultobj;
22115 fail:
22116 return NULL;
22117 }
22118
22119
22120 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22121 PyObject *resultobj = 0;
22122 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22123 int result;
22124 void *argp1 = 0 ;
22125 int res1 = 0 ;
22126 PyObject *swig_obj[1] ;
22127
22128 if (!args) SWIG_fail;
22129 swig_obj[0] = args;
22130 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22131 if (!SWIG_IsOK(res1)) {
22132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22133 }
22134 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22135 {
22136 PyThreadState* __tstate = wxPyBeginAllowThreads();
22137 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
22138 wxPyEndAllowThreads(__tstate);
22139 if (PyErr_Occurred()) SWIG_fail;
22140 }
22141 resultobj = SWIG_From_int(static_cast< int >(result));
22142 return resultobj;
22143 fail:
22144 return NULL;
22145 }
22146
22147
22148 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22149 PyObject *resultobj = 0;
22150 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22151 unsigned int result;
22152 void *argp1 = 0 ;
22153 int res1 = 0 ;
22154 PyObject *swig_obj[1] ;
22155
22156 if (!args) SWIG_fail;
22157 swig_obj[0] = args;
22158 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22159 if (!SWIG_IsOK(res1)) {
22160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22161 }
22162 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22163 {
22164 PyThreadState* __tstate = wxPyBeginAllowThreads();
22165 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
22166 wxPyEndAllowThreads(__tstate);
22167 if (PyErr_Occurred()) SWIG_fail;
22168 }
22169 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22170 return resultobj;
22171 fail:
22172 return NULL;
22173 }
22174
22175
22176 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22177 PyObject *resultobj = 0;
22178 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22179 unsigned int result;
22180 void *argp1 = 0 ;
22181 int res1 = 0 ;
22182 PyObject *swig_obj[1] ;
22183
22184 if (!args) SWIG_fail;
22185 swig_obj[0] = args;
22186 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22187 if (!SWIG_IsOK(res1)) {
22188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22189 }
22190 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22191 {
22192 PyThreadState* __tstate = wxPyBeginAllowThreads();
22193 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
22194 wxPyEndAllowThreads(__tstate);
22195 if (PyErr_Occurred()) SWIG_fail;
22196 }
22197 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22198 return resultobj;
22199 fail:
22200 return NULL;
22201 }
22202
22203
22204 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22205 PyObject *resultobj = 0;
22206 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22207 wxPoint result;
22208 void *argp1 = 0 ;
22209 int res1 = 0 ;
22210 PyObject *swig_obj[1] ;
22211
22212 if (!args) SWIG_fail;
22213 swig_obj[0] = args;
22214 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22215 if (!SWIG_IsOK(res1)) {
22216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22217 }
22218 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22219 {
22220 PyThreadState* __tstate = wxPyBeginAllowThreads();
22221 result = (arg1)->GetPosition();
22222 wxPyEndAllowThreads(__tstate);
22223 if (PyErr_Occurred()) SWIG_fail;
22224 }
22225 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
22226 return resultobj;
22227 fail:
22228 return NULL;
22229 }
22230
22231
22232 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22233 PyObject *resultobj = 0;
22234 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22235 long *arg2 = (long *) 0 ;
22236 long *arg3 = (long *) 0 ;
22237 void *argp1 = 0 ;
22238 int res1 = 0 ;
22239 long temp2 ;
22240 int res2 = SWIG_TMPOBJ ;
22241 long temp3 ;
22242 int res3 = SWIG_TMPOBJ ;
22243 PyObject *swig_obj[1] ;
22244
22245 arg2 = &temp2;
22246 arg3 = &temp3;
22247 if (!args) SWIG_fail;
22248 swig_obj[0] = args;
22249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22250 if (!SWIG_IsOK(res1)) {
22251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22252 }
22253 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22254 {
22255 PyThreadState* __tstate = wxPyBeginAllowThreads();
22256 (arg1)->GetPosition(arg2,arg3);
22257 wxPyEndAllowThreads(__tstate);
22258 if (PyErr_Occurred()) SWIG_fail;
22259 }
22260 resultobj = SWIG_Py_Void();
22261 if (SWIG_IsTmpObj(res2)) {
22262 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
22263 } else {
22264 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22265 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
22266 }
22267 if (SWIG_IsTmpObj(res3)) {
22268 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
22269 } else {
22270 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22271 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
22272 }
22273 return resultobj;
22274 fail:
22275 return NULL;
22276 }
22277
22278
22279 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22280 PyObject *resultobj = 0;
22281 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22282 int result;
22283 void *argp1 = 0 ;
22284 int res1 = 0 ;
22285 PyObject *swig_obj[1] ;
22286
22287 if (!args) SWIG_fail;
22288 swig_obj[0] = args;
22289 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22290 if (!SWIG_IsOK(res1)) {
22291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22292 }
22293 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22294 {
22295 PyThreadState* __tstate = wxPyBeginAllowThreads();
22296 result = (int)((wxKeyEvent const *)arg1)->GetX();
22297 wxPyEndAllowThreads(__tstate);
22298 if (PyErr_Occurred()) SWIG_fail;
22299 }
22300 resultobj = SWIG_From_int(static_cast< int >(result));
22301 return resultobj;
22302 fail:
22303 return NULL;
22304 }
22305
22306
22307 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22308 PyObject *resultobj = 0;
22309 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22310 int result;
22311 void *argp1 = 0 ;
22312 int res1 = 0 ;
22313 PyObject *swig_obj[1] ;
22314
22315 if (!args) SWIG_fail;
22316 swig_obj[0] = args;
22317 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22318 if (!SWIG_IsOK(res1)) {
22319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22320 }
22321 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22322 {
22323 PyThreadState* __tstate = wxPyBeginAllowThreads();
22324 result = (int)((wxKeyEvent const *)arg1)->GetY();
22325 wxPyEndAllowThreads(__tstate);
22326 if (PyErr_Occurred()) SWIG_fail;
22327 }
22328 resultobj = SWIG_From_int(static_cast< int >(result));
22329 return resultobj;
22330 fail:
22331 return NULL;
22332 }
22333
22334
22335 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22336 PyObject *resultobj = 0;
22337 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22338 int arg2 ;
22339 void *argp1 = 0 ;
22340 int res1 = 0 ;
22341 int val2 ;
22342 int ecode2 = 0 ;
22343 PyObject *swig_obj[2] ;
22344
22345 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
22346 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22347 if (!SWIG_IsOK(res1)) {
22348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22349 }
22350 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22351 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22352 if (!SWIG_IsOK(ecode2)) {
22353 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
22354 }
22355 arg2 = static_cast< int >(val2);
22356 if (arg1) (arg1)->m_x = arg2;
22357
22358 resultobj = SWIG_Py_Void();
22359 return resultobj;
22360 fail:
22361 return NULL;
22362 }
22363
22364
22365 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22366 PyObject *resultobj = 0;
22367 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22368 int result;
22369 void *argp1 = 0 ;
22370 int res1 = 0 ;
22371 PyObject *swig_obj[1] ;
22372
22373 if (!args) SWIG_fail;
22374 swig_obj[0] = args;
22375 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22376 if (!SWIG_IsOK(res1)) {
22377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22378 }
22379 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22380 result = (int) ((arg1)->m_x);
22381 resultobj = SWIG_From_int(static_cast< int >(result));
22382 return resultobj;
22383 fail:
22384 return NULL;
22385 }
22386
22387
22388 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22389 PyObject *resultobj = 0;
22390 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22391 int arg2 ;
22392 void *argp1 = 0 ;
22393 int res1 = 0 ;
22394 int val2 ;
22395 int ecode2 = 0 ;
22396 PyObject *swig_obj[2] ;
22397
22398 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
22399 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22400 if (!SWIG_IsOK(res1)) {
22401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22402 }
22403 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22404 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22405 if (!SWIG_IsOK(ecode2)) {
22406 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
22407 }
22408 arg2 = static_cast< int >(val2);
22409 if (arg1) (arg1)->m_y = arg2;
22410
22411 resultobj = SWIG_Py_Void();
22412 return resultobj;
22413 fail:
22414 return NULL;
22415 }
22416
22417
22418 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22419 PyObject *resultobj = 0;
22420 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22421 int result;
22422 void *argp1 = 0 ;
22423 int res1 = 0 ;
22424 PyObject *swig_obj[1] ;
22425
22426 if (!args) SWIG_fail;
22427 swig_obj[0] = args;
22428 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22429 if (!SWIG_IsOK(res1)) {
22430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22431 }
22432 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22433 result = (int) ((arg1)->m_y);
22434 resultobj = SWIG_From_int(static_cast< int >(result));
22435 return resultobj;
22436 fail:
22437 return NULL;
22438 }
22439
22440
22441 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22442 PyObject *resultobj = 0;
22443 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22444 long arg2 ;
22445 void *argp1 = 0 ;
22446 int res1 = 0 ;
22447 long val2 ;
22448 int ecode2 = 0 ;
22449 PyObject *swig_obj[2] ;
22450
22451 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
22452 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22453 if (!SWIG_IsOK(res1)) {
22454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22455 }
22456 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22457 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
22458 if (!SWIG_IsOK(ecode2)) {
22459 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
22460 }
22461 arg2 = static_cast< long >(val2);
22462 if (arg1) (arg1)->m_keyCode = arg2;
22463
22464 resultobj = SWIG_Py_Void();
22465 return resultobj;
22466 fail:
22467 return NULL;
22468 }
22469
22470
22471 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22472 PyObject *resultobj = 0;
22473 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22474 long result;
22475 void *argp1 = 0 ;
22476 int res1 = 0 ;
22477 PyObject *swig_obj[1] ;
22478
22479 if (!args) SWIG_fail;
22480 swig_obj[0] = args;
22481 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22482 if (!SWIG_IsOK(res1)) {
22483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22484 }
22485 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22486 result = (long) ((arg1)->m_keyCode);
22487 resultobj = SWIG_From_long(static_cast< long >(result));
22488 return resultobj;
22489 fail:
22490 return NULL;
22491 }
22492
22493
22494 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22495 PyObject *resultobj = 0;
22496 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22497 bool arg2 ;
22498 void *argp1 = 0 ;
22499 int res1 = 0 ;
22500 bool val2 ;
22501 int ecode2 = 0 ;
22502 PyObject *swig_obj[2] ;
22503
22504 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
22505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22506 if (!SWIG_IsOK(res1)) {
22507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22508 }
22509 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22510 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22511 if (!SWIG_IsOK(ecode2)) {
22512 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
22513 }
22514 arg2 = static_cast< bool >(val2);
22515 if (arg1) (arg1)->m_controlDown = arg2;
22516
22517 resultobj = SWIG_Py_Void();
22518 return resultobj;
22519 fail:
22520 return NULL;
22521 }
22522
22523
22524 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22525 PyObject *resultobj = 0;
22526 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22527 bool result;
22528 void *argp1 = 0 ;
22529 int res1 = 0 ;
22530 PyObject *swig_obj[1] ;
22531
22532 if (!args) SWIG_fail;
22533 swig_obj[0] = args;
22534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22535 if (!SWIG_IsOK(res1)) {
22536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22537 }
22538 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22539 result = (bool) ((arg1)->m_controlDown);
22540 {
22541 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22542 }
22543 return resultobj;
22544 fail:
22545 return NULL;
22546 }
22547
22548
22549 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22550 PyObject *resultobj = 0;
22551 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22552 bool arg2 ;
22553 void *argp1 = 0 ;
22554 int res1 = 0 ;
22555 bool val2 ;
22556 int ecode2 = 0 ;
22557 PyObject *swig_obj[2] ;
22558
22559 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
22560 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22561 if (!SWIG_IsOK(res1)) {
22562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22563 }
22564 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22565 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22566 if (!SWIG_IsOK(ecode2)) {
22567 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
22568 }
22569 arg2 = static_cast< bool >(val2);
22570 if (arg1) (arg1)->m_shiftDown = arg2;
22571
22572 resultobj = SWIG_Py_Void();
22573 return resultobj;
22574 fail:
22575 return NULL;
22576 }
22577
22578
22579 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22580 PyObject *resultobj = 0;
22581 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22582 bool result;
22583 void *argp1 = 0 ;
22584 int res1 = 0 ;
22585 PyObject *swig_obj[1] ;
22586
22587 if (!args) SWIG_fail;
22588 swig_obj[0] = args;
22589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22590 if (!SWIG_IsOK(res1)) {
22591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22592 }
22593 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22594 result = (bool) ((arg1)->m_shiftDown);
22595 {
22596 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22597 }
22598 return resultobj;
22599 fail:
22600 return NULL;
22601 }
22602
22603
22604 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22605 PyObject *resultobj = 0;
22606 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22607 bool arg2 ;
22608 void *argp1 = 0 ;
22609 int res1 = 0 ;
22610 bool val2 ;
22611 int ecode2 = 0 ;
22612 PyObject *swig_obj[2] ;
22613
22614 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
22615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22616 if (!SWIG_IsOK(res1)) {
22617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22618 }
22619 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22620 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22621 if (!SWIG_IsOK(ecode2)) {
22622 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
22623 }
22624 arg2 = static_cast< bool >(val2);
22625 if (arg1) (arg1)->m_altDown = arg2;
22626
22627 resultobj = SWIG_Py_Void();
22628 return resultobj;
22629 fail:
22630 return NULL;
22631 }
22632
22633
22634 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22635 PyObject *resultobj = 0;
22636 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22637 bool result;
22638 void *argp1 = 0 ;
22639 int res1 = 0 ;
22640 PyObject *swig_obj[1] ;
22641
22642 if (!args) SWIG_fail;
22643 swig_obj[0] = args;
22644 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22645 if (!SWIG_IsOK(res1)) {
22646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22647 }
22648 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22649 result = (bool) ((arg1)->m_altDown);
22650 {
22651 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22652 }
22653 return resultobj;
22654 fail:
22655 return NULL;
22656 }
22657
22658
22659 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22660 PyObject *resultobj = 0;
22661 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22662 bool arg2 ;
22663 void *argp1 = 0 ;
22664 int res1 = 0 ;
22665 bool val2 ;
22666 int ecode2 = 0 ;
22667 PyObject *swig_obj[2] ;
22668
22669 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
22670 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22671 if (!SWIG_IsOK(res1)) {
22672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22673 }
22674 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22675 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22676 if (!SWIG_IsOK(ecode2)) {
22677 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
22678 }
22679 arg2 = static_cast< bool >(val2);
22680 if (arg1) (arg1)->m_metaDown = arg2;
22681
22682 resultobj = SWIG_Py_Void();
22683 return resultobj;
22684 fail:
22685 return NULL;
22686 }
22687
22688
22689 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22690 PyObject *resultobj = 0;
22691 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22692 bool result;
22693 void *argp1 = 0 ;
22694 int res1 = 0 ;
22695 PyObject *swig_obj[1] ;
22696
22697 if (!args) SWIG_fail;
22698 swig_obj[0] = args;
22699 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22700 if (!SWIG_IsOK(res1)) {
22701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22702 }
22703 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22704 result = (bool) ((arg1)->m_metaDown);
22705 {
22706 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22707 }
22708 return resultobj;
22709 fail:
22710 return NULL;
22711 }
22712
22713
22714 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22715 PyObject *resultobj = 0;
22716 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22717 bool arg2 ;
22718 void *argp1 = 0 ;
22719 int res1 = 0 ;
22720 bool val2 ;
22721 int ecode2 = 0 ;
22722 PyObject *swig_obj[2] ;
22723
22724 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
22725 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22726 if (!SWIG_IsOK(res1)) {
22727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22728 }
22729 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22730 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22731 if (!SWIG_IsOK(ecode2)) {
22732 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
22733 }
22734 arg2 = static_cast< bool >(val2);
22735 if (arg1) (arg1)->m_scanCode = arg2;
22736
22737 resultobj = SWIG_Py_Void();
22738 return resultobj;
22739 fail:
22740 return NULL;
22741 }
22742
22743
22744 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22745 PyObject *resultobj = 0;
22746 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22747 bool result;
22748 void *argp1 = 0 ;
22749 int res1 = 0 ;
22750 PyObject *swig_obj[1] ;
22751
22752 if (!args) SWIG_fail;
22753 swig_obj[0] = args;
22754 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22755 if (!SWIG_IsOK(res1)) {
22756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22757 }
22758 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22759 result = (bool) ((arg1)->m_scanCode);
22760 {
22761 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22762 }
22763 return resultobj;
22764 fail:
22765 return NULL;
22766 }
22767
22768
22769 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22770 PyObject *resultobj = 0;
22771 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22772 unsigned int arg2 ;
22773 void *argp1 = 0 ;
22774 int res1 = 0 ;
22775 unsigned int val2 ;
22776 int ecode2 = 0 ;
22777 PyObject *swig_obj[2] ;
22778
22779 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
22780 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22781 if (!SWIG_IsOK(res1)) {
22782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22783 }
22784 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22785 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
22786 if (!SWIG_IsOK(ecode2)) {
22787 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
22788 }
22789 arg2 = static_cast< unsigned int >(val2);
22790 if (arg1) (arg1)->m_rawCode = arg2;
22791
22792 resultobj = SWIG_Py_Void();
22793 return resultobj;
22794 fail:
22795 return NULL;
22796 }
22797
22798
22799 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22800 PyObject *resultobj = 0;
22801 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22802 unsigned int result;
22803 void *argp1 = 0 ;
22804 int res1 = 0 ;
22805 PyObject *swig_obj[1] ;
22806
22807 if (!args) SWIG_fail;
22808 swig_obj[0] = args;
22809 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22810 if (!SWIG_IsOK(res1)) {
22811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22812 }
22813 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22814 result = (unsigned int) ((arg1)->m_rawCode);
22815 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22816 return resultobj;
22817 fail:
22818 return NULL;
22819 }
22820
22821
22822 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22823 PyObject *resultobj = 0;
22824 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22825 unsigned int arg2 ;
22826 void *argp1 = 0 ;
22827 int res1 = 0 ;
22828 unsigned int val2 ;
22829 int ecode2 = 0 ;
22830 PyObject *swig_obj[2] ;
22831
22832 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
22833 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22834 if (!SWIG_IsOK(res1)) {
22835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22836 }
22837 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22838 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
22839 if (!SWIG_IsOK(ecode2)) {
22840 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
22841 }
22842 arg2 = static_cast< unsigned int >(val2);
22843 if (arg1) (arg1)->m_rawFlags = arg2;
22844
22845 resultobj = SWIG_Py_Void();
22846 return resultobj;
22847 fail:
22848 return NULL;
22849 }
22850
22851
22852 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22853 PyObject *resultobj = 0;
22854 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22855 unsigned int result;
22856 void *argp1 = 0 ;
22857 int res1 = 0 ;
22858 PyObject *swig_obj[1] ;
22859
22860 if (!args) SWIG_fail;
22861 swig_obj[0] = args;
22862 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22863 if (!SWIG_IsOK(res1)) {
22864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22865 }
22866 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22867 result = (unsigned int) ((arg1)->m_rawFlags);
22868 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22869 return resultobj;
22870 fail:
22871 return NULL;
22872 }
22873
22874
22875 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22876 PyObject *obj;
22877 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22878 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
22879 return SWIG_Py_Void();
22880 }
22881
22882 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22883 return SWIG_Python_InitShadowInstance(args);
22884 }
22885
22886 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22887 PyObject *resultobj = 0;
22888 wxSize const &arg1_defvalue = wxDefaultSize ;
22889 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
22890 int arg2 = (int) 0 ;
22891 wxSizeEvent *result = 0 ;
22892 wxSize temp1 ;
22893 int val2 ;
22894 int ecode2 = 0 ;
22895 PyObject * obj0 = 0 ;
22896 PyObject * obj1 = 0 ;
22897 char * kwnames[] = {
22898 (char *) "sz",(char *) "winid", NULL
22899 };
22900
22901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
22902 if (obj0) {
22903 {
22904 arg1 = &temp1;
22905 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
22906 }
22907 }
22908 if (obj1) {
22909 ecode2 = SWIG_AsVal_int(obj1, &val2);
22910 if (!SWIG_IsOK(ecode2)) {
22911 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
22912 }
22913 arg2 = static_cast< int >(val2);
22914 }
22915 {
22916 PyThreadState* __tstate = wxPyBeginAllowThreads();
22917 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
22918 wxPyEndAllowThreads(__tstate);
22919 if (PyErr_Occurred()) SWIG_fail;
22920 }
22921 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
22922 return resultobj;
22923 fail:
22924 return NULL;
22925 }
22926
22927
22928 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22929 PyObject *resultobj = 0;
22930 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
22931 wxSize result;
22932 void *argp1 = 0 ;
22933 int res1 = 0 ;
22934 PyObject *swig_obj[1] ;
22935
22936 if (!args) SWIG_fail;
22937 swig_obj[0] = args;
22938 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
22939 if (!SWIG_IsOK(res1)) {
22940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
22941 }
22942 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
22943 {
22944 PyThreadState* __tstate = wxPyBeginAllowThreads();
22945 result = ((wxSizeEvent const *)arg1)->GetSize();
22946 wxPyEndAllowThreads(__tstate);
22947 if (PyErr_Occurred()) SWIG_fail;
22948 }
22949 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
22950 return resultobj;
22951 fail:
22952 return NULL;
22953 }
22954
22955
22956 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22957 PyObject *resultobj = 0;
22958 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
22959 wxRect result;
22960 void *argp1 = 0 ;
22961 int res1 = 0 ;
22962 PyObject *swig_obj[1] ;
22963
22964 if (!args) SWIG_fail;
22965 swig_obj[0] = args;
22966 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
22967 if (!SWIG_IsOK(res1)) {
22968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
22969 }
22970 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
22971 {
22972 PyThreadState* __tstate = wxPyBeginAllowThreads();
22973 result = ((wxSizeEvent const *)arg1)->GetRect();
22974 wxPyEndAllowThreads(__tstate);
22975 if (PyErr_Occurred()) SWIG_fail;
22976 }
22977 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
22978 return resultobj;
22979 fail:
22980 return NULL;
22981 }
22982
22983
22984 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22985 PyObject *resultobj = 0;
22986 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
22987 wxRect arg2 ;
22988 void *argp1 = 0 ;
22989 int res1 = 0 ;
22990 void *argp2 ;
22991 int res2 = 0 ;
22992 PyObject * obj0 = 0 ;
22993 PyObject * obj1 = 0 ;
22994 char * kwnames[] = {
22995 (char *) "self",(char *) "rect", NULL
22996 };
22997
22998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
22999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23000 if (!SWIG_IsOK(res1)) {
23001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23002 }
23003 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23004 {
23005 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
23006 if (!SWIG_IsOK(res2)) {
23007 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23008 }
23009 if (!argp2) {
23010 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23011 } else {
23012 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
23013 arg2 = *temp;
23014 if (SWIG_IsNewObj(res2)) delete temp;
23015 }
23016 }
23017 {
23018 PyThreadState* __tstate = wxPyBeginAllowThreads();
23019 (arg1)->SetRect(arg2);
23020 wxPyEndAllowThreads(__tstate);
23021 if (PyErr_Occurred()) SWIG_fail;
23022 }
23023 resultobj = SWIG_Py_Void();
23024 return resultobj;
23025 fail:
23026 return NULL;
23027 }
23028
23029
23030 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23031 PyObject *resultobj = 0;
23032 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23033 wxSize arg2 ;
23034 void *argp1 = 0 ;
23035 int res1 = 0 ;
23036 void *argp2 ;
23037 int res2 = 0 ;
23038 PyObject * obj0 = 0 ;
23039 PyObject * obj1 = 0 ;
23040 char * kwnames[] = {
23041 (char *) "self",(char *) "size", NULL
23042 };
23043
23044 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
23045 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23046 if (!SWIG_IsOK(res1)) {
23047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23048 }
23049 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23050 {
23051 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
23052 if (!SWIG_IsOK(res2)) {
23053 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23054 }
23055 if (!argp2) {
23056 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23057 } else {
23058 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
23059 arg2 = *temp;
23060 if (SWIG_IsNewObj(res2)) delete temp;
23061 }
23062 }
23063 {
23064 PyThreadState* __tstate = wxPyBeginAllowThreads();
23065 wxSizeEvent_SetSize(arg1,arg2);
23066 wxPyEndAllowThreads(__tstate);
23067 if (PyErr_Occurred()) SWIG_fail;
23068 }
23069 resultobj = SWIG_Py_Void();
23070 return resultobj;
23071 fail:
23072 return NULL;
23073 }
23074
23075
23076 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23077 PyObject *resultobj = 0;
23078 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23079 wxSize *arg2 = (wxSize *) 0 ;
23080 void *argp1 = 0 ;
23081 int res1 = 0 ;
23082 void *argp2 = 0 ;
23083 int res2 = 0 ;
23084 PyObject *swig_obj[2] ;
23085
23086 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
23087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23088 if (!SWIG_IsOK(res1)) {
23089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23090 }
23091 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23092 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
23093 if (!SWIG_IsOK(res2)) {
23094 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
23095 }
23096 arg2 = reinterpret_cast< wxSize * >(argp2);
23097 if (arg1) (arg1)->m_size = *arg2;
23098
23099 resultobj = SWIG_Py_Void();
23100 return resultobj;
23101 fail:
23102 return NULL;
23103 }
23104
23105
23106 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23107 PyObject *resultobj = 0;
23108 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23109 wxSize *result = 0 ;
23110 void *argp1 = 0 ;
23111 int res1 = 0 ;
23112 PyObject *swig_obj[1] ;
23113
23114 if (!args) SWIG_fail;
23115 swig_obj[0] = args;
23116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23117 if (!SWIG_IsOK(res1)) {
23118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23119 }
23120 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23121 result = (wxSize *)& ((arg1)->m_size);
23122 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
23123 return resultobj;
23124 fail:
23125 return NULL;
23126 }
23127
23128
23129 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23130 PyObject *resultobj = 0;
23131 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23132 wxRect *arg2 = (wxRect *) 0 ;
23133 void *argp1 = 0 ;
23134 int res1 = 0 ;
23135 void *argp2 = 0 ;
23136 int res2 = 0 ;
23137 PyObject *swig_obj[2] ;
23138
23139 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
23140 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23141 if (!SWIG_IsOK(res1)) {
23142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23143 }
23144 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23145 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
23146 if (!SWIG_IsOK(res2)) {
23147 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
23148 }
23149 arg2 = reinterpret_cast< wxRect * >(argp2);
23150 if (arg1) (arg1)->m_rect = *arg2;
23151
23152 resultobj = SWIG_Py_Void();
23153 return resultobj;
23154 fail:
23155 return NULL;
23156 }
23157
23158
23159 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23160 PyObject *resultobj = 0;
23161 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23162 wxRect *result = 0 ;
23163 void *argp1 = 0 ;
23164 int res1 = 0 ;
23165 PyObject *swig_obj[1] ;
23166
23167 if (!args) SWIG_fail;
23168 swig_obj[0] = args;
23169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23170 if (!SWIG_IsOK(res1)) {
23171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23172 }
23173 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23174 result = (wxRect *)& ((arg1)->m_rect);
23175 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
23176 return resultobj;
23177 fail:
23178 return NULL;
23179 }
23180
23181
23182 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23183 PyObject *obj;
23184 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23185 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
23186 return SWIG_Py_Void();
23187 }
23188
23189 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23190 return SWIG_Python_InitShadowInstance(args);
23191 }
23192
23193 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23194 PyObject *resultobj = 0;
23195 wxPoint const &arg1_defvalue = wxDefaultPosition ;
23196 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
23197 int arg2 = (int) 0 ;
23198 wxMoveEvent *result = 0 ;
23199 wxPoint temp1 ;
23200 int val2 ;
23201 int ecode2 = 0 ;
23202 PyObject * obj0 = 0 ;
23203 PyObject * obj1 = 0 ;
23204 char * kwnames[] = {
23205 (char *) "pos",(char *) "winid", NULL
23206 };
23207
23208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23209 if (obj0) {
23210 {
23211 arg1 = &temp1;
23212 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
23213 }
23214 }
23215 if (obj1) {
23216 ecode2 = SWIG_AsVal_int(obj1, &val2);
23217 if (!SWIG_IsOK(ecode2)) {
23218 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
23219 }
23220 arg2 = static_cast< int >(val2);
23221 }
23222 {
23223 PyThreadState* __tstate = wxPyBeginAllowThreads();
23224 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
23225 wxPyEndAllowThreads(__tstate);
23226 if (PyErr_Occurred()) SWIG_fail;
23227 }
23228 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
23229 return resultobj;
23230 fail:
23231 return NULL;
23232 }
23233
23234
23235 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23236 PyObject *resultobj = 0;
23237 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23238 wxPoint result;
23239 void *argp1 = 0 ;
23240 int res1 = 0 ;
23241 PyObject *swig_obj[1] ;
23242
23243 if (!args) SWIG_fail;
23244 swig_obj[0] = args;
23245 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23246 if (!SWIG_IsOK(res1)) {
23247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23248 }
23249 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23250 {
23251 PyThreadState* __tstate = wxPyBeginAllowThreads();
23252 result = ((wxMoveEvent const *)arg1)->GetPosition();
23253 wxPyEndAllowThreads(__tstate);
23254 if (PyErr_Occurred()) SWIG_fail;
23255 }
23256 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23257 return resultobj;
23258 fail:
23259 return NULL;
23260 }
23261
23262
23263 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23264 PyObject *resultobj = 0;
23265 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23266 wxRect result;
23267 void *argp1 = 0 ;
23268 int res1 = 0 ;
23269 PyObject *swig_obj[1] ;
23270
23271 if (!args) SWIG_fail;
23272 swig_obj[0] = args;
23273 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23274 if (!SWIG_IsOK(res1)) {
23275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23276 }
23277 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23278 {
23279 PyThreadState* __tstate = wxPyBeginAllowThreads();
23280 result = ((wxMoveEvent const *)arg1)->GetRect();
23281 wxPyEndAllowThreads(__tstate);
23282 if (PyErr_Occurred()) SWIG_fail;
23283 }
23284 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23285 return resultobj;
23286 fail:
23287 return NULL;
23288 }
23289
23290
23291 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23292 PyObject *resultobj = 0;
23293 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23294 wxRect *arg2 = 0 ;
23295 void *argp1 = 0 ;
23296 int res1 = 0 ;
23297 wxRect temp2 ;
23298 PyObject * obj0 = 0 ;
23299 PyObject * obj1 = 0 ;
23300 char * kwnames[] = {
23301 (char *) "self",(char *) "rect", NULL
23302 };
23303
23304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23305 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23306 if (!SWIG_IsOK(res1)) {
23307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23308 }
23309 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23310 {
23311 arg2 = &temp2;
23312 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
23313 }
23314 {
23315 PyThreadState* __tstate = wxPyBeginAllowThreads();
23316 (arg1)->SetRect((wxRect const &)*arg2);
23317 wxPyEndAllowThreads(__tstate);
23318 if (PyErr_Occurred()) SWIG_fail;
23319 }
23320 resultobj = SWIG_Py_Void();
23321 return resultobj;
23322 fail:
23323 return NULL;
23324 }
23325
23326
23327 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23328 PyObject *resultobj = 0;
23329 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23330 wxPoint *arg2 = 0 ;
23331 void *argp1 = 0 ;
23332 int res1 = 0 ;
23333 wxPoint temp2 ;
23334 PyObject * obj0 = 0 ;
23335 PyObject * obj1 = 0 ;
23336 char * kwnames[] = {
23337 (char *) "self",(char *) "pos", NULL
23338 };
23339
23340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23342 if (!SWIG_IsOK(res1)) {
23343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23344 }
23345 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23346 {
23347 arg2 = &temp2;
23348 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
23349 }
23350 {
23351 PyThreadState* __tstate = wxPyBeginAllowThreads();
23352 (arg1)->SetPosition((wxPoint const &)*arg2);
23353 wxPyEndAllowThreads(__tstate);
23354 if (PyErr_Occurred()) SWIG_fail;
23355 }
23356 resultobj = SWIG_Py_Void();
23357 return resultobj;
23358 fail:
23359 return NULL;
23360 }
23361
23362
23363 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23364 PyObject *obj;
23365 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23366 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
23367 return SWIG_Py_Void();
23368 }
23369
23370 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23371 return SWIG_Python_InitShadowInstance(args);
23372 }
23373
23374 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23375 PyObject *resultobj = 0;
23376 int arg1 = (int) 0 ;
23377 wxPaintEvent *result = 0 ;
23378 int val1 ;
23379 int ecode1 = 0 ;
23380 PyObject * obj0 = 0 ;
23381 char * kwnames[] = {
23382 (char *) "Id", NULL
23383 };
23384
23385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
23386 if (obj0) {
23387 ecode1 = SWIG_AsVal_int(obj0, &val1);
23388 if (!SWIG_IsOK(ecode1)) {
23389 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
23390 }
23391 arg1 = static_cast< int >(val1);
23392 }
23393 {
23394 PyThreadState* __tstate = wxPyBeginAllowThreads();
23395 result = (wxPaintEvent *)new wxPaintEvent(arg1);
23396 wxPyEndAllowThreads(__tstate);
23397 if (PyErr_Occurred()) SWIG_fail;
23398 }
23399 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
23400 return resultobj;
23401 fail:
23402 return NULL;
23403 }
23404
23405
23406 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23407 PyObject *obj;
23408 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23409 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
23410 return SWIG_Py_Void();
23411 }
23412
23413 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23414 return SWIG_Python_InitShadowInstance(args);
23415 }
23416
23417 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23418 PyObject *resultobj = 0;
23419 int arg1 = (int) 0 ;
23420 wxNcPaintEvent *result = 0 ;
23421 int val1 ;
23422 int ecode1 = 0 ;
23423 PyObject * obj0 = 0 ;
23424 char * kwnames[] = {
23425 (char *) "winid", NULL
23426 };
23427
23428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
23429 if (obj0) {
23430 ecode1 = SWIG_AsVal_int(obj0, &val1);
23431 if (!SWIG_IsOK(ecode1)) {
23432 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
23433 }
23434 arg1 = static_cast< int >(val1);
23435 }
23436 {
23437 PyThreadState* __tstate = wxPyBeginAllowThreads();
23438 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
23439 wxPyEndAllowThreads(__tstate);
23440 if (PyErr_Occurred()) SWIG_fail;
23441 }
23442 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
23443 return resultobj;
23444 fail:
23445 return NULL;
23446 }
23447
23448
23449 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23450 PyObject *obj;
23451 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23452 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
23453 return SWIG_Py_Void();
23454 }
23455
23456 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23457 return SWIG_Python_InitShadowInstance(args);
23458 }
23459
23460 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23461 PyObject *resultobj = 0;
23462 int arg1 = (int) 0 ;
23463 wxDC *arg2 = (wxDC *) NULL ;
23464 wxEraseEvent *result = 0 ;
23465 int val1 ;
23466 int ecode1 = 0 ;
23467 void *argp2 = 0 ;
23468 int res2 = 0 ;
23469 PyObject * obj0 = 0 ;
23470 PyObject * obj1 = 0 ;
23471 char * kwnames[] = {
23472 (char *) "Id",(char *) "dc", NULL
23473 };
23474
23475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23476 if (obj0) {
23477 ecode1 = SWIG_AsVal_int(obj0, &val1);
23478 if (!SWIG_IsOK(ecode1)) {
23479 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
23480 }
23481 arg1 = static_cast< int >(val1);
23482 }
23483 if (obj1) {
23484 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
23485 if (!SWIG_IsOK(res2)) {
23486 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
23487 }
23488 arg2 = reinterpret_cast< wxDC * >(argp2);
23489 }
23490 {
23491 PyThreadState* __tstate = wxPyBeginAllowThreads();
23492 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
23493 wxPyEndAllowThreads(__tstate);
23494 if (PyErr_Occurred()) SWIG_fail;
23495 }
23496 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
23497 return resultobj;
23498 fail:
23499 return NULL;
23500 }
23501
23502
23503 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23504 PyObject *resultobj = 0;
23505 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
23506 wxDC *result = 0 ;
23507 void *argp1 = 0 ;
23508 int res1 = 0 ;
23509 PyObject *swig_obj[1] ;
23510
23511 if (!args) SWIG_fail;
23512 swig_obj[0] = args;
23513 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
23514 if (!SWIG_IsOK(res1)) {
23515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
23516 }
23517 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
23518 {
23519 PyThreadState* __tstate = wxPyBeginAllowThreads();
23520 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
23521 wxPyEndAllowThreads(__tstate);
23522 if (PyErr_Occurred()) SWIG_fail;
23523 }
23524 {
23525 resultobj = wxPyMake_wxObject(result, (bool)0);
23526 }
23527 return resultobj;
23528 fail:
23529 return NULL;
23530 }
23531
23532
23533 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23534 PyObject *obj;
23535 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23536 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
23537 return SWIG_Py_Void();
23538 }
23539
23540 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23541 return SWIG_Python_InitShadowInstance(args);
23542 }
23543
23544 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23545 PyObject *resultobj = 0;
23546 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23547 int arg2 = (int) 0 ;
23548 wxFocusEvent *result = 0 ;
23549 int val1 ;
23550 int ecode1 = 0 ;
23551 int val2 ;
23552 int ecode2 = 0 ;
23553 PyObject * obj0 = 0 ;
23554 PyObject * obj1 = 0 ;
23555 char * kwnames[] = {
23556 (char *) "type",(char *) "winid", NULL
23557 };
23558
23559 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23560 if (obj0) {
23561 ecode1 = SWIG_AsVal_int(obj0, &val1);
23562 if (!SWIG_IsOK(ecode1)) {
23563 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23564 }
23565 arg1 = static_cast< wxEventType >(val1);
23566 }
23567 if (obj1) {
23568 ecode2 = SWIG_AsVal_int(obj1, &val2);
23569 if (!SWIG_IsOK(ecode2)) {
23570 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
23571 }
23572 arg2 = static_cast< int >(val2);
23573 }
23574 {
23575 PyThreadState* __tstate = wxPyBeginAllowThreads();
23576 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
23577 wxPyEndAllowThreads(__tstate);
23578 if (PyErr_Occurred()) SWIG_fail;
23579 }
23580 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
23581 return resultobj;
23582 fail:
23583 return NULL;
23584 }
23585
23586
23587 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23588 PyObject *resultobj = 0;
23589 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23590 wxWindow *result = 0 ;
23591 void *argp1 = 0 ;
23592 int res1 = 0 ;
23593 PyObject *swig_obj[1] ;
23594
23595 if (!args) SWIG_fail;
23596 swig_obj[0] = args;
23597 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23598 if (!SWIG_IsOK(res1)) {
23599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
23600 }
23601 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23602 {
23603 PyThreadState* __tstate = wxPyBeginAllowThreads();
23604 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
23605 wxPyEndAllowThreads(__tstate);
23606 if (PyErr_Occurred()) SWIG_fail;
23607 }
23608 {
23609 resultobj = wxPyMake_wxObject(result, (bool)0);
23610 }
23611 return resultobj;
23612 fail:
23613 return NULL;
23614 }
23615
23616
23617 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23618 PyObject *resultobj = 0;
23619 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23620 wxWindow *arg2 = (wxWindow *) 0 ;
23621 void *argp1 = 0 ;
23622 int res1 = 0 ;
23623 void *argp2 = 0 ;
23624 int res2 = 0 ;
23625 PyObject * obj0 = 0 ;
23626 PyObject * obj1 = 0 ;
23627 char * kwnames[] = {
23628 (char *) "self",(char *) "win", NULL
23629 };
23630
23631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
23632 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23633 if (!SWIG_IsOK(res1)) {
23634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
23635 }
23636 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23637 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
23638 if (!SWIG_IsOK(res2)) {
23639 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
23640 }
23641 arg2 = reinterpret_cast< wxWindow * >(argp2);
23642 {
23643 PyThreadState* __tstate = wxPyBeginAllowThreads();
23644 (arg1)->SetWindow(arg2);
23645 wxPyEndAllowThreads(__tstate);
23646 if (PyErr_Occurred()) SWIG_fail;
23647 }
23648 resultobj = SWIG_Py_Void();
23649 return resultobj;
23650 fail:
23651 return NULL;
23652 }
23653
23654
23655 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23656 PyObject *obj;
23657 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23658 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
23659 return SWIG_Py_Void();
23660 }
23661
23662 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23663 return SWIG_Python_InitShadowInstance(args);
23664 }
23665
23666 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23667 PyObject *resultobj = 0;
23668 wxWindow *arg1 = (wxWindow *) NULL ;
23669 wxChildFocusEvent *result = 0 ;
23670 void *argp1 = 0 ;
23671 int res1 = 0 ;
23672 PyObject * obj0 = 0 ;
23673 char * kwnames[] = {
23674 (char *) "win", NULL
23675 };
23676
23677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
23678 if (obj0) {
23679 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
23680 if (!SWIG_IsOK(res1)) {
23681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
23682 }
23683 arg1 = reinterpret_cast< wxWindow * >(argp1);
23684 }
23685 {
23686 PyThreadState* __tstate = wxPyBeginAllowThreads();
23687 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
23688 wxPyEndAllowThreads(__tstate);
23689 if (PyErr_Occurred()) SWIG_fail;
23690 }
23691 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
23692 return resultobj;
23693 fail:
23694 return NULL;
23695 }
23696
23697
23698 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23699 PyObject *resultobj = 0;
23700 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
23701 wxWindow *result = 0 ;
23702 void *argp1 = 0 ;
23703 int res1 = 0 ;
23704 PyObject *swig_obj[1] ;
23705
23706 if (!args) SWIG_fail;
23707 swig_obj[0] = args;
23708 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
23709 if (!SWIG_IsOK(res1)) {
23710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
23711 }
23712 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
23713 {
23714 PyThreadState* __tstate = wxPyBeginAllowThreads();
23715 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
23716 wxPyEndAllowThreads(__tstate);
23717 if (PyErr_Occurred()) SWIG_fail;
23718 }
23719 {
23720 resultobj = wxPyMake_wxObject(result, (bool)0);
23721 }
23722 return resultobj;
23723 fail:
23724 return NULL;
23725 }
23726
23727
23728 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23729 PyObject *obj;
23730 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23731 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
23732 return SWIG_Py_Void();
23733 }
23734
23735 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23736 return SWIG_Python_InitShadowInstance(args);
23737 }
23738
23739 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23740 PyObject *resultobj = 0;
23741 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23742 bool arg2 = (bool) true ;
23743 int arg3 = (int) 0 ;
23744 wxActivateEvent *result = 0 ;
23745 int val1 ;
23746 int ecode1 = 0 ;
23747 bool val2 ;
23748 int ecode2 = 0 ;
23749 int val3 ;
23750 int ecode3 = 0 ;
23751 PyObject * obj0 = 0 ;
23752 PyObject * obj1 = 0 ;
23753 PyObject * obj2 = 0 ;
23754 char * kwnames[] = {
23755 (char *) "type",(char *) "active",(char *) "Id", NULL
23756 };
23757
23758 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23759 if (obj0) {
23760 ecode1 = SWIG_AsVal_int(obj0, &val1);
23761 if (!SWIG_IsOK(ecode1)) {
23762 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23763 }
23764 arg1 = static_cast< wxEventType >(val1);
23765 }
23766 if (obj1) {
23767 ecode2 = SWIG_AsVal_bool(obj1, &val2);
23768 if (!SWIG_IsOK(ecode2)) {
23769 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
23770 }
23771 arg2 = static_cast< bool >(val2);
23772 }
23773 if (obj2) {
23774 ecode3 = SWIG_AsVal_int(obj2, &val3);
23775 if (!SWIG_IsOK(ecode3)) {
23776 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
23777 }
23778 arg3 = static_cast< int >(val3);
23779 }
23780 {
23781 PyThreadState* __tstate = wxPyBeginAllowThreads();
23782 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
23783 wxPyEndAllowThreads(__tstate);
23784 if (PyErr_Occurred()) SWIG_fail;
23785 }
23786 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
23787 return resultobj;
23788 fail:
23789 return NULL;
23790 }
23791
23792
23793 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23794 PyObject *resultobj = 0;
23795 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
23796 bool result;
23797 void *argp1 = 0 ;
23798 int res1 = 0 ;
23799 PyObject *swig_obj[1] ;
23800
23801 if (!args) SWIG_fail;
23802 swig_obj[0] = args;
23803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
23804 if (!SWIG_IsOK(res1)) {
23805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
23806 }
23807 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
23808 {
23809 PyThreadState* __tstate = wxPyBeginAllowThreads();
23810 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
23811 wxPyEndAllowThreads(__tstate);
23812 if (PyErr_Occurred()) SWIG_fail;
23813 }
23814 {
23815 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23816 }
23817 return resultobj;
23818 fail:
23819 return NULL;
23820 }
23821
23822
23823 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23824 PyObject *obj;
23825 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23826 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
23827 return SWIG_Py_Void();
23828 }
23829
23830 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23831 return SWIG_Python_InitShadowInstance(args);
23832 }
23833
23834 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23835 PyObject *resultobj = 0;
23836 int arg1 = (int) 0 ;
23837 wxInitDialogEvent *result = 0 ;
23838 int val1 ;
23839 int ecode1 = 0 ;
23840 PyObject * obj0 = 0 ;
23841 char * kwnames[] = {
23842 (char *) "Id", NULL
23843 };
23844
23845 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
23846 if (obj0) {
23847 ecode1 = SWIG_AsVal_int(obj0, &val1);
23848 if (!SWIG_IsOK(ecode1)) {
23849 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
23850 }
23851 arg1 = static_cast< int >(val1);
23852 }
23853 {
23854 PyThreadState* __tstate = wxPyBeginAllowThreads();
23855 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
23856 wxPyEndAllowThreads(__tstate);
23857 if (PyErr_Occurred()) SWIG_fail;
23858 }
23859 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
23860 return resultobj;
23861 fail:
23862 return NULL;
23863 }
23864
23865
23866 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23867 PyObject *obj;
23868 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23869 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
23870 return SWIG_Py_Void();
23871 }
23872
23873 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23874 return SWIG_Python_InitShadowInstance(args);
23875 }
23876
23877 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23878 PyObject *resultobj = 0;
23879 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23880 int arg2 = (int) 0 ;
23881 wxMenu *arg3 = (wxMenu *) NULL ;
23882 wxMenuEvent *result = 0 ;
23883 int val1 ;
23884 int ecode1 = 0 ;
23885 int val2 ;
23886 int ecode2 = 0 ;
23887 void *argp3 = 0 ;
23888 int res3 = 0 ;
23889 PyObject * obj0 = 0 ;
23890 PyObject * obj1 = 0 ;
23891 PyObject * obj2 = 0 ;
23892 char * kwnames[] = {
23893 (char *) "type",(char *) "winid",(char *) "menu", NULL
23894 };
23895
23896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23897 if (obj0) {
23898 ecode1 = SWIG_AsVal_int(obj0, &val1);
23899 if (!SWIG_IsOK(ecode1)) {
23900 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23901 }
23902 arg1 = static_cast< wxEventType >(val1);
23903 }
23904 if (obj1) {
23905 ecode2 = SWIG_AsVal_int(obj1, &val2);
23906 if (!SWIG_IsOK(ecode2)) {
23907 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
23908 }
23909 arg2 = static_cast< int >(val2);
23910 }
23911 if (obj2) {
23912 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
23913 if (!SWIG_IsOK(res3)) {
23914 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
23915 }
23916 arg3 = reinterpret_cast< wxMenu * >(argp3);
23917 }
23918 {
23919 PyThreadState* __tstate = wxPyBeginAllowThreads();
23920 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
23921 wxPyEndAllowThreads(__tstate);
23922 if (PyErr_Occurred()) SWIG_fail;
23923 }
23924 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
23925 return resultobj;
23926 fail:
23927 return NULL;
23928 }
23929
23930
23931 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23932 PyObject *resultobj = 0;
23933 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
23934 int result;
23935 void *argp1 = 0 ;
23936 int res1 = 0 ;
23937 PyObject *swig_obj[1] ;
23938
23939 if (!args) SWIG_fail;
23940 swig_obj[0] = args;
23941 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
23942 if (!SWIG_IsOK(res1)) {
23943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
23944 }
23945 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
23946 {
23947 PyThreadState* __tstate = wxPyBeginAllowThreads();
23948 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
23949 wxPyEndAllowThreads(__tstate);
23950 if (PyErr_Occurred()) SWIG_fail;
23951 }
23952 resultobj = SWIG_From_int(static_cast< int >(result));
23953 return resultobj;
23954 fail:
23955 return NULL;
23956 }
23957
23958
23959 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23960 PyObject *resultobj = 0;
23961 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
23962 bool result;
23963 void *argp1 = 0 ;
23964 int res1 = 0 ;
23965 PyObject *swig_obj[1] ;
23966
23967 if (!args) SWIG_fail;
23968 swig_obj[0] = args;
23969 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
23970 if (!SWIG_IsOK(res1)) {
23971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
23972 }
23973 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
23974 {
23975 PyThreadState* __tstate = wxPyBeginAllowThreads();
23976 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
23977 wxPyEndAllowThreads(__tstate);
23978 if (PyErr_Occurred()) SWIG_fail;
23979 }
23980 {
23981 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23982 }
23983 return resultobj;
23984 fail:
23985 return NULL;
23986 }
23987
23988
23989 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23990 PyObject *resultobj = 0;
23991 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
23992 wxMenu *result = 0 ;
23993 void *argp1 = 0 ;
23994 int res1 = 0 ;
23995 PyObject *swig_obj[1] ;
23996
23997 if (!args) SWIG_fail;
23998 swig_obj[0] = args;
23999 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24000 if (!SWIG_IsOK(res1)) {
24001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24002 }
24003 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24004 {
24005 PyThreadState* __tstate = wxPyBeginAllowThreads();
24006 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
24007 wxPyEndAllowThreads(__tstate);
24008 if (PyErr_Occurred()) SWIG_fail;
24009 }
24010 {
24011 resultobj = wxPyMake_wxObject(result, (bool)0);
24012 }
24013 return resultobj;
24014 fail:
24015 return NULL;
24016 }
24017
24018
24019 SWIGINTERN PyObject *MenuEvent_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_wxMenuEvent, SWIG_NewClientData(obj));
24023 return SWIG_Py_Void();
24024 }
24025
24026 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24027 return SWIG_Python_InitShadowInstance(args);
24028 }
24029
24030 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24031 PyObject *resultobj = 0;
24032 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24033 int arg2 = (int) 0 ;
24034 wxCloseEvent *result = 0 ;
24035 int val1 ;
24036 int ecode1 = 0 ;
24037 int val2 ;
24038 int ecode2 = 0 ;
24039 PyObject * obj0 = 0 ;
24040 PyObject * obj1 = 0 ;
24041 char * kwnames[] = {
24042 (char *) "type",(char *) "winid", NULL
24043 };
24044
24045 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24046 if (obj0) {
24047 ecode1 = SWIG_AsVal_int(obj0, &val1);
24048 if (!SWIG_IsOK(ecode1)) {
24049 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24050 }
24051 arg1 = static_cast< wxEventType >(val1);
24052 }
24053 if (obj1) {
24054 ecode2 = SWIG_AsVal_int(obj1, &val2);
24055 if (!SWIG_IsOK(ecode2)) {
24056 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
24057 }
24058 arg2 = static_cast< int >(val2);
24059 }
24060 {
24061 PyThreadState* __tstate = wxPyBeginAllowThreads();
24062 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
24063 wxPyEndAllowThreads(__tstate);
24064 if (PyErr_Occurred()) SWIG_fail;
24065 }
24066 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
24067 return resultobj;
24068 fail:
24069 return NULL;
24070 }
24071
24072
24073 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24074 PyObject *resultobj = 0;
24075 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24076 bool arg2 ;
24077 void *argp1 = 0 ;
24078 int res1 = 0 ;
24079 bool val2 ;
24080 int ecode2 = 0 ;
24081 PyObject * obj0 = 0 ;
24082 PyObject * obj1 = 0 ;
24083 char * kwnames[] = {
24084 (char *) "self",(char *) "logOff", NULL
24085 };
24086
24087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
24088 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24089 if (!SWIG_IsOK(res1)) {
24090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24091 }
24092 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24093 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24094 if (!SWIG_IsOK(ecode2)) {
24095 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
24096 }
24097 arg2 = static_cast< bool >(val2);
24098 {
24099 PyThreadState* __tstate = wxPyBeginAllowThreads();
24100 (arg1)->SetLoggingOff(arg2);
24101 wxPyEndAllowThreads(__tstate);
24102 if (PyErr_Occurred()) SWIG_fail;
24103 }
24104 resultobj = SWIG_Py_Void();
24105 return resultobj;
24106 fail:
24107 return NULL;
24108 }
24109
24110
24111 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24112 PyObject *resultobj = 0;
24113 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24114 bool result;
24115 void *argp1 = 0 ;
24116 int res1 = 0 ;
24117 PyObject *swig_obj[1] ;
24118
24119 if (!args) SWIG_fail;
24120 swig_obj[0] = args;
24121 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24122 if (!SWIG_IsOK(res1)) {
24123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24124 }
24125 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24126 {
24127 PyThreadState* __tstate = wxPyBeginAllowThreads();
24128 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
24129 wxPyEndAllowThreads(__tstate);
24130 if (PyErr_Occurred()) SWIG_fail;
24131 }
24132 {
24133 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24134 }
24135 return resultobj;
24136 fail:
24137 return NULL;
24138 }
24139
24140
24141 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24142 PyObject *resultobj = 0;
24143 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24144 bool arg2 = (bool) true ;
24145 void *argp1 = 0 ;
24146 int res1 = 0 ;
24147 bool val2 ;
24148 int ecode2 = 0 ;
24149 PyObject * obj0 = 0 ;
24150 PyObject * obj1 = 0 ;
24151 char * kwnames[] = {
24152 (char *) "self",(char *) "veto", NULL
24153 };
24154
24155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
24156 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24157 if (!SWIG_IsOK(res1)) {
24158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24159 }
24160 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24161 if (obj1) {
24162 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24163 if (!SWIG_IsOK(ecode2)) {
24164 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
24165 }
24166 arg2 = static_cast< bool >(val2);
24167 }
24168 {
24169 PyThreadState* __tstate = wxPyBeginAllowThreads();
24170 (arg1)->Veto(arg2);
24171 wxPyEndAllowThreads(__tstate);
24172 if (PyErr_Occurred()) SWIG_fail;
24173 }
24174 resultobj = SWIG_Py_Void();
24175 return resultobj;
24176 fail:
24177 return NULL;
24178 }
24179
24180
24181 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24182 PyObject *resultobj = 0;
24183 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24184 bool result;
24185 void *argp1 = 0 ;
24186 int res1 = 0 ;
24187 PyObject *swig_obj[1] ;
24188
24189 if (!args) SWIG_fail;
24190 swig_obj[0] = args;
24191 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24192 if (!SWIG_IsOK(res1)) {
24193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24194 }
24195 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24196 {
24197 PyThreadState* __tstate = wxPyBeginAllowThreads();
24198 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
24199 wxPyEndAllowThreads(__tstate);
24200 if (PyErr_Occurred()) SWIG_fail;
24201 }
24202 {
24203 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24204 }
24205 return resultobj;
24206 fail:
24207 return NULL;
24208 }
24209
24210
24211 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24212 PyObject *resultobj = 0;
24213 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24214 bool arg2 ;
24215 void *argp1 = 0 ;
24216 int res1 = 0 ;
24217 bool val2 ;
24218 int ecode2 = 0 ;
24219 PyObject * obj0 = 0 ;
24220 PyObject * obj1 = 0 ;
24221 char * kwnames[] = {
24222 (char *) "self",(char *) "canVeto", NULL
24223 };
24224
24225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
24226 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24227 if (!SWIG_IsOK(res1)) {
24228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24229 }
24230 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24231 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24232 if (!SWIG_IsOK(ecode2)) {
24233 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
24234 }
24235 arg2 = static_cast< bool >(val2);
24236 {
24237 PyThreadState* __tstate = wxPyBeginAllowThreads();
24238 (arg1)->SetCanVeto(arg2);
24239 wxPyEndAllowThreads(__tstate);
24240 if (PyErr_Occurred()) SWIG_fail;
24241 }
24242 resultobj = SWIG_Py_Void();
24243 return resultobj;
24244 fail:
24245 return NULL;
24246 }
24247
24248
24249 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24250 PyObject *resultobj = 0;
24251 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24252 bool result;
24253 void *argp1 = 0 ;
24254 int res1 = 0 ;
24255 PyObject *swig_obj[1] ;
24256
24257 if (!args) SWIG_fail;
24258 swig_obj[0] = args;
24259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24260 if (!SWIG_IsOK(res1)) {
24261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24262 }
24263 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24264 {
24265 PyThreadState* __tstate = wxPyBeginAllowThreads();
24266 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
24267 wxPyEndAllowThreads(__tstate);
24268 if (PyErr_Occurred()) SWIG_fail;
24269 }
24270 {
24271 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24272 }
24273 return resultobj;
24274 fail:
24275 return NULL;
24276 }
24277
24278
24279 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24280 PyObject *obj;
24281 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24282 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
24283 return SWIG_Py_Void();
24284 }
24285
24286 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24287 return SWIG_Python_InitShadowInstance(args);
24288 }
24289
24290 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24291 PyObject *resultobj = 0;
24292 int arg1 = (int) 0 ;
24293 bool arg2 = (bool) false ;
24294 wxShowEvent *result = 0 ;
24295 int val1 ;
24296 int ecode1 = 0 ;
24297 bool val2 ;
24298 int ecode2 = 0 ;
24299 PyObject * obj0 = 0 ;
24300 PyObject * obj1 = 0 ;
24301 char * kwnames[] = {
24302 (char *) "winid",(char *) "show", NULL
24303 };
24304
24305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24306 if (obj0) {
24307 ecode1 = SWIG_AsVal_int(obj0, &val1);
24308 if (!SWIG_IsOK(ecode1)) {
24309 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
24310 }
24311 arg1 = static_cast< int >(val1);
24312 }
24313 if (obj1) {
24314 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24315 if (!SWIG_IsOK(ecode2)) {
24316 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
24317 }
24318 arg2 = static_cast< bool >(val2);
24319 }
24320 {
24321 PyThreadState* __tstate = wxPyBeginAllowThreads();
24322 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
24323 wxPyEndAllowThreads(__tstate);
24324 if (PyErr_Occurred()) SWIG_fail;
24325 }
24326 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
24327 return resultobj;
24328 fail:
24329 return NULL;
24330 }
24331
24332
24333 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24334 PyObject *resultobj = 0;
24335 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24336 bool arg2 ;
24337 void *argp1 = 0 ;
24338 int res1 = 0 ;
24339 bool val2 ;
24340 int ecode2 = 0 ;
24341 PyObject * obj0 = 0 ;
24342 PyObject * obj1 = 0 ;
24343 char * kwnames[] = {
24344 (char *) "self",(char *) "show", NULL
24345 };
24346
24347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
24348 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24349 if (!SWIG_IsOK(res1)) {
24350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
24351 }
24352 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24353 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24354 if (!SWIG_IsOK(ecode2)) {
24355 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
24356 }
24357 arg2 = static_cast< bool >(val2);
24358 {
24359 PyThreadState* __tstate = wxPyBeginAllowThreads();
24360 (arg1)->SetShow(arg2);
24361 wxPyEndAllowThreads(__tstate);
24362 if (PyErr_Occurred()) SWIG_fail;
24363 }
24364 resultobj = SWIG_Py_Void();
24365 return resultobj;
24366 fail:
24367 return NULL;
24368 }
24369
24370
24371 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24372 PyObject *resultobj = 0;
24373 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24374 bool result;
24375 void *argp1 = 0 ;
24376 int res1 = 0 ;
24377 PyObject *swig_obj[1] ;
24378
24379 if (!args) SWIG_fail;
24380 swig_obj[0] = args;
24381 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24382 if (!SWIG_IsOK(res1)) {
24383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
24384 }
24385 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24386 {
24387 PyThreadState* __tstate = wxPyBeginAllowThreads();
24388 result = (bool)((wxShowEvent const *)arg1)->GetShow();
24389 wxPyEndAllowThreads(__tstate);
24390 if (PyErr_Occurred()) SWIG_fail;
24391 }
24392 {
24393 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24394 }
24395 return resultobj;
24396 fail:
24397 return NULL;
24398 }
24399
24400
24401 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24402 PyObject *obj;
24403 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24404 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
24405 return SWIG_Py_Void();
24406 }
24407
24408 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24409 return SWIG_Python_InitShadowInstance(args);
24410 }
24411
24412 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24413 PyObject *resultobj = 0;
24414 int arg1 = (int) 0 ;
24415 bool arg2 = (bool) true ;
24416 wxIconizeEvent *result = 0 ;
24417 int val1 ;
24418 int ecode1 = 0 ;
24419 bool val2 ;
24420 int ecode2 = 0 ;
24421 PyObject * obj0 = 0 ;
24422 PyObject * obj1 = 0 ;
24423 char * kwnames[] = {
24424 (char *) "id",(char *) "iconized", NULL
24425 };
24426
24427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24428 if (obj0) {
24429 ecode1 = SWIG_AsVal_int(obj0, &val1);
24430 if (!SWIG_IsOK(ecode1)) {
24431 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
24432 }
24433 arg1 = static_cast< int >(val1);
24434 }
24435 if (obj1) {
24436 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24437 if (!SWIG_IsOK(ecode2)) {
24438 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
24439 }
24440 arg2 = static_cast< bool >(val2);
24441 }
24442 {
24443 PyThreadState* __tstate = wxPyBeginAllowThreads();
24444 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
24445 wxPyEndAllowThreads(__tstate);
24446 if (PyErr_Occurred()) SWIG_fail;
24447 }
24448 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
24449 return resultobj;
24450 fail:
24451 return NULL;
24452 }
24453
24454
24455 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24456 PyObject *resultobj = 0;
24457 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
24458 bool result;
24459 void *argp1 = 0 ;
24460 int res1 = 0 ;
24461 PyObject *swig_obj[1] ;
24462
24463 if (!args) SWIG_fail;
24464 swig_obj[0] = args;
24465 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
24466 if (!SWIG_IsOK(res1)) {
24467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
24468 }
24469 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
24470 {
24471 PyThreadState* __tstate = wxPyBeginAllowThreads();
24472 result = (bool)(arg1)->Iconized();
24473 wxPyEndAllowThreads(__tstate);
24474 if (PyErr_Occurred()) SWIG_fail;
24475 }
24476 {
24477 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24478 }
24479 return resultobj;
24480 fail:
24481 return NULL;
24482 }
24483
24484
24485 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24486 PyObject *obj;
24487 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24488 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
24489 return SWIG_Py_Void();
24490 }
24491
24492 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24493 return SWIG_Python_InitShadowInstance(args);
24494 }
24495
24496 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24497 PyObject *resultobj = 0;
24498 int arg1 = (int) 0 ;
24499 wxMaximizeEvent *result = 0 ;
24500 int val1 ;
24501 int ecode1 = 0 ;
24502 PyObject * obj0 = 0 ;
24503 char * kwnames[] = {
24504 (char *) "id", NULL
24505 };
24506
24507 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
24508 if (obj0) {
24509 ecode1 = SWIG_AsVal_int(obj0, &val1);
24510 if (!SWIG_IsOK(ecode1)) {
24511 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
24512 }
24513 arg1 = static_cast< int >(val1);
24514 }
24515 {
24516 PyThreadState* __tstate = wxPyBeginAllowThreads();
24517 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
24518 wxPyEndAllowThreads(__tstate);
24519 if (PyErr_Occurred()) SWIG_fail;
24520 }
24521 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
24522 return resultobj;
24523 fail:
24524 return NULL;
24525 }
24526
24527
24528 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24529 PyObject *obj;
24530 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24531 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
24532 return SWIG_Py_Void();
24533 }
24534
24535 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24536 return SWIG_Python_InitShadowInstance(args);
24537 }
24538
24539 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24540 PyObject *resultobj = 0;
24541 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24542 wxPoint result;
24543 void *argp1 = 0 ;
24544 int res1 = 0 ;
24545 PyObject *swig_obj[1] ;
24546
24547 if (!args) SWIG_fail;
24548 swig_obj[0] = args;
24549 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24550 if (!SWIG_IsOK(res1)) {
24551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24552 }
24553 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24554 {
24555 PyThreadState* __tstate = wxPyBeginAllowThreads();
24556 result = (arg1)->GetPosition();
24557 wxPyEndAllowThreads(__tstate);
24558 if (PyErr_Occurred()) SWIG_fail;
24559 }
24560 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
24561 return resultobj;
24562 fail:
24563 return NULL;
24564 }
24565
24566
24567 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24568 PyObject *resultobj = 0;
24569 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24570 int result;
24571 void *argp1 = 0 ;
24572 int res1 = 0 ;
24573 PyObject *swig_obj[1] ;
24574
24575 if (!args) SWIG_fail;
24576 swig_obj[0] = args;
24577 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24578 if (!SWIG_IsOK(res1)) {
24579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24580 }
24581 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24582 {
24583 PyThreadState* __tstate = wxPyBeginAllowThreads();
24584 result = (int)(arg1)->GetNumberOfFiles();
24585 wxPyEndAllowThreads(__tstate);
24586 if (PyErr_Occurred()) SWIG_fail;
24587 }
24588 resultobj = SWIG_From_int(static_cast< int >(result));
24589 return resultobj;
24590 fail:
24591 return NULL;
24592 }
24593
24594
24595 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24596 PyObject *resultobj = 0;
24597 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24598 PyObject *result = 0 ;
24599 void *argp1 = 0 ;
24600 int res1 = 0 ;
24601 PyObject *swig_obj[1] ;
24602
24603 if (!args) SWIG_fail;
24604 swig_obj[0] = args;
24605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24606 if (!SWIG_IsOK(res1)) {
24607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24608 }
24609 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24610 {
24611 PyThreadState* __tstate = wxPyBeginAllowThreads();
24612 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
24613 wxPyEndAllowThreads(__tstate);
24614 if (PyErr_Occurred()) SWIG_fail;
24615 }
24616 resultobj = result;
24617 return resultobj;
24618 fail:
24619 return NULL;
24620 }
24621
24622
24623 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24624 PyObject *obj;
24625 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24626 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
24627 return SWIG_Py_Void();
24628 }
24629
24630 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24631 PyObject *resultobj = 0;
24632 int arg1 = (int) 0 ;
24633 wxUpdateUIEvent *result = 0 ;
24634 int val1 ;
24635 int ecode1 = 0 ;
24636 PyObject * obj0 = 0 ;
24637 char * kwnames[] = {
24638 (char *) "commandId", NULL
24639 };
24640
24641 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
24642 if (obj0) {
24643 ecode1 = SWIG_AsVal_int(obj0, &val1);
24644 if (!SWIG_IsOK(ecode1)) {
24645 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
24646 }
24647 arg1 = static_cast< int >(val1);
24648 }
24649 {
24650 PyThreadState* __tstate = wxPyBeginAllowThreads();
24651 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
24652 wxPyEndAllowThreads(__tstate);
24653 if (PyErr_Occurred()) SWIG_fail;
24654 }
24655 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
24656 return resultobj;
24657 fail:
24658 return NULL;
24659 }
24660
24661
24662 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24663 PyObject *resultobj = 0;
24664 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24665 bool result;
24666 void *argp1 = 0 ;
24667 int res1 = 0 ;
24668 PyObject *swig_obj[1] ;
24669
24670 if (!args) SWIG_fail;
24671 swig_obj[0] = args;
24672 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24673 if (!SWIG_IsOK(res1)) {
24674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24675 }
24676 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24677 {
24678 PyThreadState* __tstate = wxPyBeginAllowThreads();
24679 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
24680 wxPyEndAllowThreads(__tstate);
24681 if (PyErr_Occurred()) SWIG_fail;
24682 }
24683 {
24684 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24685 }
24686 return resultobj;
24687 fail:
24688 return NULL;
24689 }
24690
24691
24692 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24693 PyObject *resultobj = 0;
24694 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24695 bool 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_wxUpdateUIEvent, 0 | 0 );
24703 if (!SWIG_IsOK(res1)) {
24704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24705 }
24706 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24707 {
24708 PyThreadState* __tstate = wxPyBeginAllowThreads();
24709 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
24710 wxPyEndAllowThreads(__tstate);
24711 if (PyErr_Occurred()) SWIG_fail;
24712 }
24713 {
24714 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24715 }
24716 return resultobj;
24717 fail:
24718 return NULL;
24719 }
24720
24721
24722 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24723 PyObject *resultobj = 0;
24724 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24725 bool result;
24726 void *argp1 = 0 ;
24727 int res1 = 0 ;
24728 PyObject *swig_obj[1] ;
24729
24730 if (!args) SWIG_fail;
24731 swig_obj[0] = args;
24732 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24733 if (!SWIG_IsOK(res1)) {
24734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24735 }
24736 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24737 {
24738 PyThreadState* __tstate = wxPyBeginAllowThreads();
24739 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
24740 wxPyEndAllowThreads(__tstate);
24741 if (PyErr_Occurred()) SWIG_fail;
24742 }
24743 {
24744 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24745 }
24746 return resultobj;
24747 fail:
24748 return NULL;
24749 }
24750
24751
24752 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24753 PyObject *resultobj = 0;
24754 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24755 wxString result;
24756 void *argp1 = 0 ;
24757 int res1 = 0 ;
24758 PyObject *swig_obj[1] ;
24759
24760 if (!args) SWIG_fail;
24761 swig_obj[0] = args;
24762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24763 if (!SWIG_IsOK(res1)) {
24764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24765 }
24766 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24767 {
24768 PyThreadState* __tstate = wxPyBeginAllowThreads();
24769 result = ((wxUpdateUIEvent const *)arg1)->GetText();
24770 wxPyEndAllowThreads(__tstate);
24771 if (PyErr_Occurred()) SWIG_fail;
24772 }
24773 {
24774 #if wxUSE_UNICODE
24775 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24776 #else
24777 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24778 #endif
24779 }
24780 return resultobj;
24781 fail:
24782 return NULL;
24783 }
24784
24785
24786 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24787 PyObject *resultobj = 0;
24788 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24789 bool result;
24790 void *argp1 = 0 ;
24791 int res1 = 0 ;
24792 PyObject *swig_obj[1] ;
24793
24794 if (!args) SWIG_fail;
24795 swig_obj[0] = args;
24796 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24797 if (!SWIG_IsOK(res1)) {
24798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24799 }
24800 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24801 {
24802 PyThreadState* __tstate = wxPyBeginAllowThreads();
24803 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
24804 wxPyEndAllowThreads(__tstate);
24805 if (PyErr_Occurred()) SWIG_fail;
24806 }
24807 {
24808 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24809 }
24810 return resultobj;
24811 fail:
24812 return NULL;
24813 }
24814
24815
24816 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24817 PyObject *resultobj = 0;
24818 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24819 bool result;
24820 void *argp1 = 0 ;
24821 int res1 = 0 ;
24822 PyObject *swig_obj[1] ;
24823
24824 if (!args) SWIG_fail;
24825 swig_obj[0] = args;
24826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24827 if (!SWIG_IsOK(res1)) {
24828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24829 }
24830 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24831 {
24832 PyThreadState* __tstate = wxPyBeginAllowThreads();
24833 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
24834 wxPyEndAllowThreads(__tstate);
24835 if (PyErr_Occurred()) SWIG_fail;
24836 }
24837 {
24838 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24839 }
24840 return resultobj;
24841 fail:
24842 return NULL;
24843 }
24844
24845
24846 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24847 PyObject *resultobj = 0;
24848 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24849 bool result;
24850 void *argp1 = 0 ;
24851 int res1 = 0 ;
24852 PyObject *swig_obj[1] ;
24853
24854 if (!args) SWIG_fail;
24855 swig_obj[0] = args;
24856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24857 if (!SWIG_IsOK(res1)) {
24858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24859 }
24860 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24861 {
24862 PyThreadState* __tstate = wxPyBeginAllowThreads();
24863 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
24864 wxPyEndAllowThreads(__tstate);
24865 if (PyErr_Occurred()) SWIG_fail;
24866 }
24867 {
24868 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24869 }
24870 return resultobj;
24871 fail:
24872 return NULL;
24873 }
24874
24875
24876 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24877 PyObject *resultobj = 0;
24878 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24879 bool result;
24880 void *argp1 = 0 ;
24881 int res1 = 0 ;
24882 PyObject *swig_obj[1] ;
24883
24884 if (!args) SWIG_fail;
24885 swig_obj[0] = args;
24886 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24887 if (!SWIG_IsOK(res1)) {
24888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24889 }
24890 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24891 {
24892 PyThreadState* __tstate = wxPyBeginAllowThreads();
24893 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
24894 wxPyEndAllowThreads(__tstate);
24895 if (PyErr_Occurred()) SWIG_fail;
24896 }
24897 {
24898 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24899 }
24900 return resultobj;
24901 fail:
24902 return NULL;
24903 }
24904
24905
24906 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24907 PyObject *resultobj = 0;
24908 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24909 bool arg2 ;
24910 void *argp1 = 0 ;
24911 int res1 = 0 ;
24912 bool val2 ;
24913 int ecode2 = 0 ;
24914 PyObject * obj0 = 0 ;
24915 PyObject * obj1 = 0 ;
24916 char * kwnames[] = {
24917 (char *) "self",(char *) "check", NULL
24918 };
24919
24920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
24921 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24922 if (!SWIG_IsOK(res1)) {
24923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
24924 }
24925 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24926 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24927 if (!SWIG_IsOK(ecode2)) {
24928 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
24929 }
24930 arg2 = static_cast< bool >(val2);
24931 {
24932 PyThreadState* __tstate = wxPyBeginAllowThreads();
24933 (arg1)->Check(arg2);
24934 wxPyEndAllowThreads(__tstate);
24935 if (PyErr_Occurred()) SWIG_fail;
24936 }
24937 resultobj = SWIG_Py_Void();
24938 return resultobj;
24939 fail:
24940 return NULL;
24941 }
24942
24943
24944 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24945 PyObject *resultobj = 0;
24946 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24947 bool arg2 ;
24948 void *argp1 = 0 ;
24949 int res1 = 0 ;
24950 bool val2 ;
24951 int ecode2 = 0 ;
24952 PyObject * obj0 = 0 ;
24953 PyObject * obj1 = 0 ;
24954 char * kwnames[] = {
24955 (char *) "self",(char *) "enable", NULL
24956 };
24957
24958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
24959 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24960 if (!SWIG_IsOK(res1)) {
24961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
24962 }
24963 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24964 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24965 if (!SWIG_IsOK(ecode2)) {
24966 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
24967 }
24968 arg2 = static_cast< bool >(val2);
24969 {
24970 PyThreadState* __tstate = wxPyBeginAllowThreads();
24971 (arg1)->Enable(arg2);
24972 wxPyEndAllowThreads(__tstate);
24973 if (PyErr_Occurred()) SWIG_fail;
24974 }
24975 resultobj = SWIG_Py_Void();
24976 return resultobj;
24977 fail:
24978 return NULL;
24979 }
24980
24981
24982 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24983 PyObject *resultobj = 0;
24984 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24985 bool arg2 ;
24986 void *argp1 = 0 ;
24987 int res1 = 0 ;
24988 bool val2 ;
24989 int ecode2 = 0 ;
24990 PyObject * obj0 = 0 ;
24991 PyObject * obj1 = 0 ;
24992 char * kwnames[] = {
24993 (char *) "self",(char *) "show", NULL
24994 };
24995
24996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
24997 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24998 if (!SWIG_IsOK(res1)) {
24999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25000 }
25001 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25002 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25003 if (!SWIG_IsOK(ecode2)) {
25004 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
25005 }
25006 arg2 = static_cast< bool >(val2);
25007 {
25008 PyThreadState* __tstate = wxPyBeginAllowThreads();
25009 (arg1)->Show(arg2);
25010 wxPyEndAllowThreads(__tstate);
25011 if (PyErr_Occurred()) SWIG_fail;
25012 }
25013 resultobj = SWIG_Py_Void();
25014 return resultobj;
25015 fail:
25016 return NULL;
25017 }
25018
25019
25020 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25021 PyObject *resultobj = 0;
25022 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25023 wxString *arg2 = 0 ;
25024 void *argp1 = 0 ;
25025 int res1 = 0 ;
25026 bool temp2 = false ;
25027 PyObject * obj0 = 0 ;
25028 PyObject * obj1 = 0 ;
25029 char * kwnames[] = {
25030 (char *) "self",(char *) "text", NULL
25031 };
25032
25033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
25034 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25035 if (!SWIG_IsOK(res1)) {
25036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25037 }
25038 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25039 {
25040 arg2 = wxString_in_helper(obj1);
25041 if (arg2 == NULL) SWIG_fail;
25042 temp2 = true;
25043 }
25044 {
25045 PyThreadState* __tstate = wxPyBeginAllowThreads();
25046 (arg1)->SetText((wxString const &)*arg2);
25047 wxPyEndAllowThreads(__tstate);
25048 if (PyErr_Occurred()) SWIG_fail;
25049 }
25050 resultobj = SWIG_Py_Void();
25051 {
25052 if (temp2)
25053 delete arg2;
25054 }
25055 return resultobj;
25056 fail:
25057 {
25058 if (temp2)
25059 delete arg2;
25060 }
25061 return NULL;
25062 }
25063
25064
25065 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25066 PyObject *resultobj = 0;
25067 long arg1 ;
25068 long val1 ;
25069 int ecode1 = 0 ;
25070 PyObject * obj0 = 0 ;
25071 char * kwnames[] = {
25072 (char *) "updateInterval", NULL
25073 };
25074
25075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
25076 ecode1 = SWIG_AsVal_long(obj0, &val1);
25077 if (!SWIG_IsOK(ecode1)) {
25078 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
25079 }
25080 arg1 = static_cast< long >(val1);
25081 {
25082 PyThreadState* __tstate = wxPyBeginAllowThreads();
25083 wxUpdateUIEvent::SetUpdateInterval(arg1);
25084 wxPyEndAllowThreads(__tstate);
25085 if (PyErr_Occurred()) SWIG_fail;
25086 }
25087 resultobj = SWIG_Py_Void();
25088 return resultobj;
25089 fail:
25090 return NULL;
25091 }
25092
25093
25094 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25095 PyObject *resultobj = 0;
25096 long result;
25097
25098 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
25099 {
25100 PyThreadState* __tstate = wxPyBeginAllowThreads();
25101 result = (long)wxUpdateUIEvent::GetUpdateInterval();
25102 wxPyEndAllowThreads(__tstate);
25103 if (PyErr_Occurred()) SWIG_fail;
25104 }
25105 resultobj = SWIG_From_long(static_cast< long >(result));
25106 return resultobj;
25107 fail:
25108 return NULL;
25109 }
25110
25111
25112 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25113 PyObject *resultobj = 0;
25114 wxWindow *arg1 = (wxWindow *) 0 ;
25115 bool result;
25116 void *argp1 = 0 ;
25117 int res1 = 0 ;
25118 PyObject * obj0 = 0 ;
25119 char * kwnames[] = {
25120 (char *) "win", NULL
25121 };
25122
25123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
25124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25125 if (!SWIG_IsOK(res1)) {
25126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
25127 }
25128 arg1 = reinterpret_cast< wxWindow * >(argp1);
25129 {
25130 PyThreadState* __tstate = wxPyBeginAllowThreads();
25131 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
25132 wxPyEndAllowThreads(__tstate);
25133 if (PyErr_Occurred()) SWIG_fail;
25134 }
25135 {
25136 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25137 }
25138 return resultobj;
25139 fail:
25140 return NULL;
25141 }
25142
25143
25144 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25145 PyObject *resultobj = 0;
25146
25147 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
25148 {
25149 PyThreadState* __tstate = wxPyBeginAllowThreads();
25150 wxUpdateUIEvent::ResetUpdateTime();
25151 wxPyEndAllowThreads(__tstate);
25152 if (PyErr_Occurred()) SWIG_fail;
25153 }
25154 resultobj = SWIG_Py_Void();
25155 return resultobj;
25156 fail:
25157 return NULL;
25158 }
25159
25160
25161 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25162 PyObject *resultobj = 0;
25163 wxUpdateUIMode arg1 ;
25164 int val1 ;
25165 int ecode1 = 0 ;
25166 PyObject * obj0 = 0 ;
25167 char * kwnames[] = {
25168 (char *) "mode", NULL
25169 };
25170
25171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
25172 ecode1 = SWIG_AsVal_int(obj0, &val1);
25173 if (!SWIG_IsOK(ecode1)) {
25174 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
25175 }
25176 arg1 = static_cast< wxUpdateUIMode >(val1);
25177 {
25178 PyThreadState* __tstate = wxPyBeginAllowThreads();
25179 wxUpdateUIEvent::SetMode(arg1);
25180 wxPyEndAllowThreads(__tstate);
25181 if (PyErr_Occurred()) SWIG_fail;
25182 }
25183 resultobj = SWIG_Py_Void();
25184 return resultobj;
25185 fail:
25186 return NULL;
25187 }
25188
25189
25190 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25191 PyObject *resultobj = 0;
25192 wxUpdateUIMode result;
25193
25194 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
25195 {
25196 PyThreadState* __tstate = wxPyBeginAllowThreads();
25197 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
25198 wxPyEndAllowThreads(__tstate);
25199 if (PyErr_Occurred()) SWIG_fail;
25200 }
25201 resultobj = SWIG_From_int(static_cast< int >(result));
25202 return resultobj;
25203 fail:
25204 return NULL;
25205 }
25206
25207
25208 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25209 PyObject *obj;
25210 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25211 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
25212 return SWIG_Py_Void();
25213 }
25214
25215 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25216 return SWIG_Python_InitShadowInstance(args);
25217 }
25218
25219 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25220 PyObject *resultobj = 0;
25221 wxSysColourChangedEvent *result = 0 ;
25222
25223 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
25224 {
25225 PyThreadState* __tstate = wxPyBeginAllowThreads();
25226 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
25227 wxPyEndAllowThreads(__tstate);
25228 if (PyErr_Occurred()) SWIG_fail;
25229 }
25230 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
25231 return resultobj;
25232 fail:
25233 return NULL;
25234 }
25235
25236
25237 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25238 PyObject *obj;
25239 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25240 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
25241 return SWIG_Py_Void();
25242 }
25243
25244 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25245 return SWIG_Python_InitShadowInstance(args);
25246 }
25247
25248 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25249 PyObject *resultobj = 0;
25250 int arg1 = (int) 0 ;
25251 wxWindow *arg2 = (wxWindow *) NULL ;
25252 wxMouseCaptureChangedEvent *result = 0 ;
25253 int val1 ;
25254 int ecode1 = 0 ;
25255 void *argp2 = 0 ;
25256 int res2 = 0 ;
25257 PyObject * obj0 = 0 ;
25258 PyObject * obj1 = 0 ;
25259 char * kwnames[] = {
25260 (char *) "winid",(char *) "gainedCapture", NULL
25261 };
25262
25263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25264 if (obj0) {
25265 ecode1 = SWIG_AsVal_int(obj0, &val1);
25266 if (!SWIG_IsOK(ecode1)) {
25267 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
25268 }
25269 arg1 = static_cast< int >(val1);
25270 }
25271 if (obj1) {
25272 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25273 if (!SWIG_IsOK(res2)) {
25274 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
25275 }
25276 arg2 = reinterpret_cast< wxWindow * >(argp2);
25277 }
25278 {
25279 PyThreadState* __tstate = wxPyBeginAllowThreads();
25280 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
25281 wxPyEndAllowThreads(__tstate);
25282 if (PyErr_Occurred()) SWIG_fail;
25283 }
25284 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
25285 return resultobj;
25286 fail:
25287 return NULL;
25288 }
25289
25290
25291 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25292 PyObject *resultobj = 0;
25293 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
25294 wxWindow *result = 0 ;
25295 void *argp1 = 0 ;
25296 int res1 = 0 ;
25297 PyObject *swig_obj[1] ;
25298
25299 if (!args) SWIG_fail;
25300 swig_obj[0] = args;
25301 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
25302 if (!SWIG_IsOK(res1)) {
25303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
25304 }
25305 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
25306 {
25307 PyThreadState* __tstate = wxPyBeginAllowThreads();
25308 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
25309 wxPyEndAllowThreads(__tstate);
25310 if (PyErr_Occurred()) SWIG_fail;
25311 }
25312 {
25313 resultobj = wxPyMake_wxObject(result, (bool)0);
25314 }
25315 return resultobj;
25316 fail:
25317 return NULL;
25318 }
25319
25320
25321 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25322 PyObject *obj;
25323 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25324 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
25325 return SWIG_Py_Void();
25326 }
25327
25328 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25329 return SWIG_Python_InitShadowInstance(args);
25330 }
25331
25332 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25333 PyObject *resultobj = 0;
25334 wxDisplayChangedEvent *result = 0 ;
25335
25336 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
25337 {
25338 PyThreadState* __tstate = wxPyBeginAllowThreads();
25339 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
25340 wxPyEndAllowThreads(__tstate);
25341 if (PyErr_Occurred()) SWIG_fail;
25342 }
25343 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
25344 return resultobj;
25345 fail:
25346 return NULL;
25347 }
25348
25349
25350 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25351 PyObject *obj;
25352 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25353 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
25354 return SWIG_Py_Void();
25355 }
25356
25357 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25358 return SWIG_Python_InitShadowInstance(args);
25359 }
25360
25361 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25362 PyObject *resultobj = 0;
25363 int arg1 = (int) 0 ;
25364 wxPaletteChangedEvent *result = 0 ;
25365 int val1 ;
25366 int ecode1 = 0 ;
25367 PyObject * obj0 = 0 ;
25368 char * kwnames[] = {
25369 (char *) "id", NULL
25370 };
25371
25372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
25373 if (obj0) {
25374 ecode1 = SWIG_AsVal_int(obj0, &val1);
25375 if (!SWIG_IsOK(ecode1)) {
25376 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
25377 }
25378 arg1 = static_cast< int >(val1);
25379 }
25380 {
25381 PyThreadState* __tstate = wxPyBeginAllowThreads();
25382 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
25383 wxPyEndAllowThreads(__tstate);
25384 if (PyErr_Occurred()) SWIG_fail;
25385 }
25386 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
25387 return resultobj;
25388 fail:
25389 return NULL;
25390 }
25391
25392
25393 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25394 PyObject *resultobj = 0;
25395 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25396 wxWindow *arg2 = (wxWindow *) 0 ;
25397 void *argp1 = 0 ;
25398 int res1 = 0 ;
25399 void *argp2 = 0 ;
25400 int res2 = 0 ;
25401 PyObject * obj0 = 0 ;
25402 PyObject * obj1 = 0 ;
25403 char * kwnames[] = {
25404 (char *) "self",(char *) "win", NULL
25405 };
25406
25407 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
25408 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25409 if (!SWIG_IsOK(res1)) {
25410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25411 }
25412 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25413 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25414 if (!SWIG_IsOK(res2)) {
25415 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
25416 }
25417 arg2 = reinterpret_cast< wxWindow * >(argp2);
25418 {
25419 PyThreadState* __tstate = wxPyBeginAllowThreads();
25420 (arg1)->SetChangedWindow(arg2);
25421 wxPyEndAllowThreads(__tstate);
25422 if (PyErr_Occurred()) SWIG_fail;
25423 }
25424 resultobj = SWIG_Py_Void();
25425 return resultobj;
25426 fail:
25427 return NULL;
25428 }
25429
25430
25431 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25432 PyObject *resultobj = 0;
25433 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25434 wxWindow *result = 0 ;
25435 void *argp1 = 0 ;
25436 int res1 = 0 ;
25437 PyObject *swig_obj[1] ;
25438
25439 if (!args) SWIG_fail;
25440 swig_obj[0] = args;
25441 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25442 if (!SWIG_IsOK(res1)) {
25443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25444 }
25445 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25446 {
25447 PyThreadState* __tstate = wxPyBeginAllowThreads();
25448 result = (wxWindow *)(arg1)->GetChangedWindow();
25449 wxPyEndAllowThreads(__tstate);
25450 if (PyErr_Occurred()) SWIG_fail;
25451 }
25452 {
25453 resultobj = wxPyMake_wxObject(result, (bool)0);
25454 }
25455 return resultobj;
25456 fail:
25457 return NULL;
25458 }
25459
25460
25461 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25462 PyObject *obj;
25463 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25464 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
25465 return SWIG_Py_Void();
25466 }
25467
25468 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25469 return SWIG_Python_InitShadowInstance(args);
25470 }
25471
25472 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25473 PyObject *resultobj = 0;
25474 int arg1 = (int) 0 ;
25475 wxQueryNewPaletteEvent *result = 0 ;
25476 int val1 ;
25477 int ecode1 = 0 ;
25478 PyObject * obj0 = 0 ;
25479 char * kwnames[] = {
25480 (char *) "winid", NULL
25481 };
25482
25483 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
25484 if (obj0) {
25485 ecode1 = SWIG_AsVal_int(obj0, &val1);
25486 if (!SWIG_IsOK(ecode1)) {
25487 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
25488 }
25489 arg1 = static_cast< int >(val1);
25490 }
25491 {
25492 PyThreadState* __tstate = wxPyBeginAllowThreads();
25493 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
25494 wxPyEndAllowThreads(__tstate);
25495 if (PyErr_Occurred()) SWIG_fail;
25496 }
25497 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
25498 return resultobj;
25499 fail:
25500 return NULL;
25501 }
25502
25503
25504 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25505 PyObject *resultobj = 0;
25506 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25507 bool arg2 ;
25508 void *argp1 = 0 ;
25509 int res1 = 0 ;
25510 bool val2 ;
25511 int ecode2 = 0 ;
25512 PyObject * obj0 = 0 ;
25513 PyObject * obj1 = 0 ;
25514 char * kwnames[] = {
25515 (char *) "self",(char *) "realized", NULL
25516 };
25517
25518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
25519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25520 if (!SWIG_IsOK(res1)) {
25521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
25522 }
25523 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25524 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25525 if (!SWIG_IsOK(ecode2)) {
25526 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
25527 }
25528 arg2 = static_cast< bool >(val2);
25529 {
25530 PyThreadState* __tstate = wxPyBeginAllowThreads();
25531 (arg1)->SetPaletteRealized(arg2);
25532 wxPyEndAllowThreads(__tstate);
25533 if (PyErr_Occurred()) SWIG_fail;
25534 }
25535 resultobj = SWIG_Py_Void();
25536 return resultobj;
25537 fail:
25538 return NULL;
25539 }
25540
25541
25542 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25543 PyObject *resultobj = 0;
25544 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25545 bool result;
25546 void *argp1 = 0 ;
25547 int res1 = 0 ;
25548 PyObject *swig_obj[1] ;
25549
25550 if (!args) SWIG_fail;
25551 swig_obj[0] = args;
25552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25553 if (!SWIG_IsOK(res1)) {
25554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
25555 }
25556 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25557 {
25558 PyThreadState* __tstate = wxPyBeginAllowThreads();
25559 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
25560 wxPyEndAllowThreads(__tstate);
25561 if (PyErr_Occurred()) SWIG_fail;
25562 }
25563 {
25564 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25565 }
25566 return resultobj;
25567 fail:
25568 return NULL;
25569 }
25570
25571
25572 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25573 PyObject *obj;
25574 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25575 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
25576 return SWIG_Py_Void();
25577 }
25578
25579 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25580 return SWIG_Python_InitShadowInstance(args);
25581 }
25582
25583 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25584 PyObject *resultobj = 0;
25585 wxNavigationKeyEvent *result = 0 ;
25586
25587 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
25588 {
25589 PyThreadState* __tstate = wxPyBeginAllowThreads();
25590 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
25591 wxPyEndAllowThreads(__tstate);
25592 if (PyErr_Occurred()) SWIG_fail;
25593 }
25594 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
25595 return resultobj;
25596 fail:
25597 return NULL;
25598 }
25599
25600
25601 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25602 PyObject *resultobj = 0;
25603 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25604 bool result;
25605 void *argp1 = 0 ;
25606 int res1 = 0 ;
25607 PyObject *swig_obj[1] ;
25608
25609 if (!args) SWIG_fail;
25610 swig_obj[0] = args;
25611 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25612 if (!SWIG_IsOK(res1)) {
25613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25614 }
25615 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25616 {
25617 PyThreadState* __tstate = wxPyBeginAllowThreads();
25618 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
25619 wxPyEndAllowThreads(__tstate);
25620 if (PyErr_Occurred()) SWIG_fail;
25621 }
25622 {
25623 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25624 }
25625 return resultobj;
25626 fail:
25627 return NULL;
25628 }
25629
25630
25631 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25632 PyObject *resultobj = 0;
25633 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25634 bool arg2 ;
25635 void *argp1 = 0 ;
25636 int res1 = 0 ;
25637 bool val2 ;
25638 int ecode2 = 0 ;
25639 PyObject * obj0 = 0 ;
25640 PyObject * obj1 = 0 ;
25641 char * kwnames[] = {
25642 (char *) "self",(char *) "forward", NULL
25643 };
25644
25645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
25646 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25647 if (!SWIG_IsOK(res1)) {
25648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25649 }
25650 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25651 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25652 if (!SWIG_IsOK(ecode2)) {
25653 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
25654 }
25655 arg2 = static_cast< bool >(val2);
25656 {
25657 PyThreadState* __tstate = wxPyBeginAllowThreads();
25658 (arg1)->SetDirection(arg2);
25659 wxPyEndAllowThreads(__tstate);
25660 if (PyErr_Occurred()) SWIG_fail;
25661 }
25662 resultobj = SWIG_Py_Void();
25663 return resultobj;
25664 fail:
25665 return NULL;
25666 }
25667
25668
25669 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25670 PyObject *resultobj = 0;
25671 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25672 bool result;
25673 void *argp1 = 0 ;
25674 int res1 = 0 ;
25675 PyObject *swig_obj[1] ;
25676
25677 if (!args) SWIG_fail;
25678 swig_obj[0] = args;
25679 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25680 if (!SWIG_IsOK(res1)) {
25681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25682 }
25683 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25684 {
25685 PyThreadState* __tstate = wxPyBeginAllowThreads();
25686 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
25687 wxPyEndAllowThreads(__tstate);
25688 if (PyErr_Occurred()) SWIG_fail;
25689 }
25690 {
25691 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25692 }
25693 return resultobj;
25694 fail:
25695 return NULL;
25696 }
25697
25698
25699 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25700 PyObject *resultobj = 0;
25701 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25702 bool arg2 ;
25703 void *argp1 = 0 ;
25704 int res1 = 0 ;
25705 bool val2 ;
25706 int ecode2 = 0 ;
25707 PyObject * obj0 = 0 ;
25708 PyObject * obj1 = 0 ;
25709 char * kwnames[] = {
25710 (char *) "self",(char *) "ischange", NULL
25711 };
25712
25713 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
25714 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25715 if (!SWIG_IsOK(res1)) {
25716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25717 }
25718 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25719 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25720 if (!SWIG_IsOK(ecode2)) {
25721 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
25722 }
25723 arg2 = static_cast< bool >(val2);
25724 {
25725 PyThreadState* __tstate = wxPyBeginAllowThreads();
25726 (arg1)->SetWindowChange(arg2);
25727 wxPyEndAllowThreads(__tstate);
25728 if (PyErr_Occurred()) SWIG_fail;
25729 }
25730 resultobj = SWIG_Py_Void();
25731 return resultobj;
25732 fail:
25733 return NULL;
25734 }
25735
25736
25737 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25738 PyObject *resultobj = 0;
25739 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25740 bool result;
25741 void *argp1 = 0 ;
25742 int res1 = 0 ;
25743 PyObject *swig_obj[1] ;
25744
25745 if (!args) SWIG_fail;
25746 swig_obj[0] = args;
25747 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25748 if (!SWIG_IsOK(res1)) {
25749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25750 }
25751 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25752 {
25753 PyThreadState* __tstate = wxPyBeginAllowThreads();
25754 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
25755 wxPyEndAllowThreads(__tstate);
25756 if (PyErr_Occurred()) SWIG_fail;
25757 }
25758 {
25759 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25760 }
25761 return resultobj;
25762 fail:
25763 return NULL;
25764 }
25765
25766
25767 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25768 PyObject *resultobj = 0;
25769 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25770 bool arg2 ;
25771 void *argp1 = 0 ;
25772 int res1 = 0 ;
25773 bool val2 ;
25774 int ecode2 = 0 ;
25775 PyObject * obj0 = 0 ;
25776 PyObject * obj1 = 0 ;
25777 char * kwnames[] = {
25778 (char *) "self",(char *) "bIs", NULL
25779 };
25780
25781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
25782 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25783 if (!SWIG_IsOK(res1)) {
25784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25785 }
25786 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25787 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25788 if (!SWIG_IsOK(ecode2)) {
25789 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
25790 }
25791 arg2 = static_cast< bool >(val2);
25792 {
25793 PyThreadState* __tstate = wxPyBeginAllowThreads();
25794 (arg1)->SetFromTab(arg2);
25795 wxPyEndAllowThreads(__tstate);
25796 if (PyErr_Occurred()) SWIG_fail;
25797 }
25798 resultobj = SWIG_Py_Void();
25799 return resultobj;
25800 fail:
25801 return NULL;
25802 }
25803
25804
25805 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25806 PyObject *resultobj = 0;
25807 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25808 long arg2 ;
25809 void *argp1 = 0 ;
25810 int res1 = 0 ;
25811 long val2 ;
25812 int ecode2 = 0 ;
25813 PyObject * obj0 = 0 ;
25814 PyObject * obj1 = 0 ;
25815 char * kwnames[] = {
25816 (char *) "self",(char *) "flags", NULL
25817 };
25818
25819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
25820 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25821 if (!SWIG_IsOK(res1)) {
25822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25823 }
25824 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25825 ecode2 = SWIG_AsVal_long(obj1, &val2);
25826 if (!SWIG_IsOK(ecode2)) {
25827 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
25828 }
25829 arg2 = static_cast< long >(val2);
25830 {
25831 PyThreadState* __tstate = wxPyBeginAllowThreads();
25832 (arg1)->SetFlags(arg2);
25833 wxPyEndAllowThreads(__tstate);
25834 if (PyErr_Occurred()) SWIG_fail;
25835 }
25836 resultobj = SWIG_Py_Void();
25837 return resultobj;
25838 fail:
25839 return NULL;
25840 }
25841
25842
25843 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25844 PyObject *resultobj = 0;
25845 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25846 wxWindow *result = 0 ;
25847 void *argp1 = 0 ;
25848 int res1 = 0 ;
25849 PyObject *swig_obj[1] ;
25850
25851 if (!args) SWIG_fail;
25852 swig_obj[0] = args;
25853 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25854 if (!SWIG_IsOK(res1)) {
25855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25856 }
25857 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25858 {
25859 PyThreadState* __tstate = wxPyBeginAllowThreads();
25860 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
25861 wxPyEndAllowThreads(__tstate);
25862 if (PyErr_Occurred()) SWIG_fail;
25863 }
25864 {
25865 resultobj = wxPyMake_wxObject(result, (bool)0);
25866 }
25867 return resultobj;
25868 fail:
25869 return NULL;
25870 }
25871
25872
25873 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25874 PyObject *resultobj = 0;
25875 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25876 wxWindow *arg2 = (wxWindow *) 0 ;
25877 void *argp1 = 0 ;
25878 int res1 = 0 ;
25879 void *argp2 = 0 ;
25880 int res2 = 0 ;
25881 PyObject * obj0 = 0 ;
25882 PyObject * obj1 = 0 ;
25883 char * kwnames[] = {
25884 (char *) "self",(char *) "win", NULL
25885 };
25886
25887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
25888 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25889 if (!SWIG_IsOK(res1)) {
25890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25891 }
25892 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25893 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25894 if (!SWIG_IsOK(res2)) {
25895 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
25896 }
25897 arg2 = reinterpret_cast< wxWindow * >(argp2);
25898 {
25899 PyThreadState* __tstate = wxPyBeginAllowThreads();
25900 (arg1)->SetCurrentFocus(arg2);
25901 wxPyEndAllowThreads(__tstate);
25902 if (PyErr_Occurred()) SWIG_fail;
25903 }
25904 resultobj = SWIG_Py_Void();
25905 return resultobj;
25906 fail:
25907 return NULL;
25908 }
25909
25910
25911 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25912 PyObject *obj;
25913 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25914 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
25915 return SWIG_Py_Void();
25916 }
25917
25918 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25919 return SWIG_Python_InitShadowInstance(args);
25920 }
25921
25922 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25923 PyObject *resultobj = 0;
25924 wxWindow *arg1 = (wxWindow *) NULL ;
25925 wxWindowCreateEvent *result = 0 ;
25926 void *argp1 = 0 ;
25927 int res1 = 0 ;
25928 PyObject * obj0 = 0 ;
25929 char * kwnames[] = {
25930 (char *) "win", NULL
25931 };
25932
25933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
25934 if (obj0) {
25935 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25936 if (!SWIG_IsOK(res1)) {
25937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
25938 }
25939 arg1 = reinterpret_cast< wxWindow * >(argp1);
25940 }
25941 {
25942 PyThreadState* __tstate = wxPyBeginAllowThreads();
25943 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
25944 wxPyEndAllowThreads(__tstate);
25945 if (PyErr_Occurred()) SWIG_fail;
25946 }
25947 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
25948 return resultobj;
25949 fail:
25950 return NULL;
25951 }
25952
25953
25954 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25955 PyObject *resultobj = 0;
25956 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
25957 wxWindow *result = 0 ;
25958 void *argp1 = 0 ;
25959 int res1 = 0 ;
25960 PyObject *swig_obj[1] ;
25961
25962 if (!args) SWIG_fail;
25963 swig_obj[0] = args;
25964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
25965 if (!SWIG_IsOK(res1)) {
25966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
25967 }
25968 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
25969 {
25970 PyThreadState* __tstate = wxPyBeginAllowThreads();
25971 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
25972 wxPyEndAllowThreads(__tstate);
25973 if (PyErr_Occurred()) SWIG_fail;
25974 }
25975 {
25976 resultobj = wxPyMake_wxObject(result, (bool)0);
25977 }
25978 return resultobj;
25979 fail:
25980 return NULL;
25981 }
25982
25983
25984 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25985 PyObject *obj;
25986 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25987 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
25988 return SWIG_Py_Void();
25989 }
25990
25991 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25992 return SWIG_Python_InitShadowInstance(args);
25993 }
25994
25995 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25996 PyObject *resultobj = 0;
25997 wxWindow *arg1 = (wxWindow *) NULL ;
25998 wxWindowDestroyEvent *result = 0 ;
25999 void *argp1 = 0 ;
26000 int res1 = 0 ;
26001 PyObject * obj0 = 0 ;
26002 char * kwnames[] = {
26003 (char *) "win", NULL
26004 };
26005
26006 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
26007 if (obj0) {
26008 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26009 if (!SWIG_IsOK(res1)) {
26010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26011 }
26012 arg1 = reinterpret_cast< wxWindow * >(argp1);
26013 }
26014 {
26015 PyThreadState* __tstate = wxPyBeginAllowThreads();
26016 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
26017 wxPyEndAllowThreads(__tstate);
26018 if (PyErr_Occurred()) SWIG_fail;
26019 }
26020 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
26021 return resultobj;
26022 fail:
26023 return NULL;
26024 }
26025
26026
26027 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26028 PyObject *resultobj = 0;
26029 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
26030 wxWindow *result = 0 ;
26031 void *argp1 = 0 ;
26032 int res1 = 0 ;
26033 PyObject *swig_obj[1] ;
26034
26035 if (!args) SWIG_fail;
26036 swig_obj[0] = args;
26037 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
26038 if (!SWIG_IsOK(res1)) {
26039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
26040 }
26041 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
26042 {
26043 PyThreadState* __tstate = wxPyBeginAllowThreads();
26044 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
26045 wxPyEndAllowThreads(__tstate);
26046 if (PyErr_Occurred()) SWIG_fail;
26047 }
26048 {
26049 resultobj = wxPyMake_wxObject(result, (bool)0);
26050 }
26051 return resultobj;
26052 fail:
26053 return NULL;
26054 }
26055
26056
26057 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26058 PyObject *obj;
26059 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26060 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
26061 return SWIG_Py_Void();
26062 }
26063
26064 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26065 return SWIG_Python_InitShadowInstance(args);
26066 }
26067
26068 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26069 PyObject *resultobj = 0;
26070 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26071 int arg2 = (int) 0 ;
26072 wxPoint const &arg3_defvalue = wxDefaultPosition ;
26073 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
26074 wxContextMenuEvent *result = 0 ;
26075 int val1 ;
26076 int ecode1 = 0 ;
26077 int val2 ;
26078 int ecode2 = 0 ;
26079 wxPoint temp3 ;
26080 PyObject * obj0 = 0 ;
26081 PyObject * obj1 = 0 ;
26082 PyObject * obj2 = 0 ;
26083 char * kwnames[] = {
26084 (char *) "type",(char *) "winid",(char *) "pt", NULL
26085 };
26086
26087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26088 if (obj0) {
26089 ecode1 = SWIG_AsVal_int(obj0, &val1);
26090 if (!SWIG_IsOK(ecode1)) {
26091 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26092 }
26093 arg1 = static_cast< wxEventType >(val1);
26094 }
26095 if (obj1) {
26096 ecode2 = SWIG_AsVal_int(obj1, &val2);
26097 if (!SWIG_IsOK(ecode2)) {
26098 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
26099 }
26100 arg2 = static_cast< int >(val2);
26101 }
26102 if (obj2) {
26103 {
26104 arg3 = &temp3;
26105 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
26106 }
26107 }
26108 {
26109 PyThreadState* __tstate = wxPyBeginAllowThreads();
26110 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
26111 wxPyEndAllowThreads(__tstate);
26112 if (PyErr_Occurred()) SWIG_fail;
26113 }
26114 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
26115 return resultobj;
26116 fail:
26117 return NULL;
26118 }
26119
26120
26121 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26122 PyObject *resultobj = 0;
26123 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26124 wxPoint *result = 0 ;
26125 void *argp1 = 0 ;
26126 int res1 = 0 ;
26127 PyObject *swig_obj[1] ;
26128
26129 if (!args) SWIG_fail;
26130 swig_obj[0] = args;
26131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26132 if (!SWIG_IsOK(res1)) {
26133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
26134 }
26135 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26136 {
26137 PyThreadState* __tstate = wxPyBeginAllowThreads();
26138 {
26139 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
26140 result = (wxPoint *) &_result_ref;
26141 }
26142 wxPyEndAllowThreads(__tstate);
26143 if (PyErr_Occurred()) SWIG_fail;
26144 }
26145 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
26146 return resultobj;
26147 fail:
26148 return NULL;
26149 }
26150
26151
26152 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26153 PyObject *resultobj = 0;
26154 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26155 wxPoint *arg2 = 0 ;
26156 void *argp1 = 0 ;
26157 int res1 = 0 ;
26158 wxPoint temp2 ;
26159 PyObject * obj0 = 0 ;
26160 PyObject * obj1 = 0 ;
26161 char * kwnames[] = {
26162 (char *) "self",(char *) "pos", NULL
26163 };
26164
26165 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26166 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26167 if (!SWIG_IsOK(res1)) {
26168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
26169 }
26170 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26171 {
26172 arg2 = &temp2;
26173 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26174 }
26175 {
26176 PyThreadState* __tstate = wxPyBeginAllowThreads();
26177 (arg1)->SetPosition((wxPoint const &)*arg2);
26178 wxPyEndAllowThreads(__tstate);
26179 if (PyErr_Occurred()) SWIG_fail;
26180 }
26181 resultobj = SWIG_Py_Void();
26182 return resultobj;
26183 fail:
26184 return NULL;
26185 }
26186
26187
26188 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26189 PyObject *obj;
26190 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26191 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
26192 return SWIG_Py_Void();
26193 }
26194
26195 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26196 return SWIG_Python_InitShadowInstance(args);
26197 }
26198
26199 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26200 PyObject *resultobj = 0;
26201 wxIdleEvent *result = 0 ;
26202
26203 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
26204 {
26205 PyThreadState* __tstate = wxPyBeginAllowThreads();
26206 result = (wxIdleEvent *)new wxIdleEvent();
26207 wxPyEndAllowThreads(__tstate);
26208 if (PyErr_Occurred()) SWIG_fail;
26209 }
26210 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
26211 return resultobj;
26212 fail:
26213 return NULL;
26214 }
26215
26216
26217 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26218 PyObject *resultobj = 0;
26219 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26220 bool arg2 = (bool) true ;
26221 void *argp1 = 0 ;
26222 int res1 = 0 ;
26223 bool val2 ;
26224 int ecode2 = 0 ;
26225 PyObject * obj0 = 0 ;
26226 PyObject * obj1 = 0 ;
26227 char * kwnames[] = {
26228 (char *) "self",(char *) "needMore", NULL
26229 };
26230
26231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
26232 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26233 if (!SWIG_IsOK(res1)) {
26234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
26235 }
26236 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26237 if (obj1) {
26238 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26239 if (!SWIG_IsOK(ecode2)) {
26240 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
26241 }
26242 arg2 = static_cast< bool >(val2);
26243 }
26244 {
26245 PyThreadState* __tstate = wxPyBeginAllowThreads();
26246 (arg1)->RequestMore(arg2);
26247 wxPyEndAllowThreads(__tstate);
26248 if (PyErr_Occurred()) SWIG_fail;
26249 }
26250 resultobj = SWIG_Py_Void();
26251 return resultobj;
26252 fail:
26253 return NULL;
26254 }
26255
26256
26257 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26258 PyObject *resultobj = 0;
26259 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26260 bool result;
26261 void *argp1 = 0 ;
26262 int res1 = 0 ;
26263 PyObject *swig_obj[1] ;
26264
26265 if (!args) SWIG_fail;
26266 swig_obj[0] = args;
26267 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26268 if (!SWIG_IsOK(res1)) {
26269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
26270 }
26271 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26272 {
26273 PyThreadState* __tstate = wxPyBeginAllowThreads();
26274 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
26275 wxPyEndAllowThreads(__tstate);
26276 if (PyErr_Occurred()) SWIG_fail;
26277 }
26278 {
26279 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26280 }
26281 return resultobj;
26282 fail:
26283 return NULL;
26284 }
26285
26286
26287 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26288 PyObject *resultobj = 0;
26289 wxIdleMode arg1 ;
26290 int val1 ;
26291 int ecode1 = 0 ;
26292 PyObject * obj0 = 0 ;
26293 char * kwnames[] = {
26294 (char *) "mode", NULL
26295 };
26296
26297 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
26298 ecode1 = SWIG_AsVal_int(obj0, &val1);
26299 if (!SWIG_IsOK(ecode1)) {
26300 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
26301 }
26302 arg1 = static_cast< wxIdleMode >(val1);
26303 {
26304 PyThreadState* __tstate = wxPyBeginAllowThreads();
26305 wxIdleEvent::SetMode(arg1);
26306 wxPyEndAllowThreads(__tstate);
26307 if (PyErr_Occurred()) SWIG_fail;
26308 }
26309 resultobj = SWIG_Py_Void();
26310 return resultobj;
26311 fail:
26312 return NULL;
26313 }
26314
26315
26316 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26317 PyObject *resultobj = 0;
26318 wxIdleMode result;
26319
26320 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
26321 {
26322 PyThreadState* __tstate = wxPyBeginAllowThreads();
26323 result = (wxIdleMode)wxIdleEvent::GetMode();
26324 wxPyEndAllowThreads(__tstate);
26325 if (PyErr_Occurred()) SWIG_fail;
26326 }
26327 resultobj = SWIG_From_int(static_cast< int >(result));
26328 return resultobj;
26329 fail:
26330 return NULL;
26331 }
26332
26333
26334 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26335 PyObject *resultobj = 0;
26336 wxWindow *arg1 = (wxWindow *) 0 ;
26337 bool result;
26338 void *argp1 = 0 ;
26339 int res1 = 0 ;
26340 PyObject * obj0 = 0 ;
26341 char * kwnames[] = {
26342 (char *) "win", NULL
26343 };
26344
26345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
26346 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26347 if (!SWIG_IsOK(res1)) {
26348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
26349 }
26350 arg1 = reinterpret_cast< wxWindow * >(argp1);
26351 {
26352 PyThreadState* __tstate = wxPyBeginAllowThreads();
26353 result = (bool)wxIdleEvent::CanSend(arg1);
26354 wxPyEndAllowThreads(__tstate);
26355 if (PyErr_Occurred()) SWIG_fail;
26356 }
26357 {
26358 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26359 }
26360 return resultobj;
26361 fail:
26362 return NULL;
26363 }
26364
26365
26366 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26367 PyObject *obj;
26368 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26369 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
26370 return SWIG_Py_Void();
26371 }
26372
26373 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26374 return SWIG_Python_InitShadowInstance(args);
26375 }
26376
26377 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26378 PyObject *resultobj = 0;
26379 int arg1 = (int) 0 ;
26380 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
26381 wxPyEvent *result = 0 ;
26382 int val1 ;
26383 int ecode1 = 0 ;
26384 int val2 ;
26385 int ecode2 = 0 ;
26386 PyObject * obj0 = 0 ;
26387 PyObject * obj1 = 0 ;
26388 char * kwnames[] = {
26389 (char *) "winid",(char *) "eventType", NULL
26390 };
26391
26392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26393 if (obj0) {
26394 ecode1 = SWIG_AsVal_int(obj0, &val1);
26395 if (!SWIG_IsOK(ecode1)) {
26396 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
26397 }
26398 arg1 = static_cast< int >(val1);
26399 }
26400 if (obj1) {
26401 ecode2 = SWIG_AsVal_int(obj1, &val2);
26402 if (!SWIG_IsOK(ecode2)) {
26403 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
26404 }
26405 arg2 = static_cast< wxEventType >(val2);
26406 }
26407 {
26408 PyThreadState* __tstate = wxPyBeginAllowThreads();
26409 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
26410 wxPyEndAllowThreads(__tstate);
26411 if (PyErr_Occurred()) SWIG_fail;
26412 }
26413 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
26414 return resultobj;
26415 fail:
26416 return NULL;
26417 }
26418
26419
26420 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26421 PyObject *resultobj = 0;
26422 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26423 void *argp1 = 0 ;
26424 int res1 = 0 ;
26425 PyObject *swig_obj[1] ;
26426
26427 if (!args) SWIG_fail;
26428 swig_obj[0] = args;
26429 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
26430 if (!SWIG_IsOK(res1)) {
26431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26432 }
26433 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26434 {
26435 PyThreadState* __tstate = wxPyBeginAllowThreads();
26436 delete arg1;
26437
26438 wxPyEndAllowThreads(__tstate);
26439 if (PyErr_Occurred()) SWIG_fail;
26440 }
26441 resultobj = SWIG_Py_Void();
26442 return resultobj;
26443 fail:
26444 return NULL;
26445 }
26446
26447
26448 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26449 PyObject *resultobj = 0;
26450 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26451 PyObject *arg2 = (PyObject *) 0 ;
26452 void *argp1 = 0 ;
26453 int res1 = 0 ;
26454 PyObject * obj0 = 0 ;
26455 PyObject * obj1 = 0 ;
26456 char * kwnames[] = {
26457 (char *) "self",(char *) "self", NULL
26458 };
26459
26460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26461 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26462 if (!SWIG_IsOK(res1)) {
26463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26464 }
26465 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26466 arg2 = obj1;
26467 {
26468 PyThreadState* __tstate = wxPyBeginAllowThreads();
26469 (arg1)->SetSelf(arg2);
26470 wxPyEndAllowThreads(__tstate);
26471 if (PyErr_Occurred()) SWIG_fail;
26472 }
26473 resultobj = SWIG_Py_Void();
26474 return resultobj;
26475 fail:
26476 return NULL;
26477 }
26478
26479
26480 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26481 PyObject *resultobj = 0;
26482 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26483 PyObject *result = 0 ;
26484 void *argp1 = 0 ;
26485 int res1 = 0 ;
26486 PyObject *swig_obj[1] ;
26487
26488 if (!args) SWIG_fail;
26489 swig_obj[0] = args;
26490 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26491 if (!SWIG_IsOK(res1)) {
26492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26493 }
26494 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26495 {
26496 PyThreadState* __tstate = wxPyBeginAllowThreads();
26497 result = (PyObject *)(arg1)->GetSelf();
26498 wxPyEndAllowThreads(__tstate);
26499 if (PyErr_Occurred()) SWIG_fail;
26500 }
26501 resultobj = result;
26502 return resultobj;
26503 fail:
26504 return NULL;
26505 }
26506
26507
26508 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26509 PyObject *obj;
26510 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26511 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
26512 return SWIG_Py_Void();
26513 }
26514
26515 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26516 return SWIG_Python_InitShadowInstance(args);
26517 }
26518
26519 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26520 PyObject *resultobj = 0;
26521 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26522 int arg2 = (int) 0 ;
26523 wxPyCommandEvent *result = 0 ;
26524 int val1 ;
26525 int ecode1 = 0 ;
26526 int val2 ;
26527 int ecode2 = 0 ;
26528 PyObject * obj0 = 0 ;
26529 PyObject * obj1 = 0 ;
26530 char * kwnames[] = {
26531 (char *) "eventType",(char *) "id", NULL
26532 };
26533
26534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26535 if (obj0) {
26536 ecode1 = SWIG_AsVal_int(obj0, &val1);
26537 if (!SWIG_IsOK(ecode1)) {
26538 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26539 }
26540 arg1 = static_cast< wxEventType >(val1);
26541 }
26542 if (obj1) {
26543 ecode2 = SWIG_AsVal_int(obj1, &val2);
26544 if (!SWIG_IsOK(ecode2)) {
26545 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
26546 }
26547 arg2 = static_cast< int >(val2);
26548 }
26549 {
26550 PyThreadState* __tstate = wxPyBeginAllowThreads();
26551 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
26552 wxPyEndAllowThreads(__tstate);
26553 if (PyErr_Occurred()) SWIG_fail;
26554 }
26555 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
26556 return resultobj;
26557 fail:
26558 return NULL;
26559 }
26560
26561
26562 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26563 PyObject *resultobj = 0;
26564 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26565 void *argp1 = 0 ;
26566 int res1 = 0 ;
26567 PyObject *swig_obj[1] ;
26568
26569 if (!args) SWIG_fail;
26570 swig_obj[0] = args;
26571 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
26572 if (!SWIG_IsOK(res1)) {
26573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26574 }
26575 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26576 {
26577 PyThreadState* __tstate = wxPyBeginAllowThreads();
26578 delete arg1;
26579
26580 wxPyEndAllowThreads(__tstate);
26581 if (PyErr_Occurred()) SWIG_fail;
26582 }
26583 resultobj = SWIG_Py_Void();
26584 return resultobj;
26585 fail:
26586 return NULL;
26587 }
26588
26589
26590 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26591 PyObject *resultobj = 0;
26592 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26593 PyObject *arg2 = (PyObject *) 0 ;
26594 void *argp1 = 0 ;
26595 int res1 = 0 ;
26596 PyObject * obj0 = 0 ;
26597 PyObject * obj1 = 0 ;
26598 char * kwnames[] = {
26599 (char *) "self",(char *) "self", NULL
26600 };
26601
26602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26603 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26604 if (!SWIG_IsOK(res1)) {
26605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26606 }
26607 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26608 arg2 = obj1;
26609 {
26610 PyThreadState* __tstate = wxPyBeginAllowThreads();
26611 (arg1)->SetSelf(arg2);
26612 wxPyEndAllowThreads(__tstate);
26613 if (PyErr_Occurred()) SWIG_fail;
26614 }
26615 resultobj = SWIG_Py_Void();
26616 return resultobj;
26617 fail:
26618 return NULL;
26619 }
26620
26621
26622 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26623 PyObject *resultobj = 0;
26624 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26625 PyObject *result = 0 ;
26626 void *argp1 = 0 ;
26627 int res1 = 0 ;
26628 PyObject *swig_obj[1] ;
26629
26630 if (!args) SWIG_fail;
26631 swig_obj[0] = args;
26632 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26633 if (!SWIG_IsOK(res1)) {
26634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26635 }
26636 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26637 {
26638 PyThreadState* __tstate = wxPyBeginAllowThreads();
26639 result = (PyObject *)(arg1)->GetSelf();
26640 wxPyEndAllowThreads(__tstate);
26641 if (PyErr_Occurred()) SWIG_fail;
26642 }
26643 resultobj = result;
26644 return resultobj;
26645 fail:
26646 return NULL;
26647 }
26648
26649
26650 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26651 PyObject *obj;
26652 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26653 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
26654 return SWIG_Py_Void();
26655 }
26656
26657 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26658 return SWIG_Python_InitShadowInstance(args);
26659 }
26660
26661 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26662 PyObject *resultobj = 0;
26663 wxWindow *arg1 = (wxWindow *) 0 ;
26664 wxDateTime *arg2 = 0 ;
26665 wxEventType arg3 ;
26666 wxDateEvent *result = 0 ;
26667 void *argp1 = 0 ;
26668 int res1 = 0 ;
26669 void *argp2 = 0 ;
26670 int res2 = 0 ;
26671 int val3 ;
26672 int ecode3 = 0 ;
26673 PyObject * obj0 = 0 ;
26674 PyObject * obj1 = 0 ;
26675 PyObject * obj2 = 0 ;
26676 char * kwnames[] = {
26677 (char *) "win",(char *) "dt",(char *) "type", NULL
26678 };
26679
26680 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26681 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26682 if (!SWIG_IsOK(res1)) {
26683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26684 }
26685 arg1 = reinterpret_cast< wxWindow * >(argp1);
26686 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26687 if (!SWIG_IsOK(res2)) {
26688 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26689 }
26690 if (!argp2) {
26691 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26692 }
26693 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26694 ecode3 = SWIG_AsVal_int(obj2, &val3);
26695 if (!SWIG_IsOK(ecode3)) {
26696 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
26697 }
26698 arg3 = static_cast< wxEventType >(val3);
26699 {
26700 PyThreadState* __tstate = wxPyBeginAllowThreads();
26701 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
26702 wxPyEndAllowThreads(__tstate);
26703 if (PyErr_Occurred()) SWIG_fail;
26704 }
26705 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
26706 return resultobj;
26707 fail:
26708 return NULL;
26709 }
26710
26711
26712 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26713 PyObject *resultobj = 0;
26714 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
26715 wxDateTime *result = 0 ;
26716 void *argp1 = 0 ;
26717 int res1 = 0 ;
26718 PyObject *swig_obj[1] ;
26719
26720 if (!args) SWIG_fail;
26721 swig_obj[0] = args;
26722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
26723 if (!SWIG_IsOK(res1)) {
26724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
26725 }
26726 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
26727 {
26728 PyThreadState* __tstate = wxPyBeginAllowThreads();
26729 {
26730 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
26731 result = (wxDateTime *) &_result_ref;
26732 }
26733 wxPyEndAllowThreads(__tstate);
26734 if (PyErr_Occurred()) SWIG_fail;
26735 }
26736 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26737 return resultobj;
26738 fail:
26739 return NULL;
26740 }
26741
26742
26743 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26744 PyObject *resultobj = 0;
26745 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
26746 wxDateTime *arg2 = 0 ;
26747 void *argp1 = 0 ;
26748 int res1 = 0 ;
26749 void *argp2 = 0 ;
26750 int res2 = 0 ;
26751 PyObject * obj0 = 0 ;
26752 PyObject * obj1 = 0 ;
26753 char * kwnames[] = {
26754 (char *) "self",(char *) "date", NULL
26755 };
26756
26757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
26758 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
26759 if (!SWIG_IsOK(res1)) {
26760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
26761 }
26762 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
26763 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26764 if (!SWIG_IsOK(res2)) {
26765 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26766 }
26767 if (!argp2) {
26768 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26769 }
26770 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26771 {
26772 PyThreadState* __tstate = wxPyBeginAllowThreads();
26773 (arg1)->SetDate((wxDateTime const &)*arg2);
26774 wxPyEndAllowThreads(__tstate);
26775 if (PyErr_Occurred()) SWIG_fail;
26776 }
26777 resultobj = SWIG_Py_Void();
26778 return resultobj;
26779 fail:
26780 return NULL;
26781 }
26782
26783
26784 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26785 PyObject *obj;
26786 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26787 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
26788 return SWIG_Py_Void();
26789 }
26790
26791 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26792 return SWIG_Python_InitShadowInstance(args);
26793 }
26794
26795 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26796 PyObject *resultobj = 0;
26797 wxPyApp *result = 0 ;
26798
26799 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
26800 {
26801 PyThreadState* __tstate = wxPyBeginAllowThreads();
26802 result = (wxPyApp *)new_wxPyApp();
26803 wxPyEndAllowThreads(__tstate);
26804 if (PyErr_Occurred()) SWIG_fail;
26805 }
26806 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
26807 return resultobj;
26808 fail:
26809 return NULL;
26810 }
26811
26812
26813 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26814 PyObject *resultobj = 0;
26815 wxPyApp *arg1 = (wxPyApp *) 0 ;
26816 void *argp1 = 0 ;
26817 int res1 = 0 ;
26818 PyObject *swig_obj[1] ;
26819
26820 if (!args) SWIG_fail;
26821 swig_obj[0] = args;
26822 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
26823 if (!SWIG_IsOK(res1)) {
26824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
26825 }
26826 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26827 {
26828 PyThreadState* __tstate = wxPyBeginAllowThreads();
26829 delete arg1;
26830
26831 wxPyEndAllowThreads(__tstate);
26832 if (PyErr_Occurred()) SWIG_fail;
26833 }
26834 resultobj = SWIG_Py_Void();
26835 return resultobj;
26836 fail:
26837 return NULL;
26838 }
26839
26840
26841 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26842 PyObject *resultobj = 0;
26843 wxPyApp *arg1 = (wxPyApp *) 0 ;
26844 PyObject *arg2 = (PyObject *) 0 ;
26845 PyObject *arg3 = (PyObject *) 0 ;
26846 bool arg4 ;
26847 void *argp1 = 0 ;
26848 int res1 = 0 ;
26849 bool val4 ;
26850 int ecode4 = 0 ;
26851 PyObject * obj0 = 0 ;
26852 PyObject * obj1 = 0 ;
26853 PyObject * obj2 = 0 ;
26854 PyObject * obj3 = 0 ;
26855 char * kwnames[] = {
26856 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
26857 };
26858
26859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
26860 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26861 if (!SWIG_IsOK(res1)) {
26862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
26863 }
26864 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26865 arg2 = obj1;
26866 arg3 = obj2;
26867 ecode4 = SWIG_AsVal_bool(obj3, &val4);
26868 if (!SWIG_IsOK(ecode4)) {
26869 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
26870 }
26871 arg4 = static_cast< bool >(val4);
26872 {
26873 PyThreadState* __tstate = wxPyBeginAllowThreads();
26874 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
26875 wxPyEndAllowThreads(__tstate);
26876 if (PyErr_Occurred()) SWIG_fail;
26877 }
26878 resultobj = SWIG_Py_Void();
26879 return resultobj;
26880 fail:
26881 return NULL;
26882 }
26883
26884
26885 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26886 PyObject *resultobj = 0;
26887 wxPyApp *arg1 = (wxPyApp *) 0 ;
26888 wxString result;
26889 void *argp1 = 0 ;
26890 int res1 = 0 ;
26891 PyObject *swig_obj[1] ;
26892
26893 if (!args) SWIG_fail;
26894 swig_obj[0] = args;
26895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26896 if (!SWIG_IsOK(res1)) {
26897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
26898 }
26899 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26900 {
26901 PyThreadState* __tstate = wxPyBeginAllowThreads();
26902 result = ((wxPyApp const *)arg1)->GetAppName();
26903 wxPyEndAllowThreads(__tstate);
26904 if (PyErr_Occurred()) SWIG_fail;
26905 }
26906 {
26907 #if wxUSE_UNICODE
26908 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26909 #else
26910 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26911 #endif
26912 }
26913 return resultobj;
26914 fail:
26915 return NULL;
26916 }
26917
26918
26919 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26920 PyObject *resultobj = 0;
26921 wxPyApp *arg1 = (wxPyApp *) 0 ;
26922 wxString *arg2 = 0 ;
26923 void *argp1 = 0 ;
26924 int res1 = 0 ;
26925 bool temp2 = false ;
26926 PyObject * obj0 = 0 ;
26927 PyObject * obj1 = 0 ;
26928 char * kwnames[] = {
26929 (char *) "self",(char *) "name", NULL
26930 };
26931
26932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
26933 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26934 if (!SWIG_IsOK(res1)) {
26935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
26936 }
26937 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26938 {
26939 arg2 = wxString_in_helper(obj1);
26940 if (arg2 == NULL) SWIG_fail;
26941 temp2 = true;
26942 }
26943 {
26944 PyThreadState* __tstate = wxPyBeginAllowThreads();
26945 (arg1)->SetAppName((wxString const &)*arg2);
26946 wxPyEndAllowThreads(__tstate);
26947 if (PyErr_Occurred()) SWIG_fail;
26948 }
26949 resultobj = SWIG_Py_Void();
26950 {
26951 if (temp2)
26952 delete arg2;
26953 }
26954 return resultobj;
26955 fail:
26956 {
26957 if (temp2)
26958 delete arg2;
26959 }
26960 return NULL;
26961 }
26962
26963
26964 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26965 PyObject *resultobj = 0;
26966 wxPyApp *arg1 = (wxPyApp *) 0 ;
26967 wxString result;
26968 void *argp1 = 0 ;
26969 int res1 = 0 ;
26970 PyObject *swig_obj[1] ;
26971
26972 if (!args) SWIG_fail;
26973 swig_obj[0] = args;
26974 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26975 if (!SWIG_IsOK(res1)) {
26976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
26977 }
26978 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26979 {
26980 PyThreadState* __tstate = wxPyBeginAllowThreads();
26981 result = ((wxPyApp const *)arg1)->GetClassName();
26982 wxPyEndAllowThreads(__tstate);
26983 if (PyErr_Occurred()) SWIG_fail;
26984 }
26985 {
26986 #if wxUSE_UNICODE
26987 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26988 #else
26989 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26990 #endif
26991 }
26992 return resultobj;
26993 fail:
26994 return NULL;
26995 }
26996
26997
26998 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26999 PyObject *resultobj = 0;
27000 wxPyApp *arg1 = (wxPyApp *) 0 ;
27001 wxString *arg2 = 0 ;
27002 void *argp1 = 0 ;
27003 int res1 = 0 ;
27004 bool temp2 = false ;
27005 PyObject * obj0 = 0 ;
27006 PyObject * obj1 = 0 ;
27007 char * kwnames[] = {
27008 (char *) "self",(char *) "name", NULL
27009 };
27010
27011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
27012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27013 if (!SWIG_IsOK(res1)) {
27014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27015 }
27016 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27017 {
27018 arg2 = wxString_in_helper(obj1);
27019 if (arg2 == NULL) SWIG_fail;
27020 temp2 = true;
27021 }
27022 {
27023 PyThreadState* __tstate = wxPyBeginAllowThreads();
27024 (arg1)->SetClassName((wxString const &)*arg2);
27025 wxPyEndAllowThreads(__tstate);
27026 if (PyErr_Occurred()) SWIG_fail;
27027 }
27028 resultobj = SWIG_Py_Void();
27029 {
27030 if (temp2)
27031 delete arg2;
27032 }
27033 return resultobj;
27034 fail:
27035 {
27036 if (temp2)
27037 delete arg2;
27038 }
27039 return NULL;
27040 }
27041
27042
27043 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27044 PyObject *resultobj = 0;
27045 wxPyApp *arg1 = (wxPyApp *) 0 ;
27046 wxString *result = 0 ;
27047 void *argp1 = 0 ;
27048 int res1 = 0 ;
27049 PyObject *swig_obj[1] ;
27050
27051 if (!args) SWIG_fail;
27052 swig_obj[0] = args;
27053 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27054 if (!SWIG_IsOK(res1)) {
27055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27056 }
27057 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27058 {
27059 PyThreadState* __tstate = wxPyBeginAllowThreads();
27060 {
27061 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
27062 result = (wxString *) &_result_ref;
27063 }
27064 wxPyEndAllowThreads(__tstate);
27065 if (PyErr_Occurred()) SWIG_fail;
27066 }
27067 {
27068 #if wxUSE_UNICODE
27069 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
27070 #else
27071 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
27072 #endif
27073 }
27074 return resultobj;
27075 fail:
27076 return NULL;
27077 }
27078
27079
27080 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27081 PyObject *resultobj = 0;
27082 wxPyApp *arg1 = (wxPyApp *) 0 ;
27083 wxString *arg2 = 0 ;
27084 void *argp1 = 0 ;
27085 int res1 = 0 ;
27086 bool temp2 = false ;
27087 PyObject * obj0 = 0 ;
27088 PyObject * obj1 = 0 ;
27089 char * kwnames[] = {
27090 (char *) "self",(char *) "name", NULL
27091 };
27092
27093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
27094 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27095 if (!SWIG_IsOK(res1)) {
27096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27097 }
27098 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27099 {
27100 arg2 = wxString_in_helper(obj1);
27101 if (arg2 == NULL) SWIG_fail;
27102 temp2 = true;
27103 }
27104 {
27105 PyThreadState* __tstate = wxPyBeginAllowThreads();
27106 (arg1)->SetVendorName((wxString const &)*arg2);
27107 wxPyEndAllowThreads(__tstate);
27108 if (PyErr_Occurred()) SWIG_fail;
27109 }
27110 resultobj = SWIG_Py_Void();
27111 {
27112 if (temp2)
27113 delete arg2;
27114 }
27115 return resultobj;
27116 fail:
27117 {
27118 if (temp2)
27119 delete arg2;
27120 }
27121 return NULL;
27122 }
27123
27124
27125 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27126 PyObject *resultobj = 0;
27127 wxPyApp *arg1 = (wxPyApp *) 0 ;
27128 wxAppTraits *result = 0 ;
27129 void *argp1 = 0 ;
27130 int res1 = 0 ;
27131 PyObject *swig_obj[1] ;
27132
27133 if (!args) SWIG_fail;
27134 swig_obj[0] = args;
27135 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27136 if (!SWIG_IsOK(res1)) {
27137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
27138 }
27139 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27140 {
27141 PyThreadState* __tstate = wxPyBeginAllowThreads();
27142 result = (wxAppTraits *)(arg1)->GetTraits();
27143 wxPyEndAllowThreads(__tstate);
27144 if (PyErr_Occurred()) SWIG_fail;
27145 }
27146 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
27147 return resultobj;
27148 fail:
27149 return NULL;
27150 }
27151
27152
27153 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27154 PyObject *resultobj = 0;
27155 wxPyApp *arg1 = (wxPyApp *) 0 ;
27156 void *argp1 = 0 ;
27157 int res1 = 0 ;
27158 PyObject *swig_obj[1] ;
27159
27160 if (!args) SWIG_fail;
27161 swig_obj[0] = args;
27162 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27163 if (!SWIG_IsOK(res1)) {
27164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27165 }
27166 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27167 {
27168 PyThreadState* __tstate = wxPyBeginAllowThreads();
27169 (arg1)->ProcessPendingEvents();
27170 wxPyEndAllowThreads(__tstate);
27171 if (PyErr_Occurred()) SWIG_fail;
27172 }
27173 resultobj = SWIG_Py_Void();
27174 return resultobj;
27175 fail:
27176 return NULL;
27177 }
27178
27179
27180 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27181 PyObject *resultobj = 0;
27182 wxPyApp *arg1 = (wxPyApp *) 0 ;
27183 bool arg2 = (bool) false ;
27184 bool result;
27185 void *argp1 = 0 ;
27186 int res1 = 0 ;
27187 bool val2 ;
27188 int ecode2 = 0 ;
27189 PyObject * obj0 = 0 ;
27190 PyObject * obj1 = 0 ;
27191 char * kwnames[] = {
27192 (char *) "self",(char *) "onlyIfNeeded", NULL
27193 };
27194
27195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
27196 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27197 if (!SWIG_IsOK(res1)) {
27198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
27199 }
27200 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27201 if (obj1) {
27202 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27203 if (!SWIG_IsOK(ecode2)) {
27204 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
27205 }
27206 arg2 = static_cast< bool >(val2);
27207 }
27208 {
27209 PyThreadState* __tstate = wxPyBeginAllowThreads();
27210 result = (bool)(arg1)->Yield(arg2);
27211 wxPyEndAllowThreads(__tstate);
27212 if (PyErr_Occurred()) SWIG_fail;
27213 }
27214 {
27215 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27216 }
27217 return resultobj;
27218 fail:
27219 return NULL;
27220 }
27221
27222
27223 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27224 PyObject *resultobj = 0;
27225 wxPyApp *arg1 = (wxPyApp *) 0 ;
27226 void *argp1 = 0 ;
27227 int res1 = 0 ;
27228 PyObject *swig_obj[1] ;
27229
27230 if (!args) SWIG_fail;
27231 swig_obj[0] = args;
27232 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27233 if (!SWIG_IsOK(res1)) {
27234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27235 }
27236 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27237 {
27238 PyThreadState* __tstate = wxPyBeginAllowThreads();
27239 (arg1)->WakeUpIdle();
27240 wxPyEndAllowThreads(__tstate);
27241 if (PyErr_Occurred()) SWIG_fail;
27242 }
27243 resultobj = SWIG_Py_Void();
27244 return resultobj;
27245 fail:
27246 return NULL;
27247 }
27248
27249
27250 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27251 PyObject *resultobj = 0;
27252 bool result;
27253
27254 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
27255 {
27256 PyThreadState* __tstate = wxPyBeginAllowThreads();
27257 result = (bool)wxPyApp::IsMainLoopRunning();
27258 wxPyEndAllowThreads(__tstate);
27259 if (PyErr_Occurred()) SWIG_fail;
27260 }
27261 {
27262 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27263 }
27264 return resultobj;
27265 fail:
27266 return NULL;
27267 }
27268
27269
27270 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27271 PyObject *resultobj = 0;
27272 wxPyApp *arg1 = (wxPyApp *) 0 ;
27273 int result;
27274 void *argp1 = 0 ;
27275 int res1 = 0 ;
27276 PyObject *swig_obj[1] ;
27277
27278 if (!args) SWIG_fail;
27279 swig_obj[0] = args;
27280 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27281 if (!SWIG_IsOK(res1)) {
27282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27283 }
27284 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27285 {
27286 PyThreadState* __tstate = wxPyBeginAllowThreads();
27287 result = (int)(arg1)->MainLoop();
27288 wxPyEndAllowThreads(__tstate);
27289 if (PyErr_Occurred()) SWIG_fail;
27290 }
27291 resultobj = SWIG_From_int(static_cast< int >(result));
27292 return resultobj;
27293 fail:
27294 return NULL;
27295 }
27296
27297
27298 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27299 PyObject *resultobj = 0;
27300 wxPyApp *arg1 = (wxPyApp *) 0 ;
27301 void *argp1 = 0 ;
27302 int res1 = 0 ;
27303 PyObject *swig_obj[1] ;
27304
27305 if (!args) SWIG_fail;
27306 swig_obj[0] = args;
27307 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27308 if (!SWIG_IsOK(res1)) {
27309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
27310 }
27311 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27312 {
27313 PyThreadState* __tstate = wxPyBeginAllowThreads();
27314 (arg1)->Exit();
27315 wxPyEndAllowThreads(__tstate);
27316 if (PyErr_Occurred()) SWIG_fail;
27317 }
27318 resultobj = SWIG_Py_Void();
27319 return resultobj;
27320 fail:
27321 return NULL;
27322 }
27323
27324
27325 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27326 PyObject *resultobj = 0;
27327 wxPyApp *arg1 = (wxPyApp *) 0 ;
27328 void *argp1 = 0 ;
27329 int res1 = 0 ;
27330 PyObject *swig_obj[1] ;
27331
27332 if (!args) SWIG_fail;
27333 swig_obj[0] = args;
27334 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27335 if (!SWIG_IsOK(res1)) {
27336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27337 }
27338 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27339 {
27340 PyThreadState* __tstate = wxPyBeginAllowThreads();
27341 (arg1)->ExitMainLoop();
27342 wxPyEndAllowThreads(__tstate);
27343 if (PyErr_Occurred()) SWIG_fail;
27344 }
27345 resultobj = SWIG_Py_Void();
27346 return resultobj;
27347 fail:
27348 return NULL;
27349 }
27350
27351
27352 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27353 PyObject *resultobj = 0;
27354 wxPyApp *arg1 = (wxPyApp *) 0 ;
27355 bool result;
27356 void *argp1 = 0 ;
27357 int res1 = 0 ;
27358 PyObject *swig_obj[1] ;
27359
27360 if (!args) SWIG_fail;
27361 swig_obj[0] = args;
27362 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27363 if (!SWIG_IsOK(res1)) {
27364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
27365 }
27366 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27367 {
27368 PyThreadState* __tstate = wxPyBeginAllowThreads();
27369 result = (bool)(arg1)->Pending();
27370 wxPyEndAllowThreads(__tstate);
27371 if (PyErr_Occurred()) SWIG_fail;
27372 }
27373 {
27374 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27375 }
27376 return resultobj;
27377 fail:
27378 return NULL;
27379 }
27380
27381
27382 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27383 PyObject *resultobj = 0;
27384 wxPyApp *arg1 = (wxPyApp *) 0 ;
27385 bool result;
27386 void *argp1 = 0 ;
27387 int res1 = 0 ;
27388 PyObject *swig_obj[1] ;
27389
27390 if (!args) SWIG_fail;
27391 swig_obj[0] = args;
27392 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27393 if (!SWIG_IsOK(res1)) {
27394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
27395 }
27396 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27397 {
27398 PyThreadState* __tstate = wxPyBeginAllowThreads();
27399 result = (bool)(arg1)->Dispatch();
27400 wxPyEndAllowThreads(__tstate);
27401 if (PyErr_Occurred()) SWIG_fail;
27402 }
27403 {
27404 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27405 }
27406 return resultobj;
27407 fail:
27408 return NULL;
27409 }
27410
27411
27412 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27413 PyObject *resultobj = 0;
27414 wxPyApp *arg1 = (wxPyApp *) 0 ;
27415 bool result;
27416 void *argp1 = 0 ;
27417 int res1 = 0 ;
27418 PyObject *swig_obj[1] ;
27419
27420 if (!args) SWIG_fail;
27421 swig_obj[0] = args;
27422 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27423 if (!SWIG_IsOK(res1)) {
27424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27425 }
27426 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27427 {
27428 PyThreadState* __tstate = wxPyBeginAllowThreads();
27429 result = (bool)(arg1)->ProcessIdle();
27430 wxPyEndAllowThreads(__tstate);
27431 if (PyErr_Occurred()) SWIG_fail;
27432 }
27433 {
27434 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27435 }
27436 return resultobj;
27437 fail:
27438 return NULL;
27439 }
27440
27441
27442 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27443 PyObject *resultobj = 0;
27444 wxPyApp *arg1 = (wxPyApp *) 0 ;
27445 wxWindow *arg2 = (wxWindow *) 0 ;
27446 wxIdleEvent *arg3 = 0 ;
27447 bool result;
27448 void *argp1 = 0 ;
27449 int res1 = 0 ;
27450 void *argp2 = 0 ;
27451 int res2 = 0 ;
27452 void *argp3 = 0 ;
27453 int res3 = 0 ;
27454 PyObject * obj0 = 0 ;
27455 PyObject * obj1 = 0 ;
27456 PyObject * obj2 = 0 ;
27457 char * kwnames[] = {
27458 (char *) "self",(char *) "win",(char *) "event", NULL
27459 };
27460
27461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27462 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27463 if (!SWIG_IsOK(res1)) {
27464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27465 }
27466 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27467 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27468 if (!SWIG_IsOK(res2)) {
27469 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
27470 }
27471 arg2 = reinterpret_cast< wxWindow * >(argp2);
27472 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
27473 if (!SWIG_IsOK(res3)) {
27474 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27475 }
27476 if (!argp3) {
27477 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27478 }
27479 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
27480 {
27481 PyThreadState* __tstate = wxPyBeginAllowThreads();
27482 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
27483 wxPyEndAllowThreads(__tstate);
27484 if (PyErr_Occurred()) SWIG_fail;
27485 }
27486 {
27487 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27488 }
27489 return resultobj;
27490 fail:
27491 return NULL;
27492 }
27493
27494
27495 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27496 PyObject *resultobj = 0;
27497 wxPyApp *arg1 = (wxPyApp *) 0 ;
27498 bool result;
27499 void *argp1 = 0 ;
27500 int res1 = 0 ;
27501 PyObject *swig_obj[1] ;
27502
27503 if (!args) SWIG_fail;
27504 swig_obj[0] = args;
27505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27506 if (!SWIG_IsOK(res1)) {
27507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27508 }
27509 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27510 {
27511 PyThreadState* __tstate = wxPyBeginAllowThreads();
27512 result = (bool)((wxPyApp const *)arg1)->IsActive();
27513 wxPyEndAllowThreads(__tstate);
27514 if (PyErr_Occurred()) SWIG_fail;
27515 }
27516 {
27517 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27518 }
27519 return resultobj;
27520 fail:
27521 return NULL;
27522 }
27523
27524
27525 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27526 PyObject *resultobj = 0;
27527 wxPyApp *arg1 = (wxPyApp *) 0 ;
27528 wxWindow *arg2 = (wxWindow *) 0 ;
27529 void *argp1 = 0 ;
27530 int res1 = 0 ;
27531 void *argp2 = 0 ;
27532 int res2 = 0 ;
27533 PyObject * obj0 = 0 ;
27534 PyObject * obj1 = 0 ;
27535 char * kwnames[] = {
27536 (char *) "self",(char *) "win", NULL
27537 };
27538
27539 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
27540 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27541 if (!SWIG_IsOK(res1)) {
27542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
27543 }
27544 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27545 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27546 if (!SWIG_IsOK(res2)) {
27547 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
27548 }
27549 arg2 = reinterpret_cast< wxWindow * >(argp2);
27550 {
27551 PyThreadState* __tstate = wxPyBeginAllowThreads();
27552 (arg1)->SetTopWindow(arg2);
27553 wxPyEndAllowThreads(__tstate);
27554 if (PyErr_Occurred()) SWIG_fail;
27555 }
27556 resultobj = SWIG_Py_Void();
27557 return resultobj;
27558 fail:
27559 return NULL;
27560 }
27561
27562
27563 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27564 PyObject *resultobj = 0;
27565 wxPyApp *arg1 = (wxPyApp *) 0 ;
27566 wxWindow *result = 0 ;
27567 void *argp1 = 0 ;
27568 int res1 = 0 ;
27569 PyObject *swig_obj[1] ;
27570
27571 if (!args) SWIG_fail;
27572 swig_obj[0] = args;
27573 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27574 if (!SWIG_IsOK(res1)) {
27575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27576 }
27577 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27578 {
27579 PyThreadState* __tstate = wxPyBeginAllowThreads();
27580 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
27581 wxPyEndAllowThreads(__tstate);
27582 if (PyErr_Occurred()) SWIG_fail;
27583 }
27584 {
27585 resultobj = wxPyMake_wxObject(result, (bool)0);
27586 }
27587 return resultobj;
27588 fail:
27589 return NULL;
27590 }
27591
27592
27593 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27594 PyObject *resultobj = 0;
27595 wxPyApp *arg1 = (wxPyApp *) 0 ;
27596 bool arg2 ;
27597 void *argp1 = 0 ;
27598 int res1 = 0 ;
27599 bool val2 ;
27600 int ecode2 = 0 ;
27601 PyObject * obj0 = 0 ;
27602 PyObject * obj1 = 0 ;
27603 char * kwnames[] = {
27604 (char *) "self",(char *) "flag", NULL
27605 };
27606
27607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
27608 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27609 if (!SWIG_IsOK(res1)) {
27610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
27611 }
27612 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27613 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27614 if (!SWIG_IsOK(ecode2)) {
27615 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
27616 }
27617 arg2 = static_cast< bool >(val2);
27618 {
27619 PyThreadState* __tstate = wxPyBeginAllowThreads();
27620 (arg1)->SetExitOnFrameDelete(arg2);
27621 wxPyEndAllowThreads(__tstate);
27622 if (PyErr_Occurred()) SWIG_fail;
27623 }
27624 resultobj = SWIG_Py_Void();
27625 return resultobj;
27626 fail:
27627 return NULL;
27628 }
27629
27630
27631 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27632 PyObject *resultobj = 0;
27633 wxPyApp *arg1 = (wxPyApp *) 0 ;
27634 bool result;
27635 void *argp1 = 0 ;
27636 int res1 = 0 ;
27637 PyObject *swig_obj[1] ;
27638
27639 if (!args) SWIG_fail;
27640 swig_obj[0] = args;
27641 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27642 if (!SWIG_IsOK(res1)) {
27643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27644 }
27645 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27646 {
27647 PyThreadState* __tstate = wxPyBeginAllowThreads();
27648 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
27649 wxPyEndAllowThreads(__tstate);
27650 if (PyErr_Occurred()) SWIG_fail;
27651 }
27652 {
27653 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27654 }
27655 return resultobj;
27656 fail:
27657 return NULL;
27658 }
27659
27660
27661 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27662 PyObject *resultobj = 0;
27663 wxPyApp *arg1 = (wxPyApp *) 0 ;
27664 bool arg2 ;
27665 void *argp1 = 0 ;
27666 int res1 = 0 ;
27667 bool val2 ;
27668 int ecode2 = 0 ;
27669 PyObject * obj0 = 0 ;
27670 PyObject * obj1 = 0 ;
27671 char * kwnames[] = {
27672 (char *) "self",(char *) "flag", NULL
27673 };
27674
27675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) SWIG_fail;
27676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27677 if (!SWIG_IsOK(res1)) {
27678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
27679 }
27680 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27681 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27682 if (!SWIG_IsOK(ecode2)) {
27683 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
27684 }
27685 arg2 = static_cast< bool >(val2);
27686 {
27687 PyThreadState* __tstate = wxPyBeginAllowThreads();
27688 (arg1)->SetUseBestVisual(arg2);
27689 wxPyEndAllowThreads(__tstate);
27690 if (PyErr_Occurred()) SWIG_fail;
27691 }
27692 resultobj = SWIG_Py_Void();
27693 return resultobj;
27694 fail:
27695 return NULL;
27696 }
27697
27698
27699 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27700 PyObject *resultobj = 0;
27701 wxPyApp *arg1 = (wxPyApp *) 0 ;
27702 bool result;
27703 void *argp1 = 0 ;
27704 int res1 = 0 ;
27705 PyObject *swig_obj[1] ;
27706
27707 if (!args) SWIG_fail;
27708 swig_obj[0] = args;
27709 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27710 if (!SWIG_IsOK(res1)) {
27711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27712 }
27713 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27714 {
27715 PyThreadState* __tstate = wxPyBeginAllowThreads();
27716 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
27717 wxPyEndAllowThreads(__tstate);
27718 if (PyErr_Occurred()) SWIG_fail;
27719 }
27720 {
27721 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27722 }
27723 return resultobj;
27724 fail:
27725 return NULL;
27726 }
27727
27728
27729 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27730 PyObject *resultobj = 0;
27731 wxPyApp *arg1 = (wxPyApp *) 0 ;
27732 int arg2 ;
27733 void *argp1 = 0 ;
27734 int res1 = 0 ;
27735 int val2 ;
27736 int ecode2 = 0 ;
27737 PyObject * obj0 = 0 ;
27738 PyObject * obj1 = 0 ;
27739 char * kwnames[] = {
27740 (char *) "self",(char *) "mode", NULL
27741 };
27742
27743 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
27744 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27745 if (!SWIG_IsOK(res1)) {
27746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27747 }
27748 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27749 ecode2 = SWIG_AsVal_int(obj1, &val2);
27750 if (!SWIG_IsOK(ecode2)) {
27751 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
27752 }
27753 arg2 = static_cast< int >(val2);
27754 {
27755 PyThreadState* __tstate = wxPyBeginAllowThreads();
27756 (arg1)->SetPrintMode(arg2);
27757 wxPyEndAllowThreads(__tstate);
27758 if (PyErr_Occurred()) SWIG_fail;
27759 }
27760 resultobj = SWIG_Py_Void();
27761 return resultobj;
27762 fail:
27763 return NULL;
27764 }
27765
27766
27767 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27768 PyObject *resultobj = 0;
27769 wxPyApp *arg1 = (wxPyApp *) 0 ;
27770 int result;
27771 void *argp1 = 0 ;
27772 int res1 = 0 ;
27773 PyObject *swig_obj[1] ;
27774
27775 if (!args) SWIG_fail;
27776 swig_obj[0] = args;
27777 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27778 if (!SWIG_IsOK(res1)) {
27779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27780 }
27781 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27782 {
27783 PyThreadState* __tstate = wxPyBeginAllowThreads();
27784 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
27785 wxPyEndAllowThreads(__tstate);
27786 if (PyErr_Occurred()) SWIG_fail;
27787 }
27788 resultobj = SWIG_From_int(static_cast< int >(result));
27789 return resultobj;
27790 fail:
27791 return NULL;
27792 }
27793
27794
27795 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27796 PyObject *resultobj = 0;
27797 wxPyApp *arg1 = (wxPyApp *) 0 ;
27798 int arg2 ;
27799 void *argp1 = 0 ;
27800 int res1 = 0 ;
27801 int val2 ;
27802 int ecode2 = 0 ;
27803 PyObject * obj0 = 0 ;
27804 PyObject * obj1 = 0 ;
27805 char * kwnames[] = {
27806 (char *) "self",(char *) "mode", NULL
27807 };
27808
27809 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
27810 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27811 if (!SWIG_IsOK(res1)) {
27812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27813 }
27814 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27815 ecode2 = SWIG_AsVal_int(obj1, &val2);
27816 if (!SWIG_IsOK(ecode2)) {
27817 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
27818 }
27819 arg2 = static_cast< int >(val2);
27820 {
27821 PyThreadState* __tstate = wxPyBeginAllowThreads();
27822 (arg1)->SetAssertMode(arg2);
27823 wxPyEndAllowThreads(__tstate);
27824 if (PyErr_Occurred()) SWIG_fail;
27825 }
27826 resultobj = SWIG_Py_Void();
27827 return resultobj;
27828 fail:
27829 return NULL;
27830 }
27831
27832
27833 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27834 PyObject *resultobj = 0;
27835 wxPyApp *arg1 = (wxPyApp *) 0 ;
27836 int result;
27837 void *argp1 = 0 ;
27838 int res1 = 0 ;
27839 PyObject *swig_obj[1] ;
27840
27841 if (!args) SWIG_fail;
27842 swig_obj[0] = args;
27843 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27844 if (!SWIG_IsOK(res1)) {
27845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27846 }
27847 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27848 {
27849 PyThreadState* __tstate = wxPyBeginAllowThreads();
27850 result = (int)(arg1)->GetAssertMode();
27851 wxPyEndAllowThreads(__tstate);
27852 if (PyErr_Occurred()) SWIG_fail;
27853 }
27854 resultobj = SWIG_From_int(static_cast< int >(result));
27855 return resultobj;
27856 fail:
27857 return NULL;
27858 }
27859
27860
27861 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27862 PyObject *resultobj = 0;
27863 bool result;
27864
27865 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
27866 {
27867 PyThreadState* __tstate = wxPyBeginAllowThreads();
27868 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
27869 wxPyEndAllowThreads(__tstate);
27870 if (PyErr_Occurred()) SWIG_fail;
27871 }
27872 {
27873 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27874 }
27875 return resultobj;
27876 fail:
27877 return NULL;
27878 }
27879
27880
27881 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27882 PyObject *resultobj = 0;
27883 long result;
27884
27885 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
27886 {
27887 PyThreadState* __tstate = wxPyBeginAllowThreads();
27888 result = (long)wxPyApp::GetMacAboutMenuItemId();
27889 wxPyEndAllowThreads(__tstate);
27890 if (PyErr_Occurred()) SWIG_fail;
27891 }
27892 resultobj = SWIG_From_long(static_cast< long >(result));
27893 return resultobj;
27894 fail:
27895 return NULL;
27896 }
27897
27898
27899 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27900 PyObject *resultobj = 0;
27901 long result;
27902
27903 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
27904 {
27905 PyThreadState* __tstate = wxPyBeginAllowThreads();
27906 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
27907 wxPyEndAllowThreads(__tstate);
27908 if (PyErr_Occurred()) SWIG_fail;
27909 }
27910 resultobj = SWIG_From_long(static_cast< long >(result));
27911 return resultobj;
27912 fail:
27913 return NULL;
27914 }
27915
27916
27917 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27918 PyObject *resultobj = 0;
27919 long result;
27920
27921 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
27922 {
27923 PyThreadState* __tstate = wxPyBeginAllowThreads();
27924 result = (long)wxPyApp::GetMacExitMenuItemId();
27925 wxPyEndAllowThreads(__tstate);
27926 if (PyErr_Occurred()) SWIG_fail;
27927 }
27928 resultobj = SWIG_From_long(static_cast< long >(result));
27929 return resultobj;
27930 fail:
27931 return NULL;
27932 }
27933
27934
27935 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27936 PyObject *resultobj = 0;
27937 wxString result;
27938
27939 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
27940 {
27941 PyThreadState* __tstate = wxPyBeginAllowThreads();
27942 result = wxPyApp::GetMacHelpMenuTitleName();
27943 wxPyEndAllowThreads(__tstate);
27944 if (PyErr_Occurred()) SWIG_fail;
27945 }
27946 {
27947 #if wxUSE_UNICODE
27948 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27949 #else
27950 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27951 #endif
27952 }
27953 return resultobj;
27954 fail:
27955 return NULL;
27956 }
27957
27958
27959 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27960 PyObject *resultobj = 0;
27961 bool arg1 ;
27962 bool val1 ;
27963 int ecode1 = 0 ;
27964 PyObject * obj0 = 0 ;
27965 char * kwnames[] = {
27966 (char *) "val", NULL
27967 };
27968
27969 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
27970 ecode1 = SWIG_AsVal_bool(obj0, &val1);
27971 if (!SWIG_IsOK(ecode1)) {
27972 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
27973 }
27974 arg1 = static_cast< bool >(val1);
27975 {
27976 PyThreadState* __tstate = wxPyBeginAllowThreads();
27977 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
27978 wxPyEndAllowThreads(__tstate);
27979 if (PyErr_Occurred()) SWIG_fail;
27980 }
27981 resultobj = SWIG_Py_Void();
27982 return resultobj;
27983 fail:
27984 return NULL;
27985 }
27986
27987
27988 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27989 PyObject *resultobj = 0;
27990 long arg1 ;
27991 long val1 ;
27992 int ecode1 = 0 ;
27993 PyObject * obj0 = 0 ;
27994 char * kwnames[] = {
27995 (char *) "val", NULL
27996 };
27997
27998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
27999 ecode1 = SWIG_AsVal_long(obj0, &val1);
28000 if (!SWIG_IsOK(ecode1)) {
28001 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
28002 }
28003 arg1 = static_cast< long >(val1);
28004 {
28005 PyThreadState* __tstate = wxPyBeginAllowThreads();
28006 wxPyApp::SetMacAboutMenuItemId(arg1);
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_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28018 PyObject *resultobj = 0;
28019 long arg1 ;
28020 long val1 ;
28021 int ecode1 = 0 ;
28022 PyObject * obj0 = 0 ;
28023 char * kwnames[] = {
28024 (char *) "val", NULL
28025 };
28026
28027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
28028 ecode1 = SWIG_AsVal_long(obj0, &val1);
28029 if (!SWIG_IsOK(ecode1)) {
28030 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
28031 }
28032 arg1 = static_cast< long >(val1);
28033 {
28034 PyThreadState* __tstate = wxPyBeginAllowThreads();
28035 wxPyApp::SetMacPreferencesMenuItemId(arg1);
28036 wxPyEndAllowThreads(__tstate);
28037 if (PyErr_Occurred()) SWIG_fail;
28038 }
28039 resultobj = SWIG_Py_Void();
28040 return resultobj;
28041 fail:
28042 return NULL;
28043 }
28044
28045
28046 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28047 PyObject *resultobj = 0;
28048 long arg1 ;
28049 long val1 ;
28050 int ecode1 = 0 ;
28051 PyObject * obj0 = 0 ;
28052 char * kwnames[] = {
28053 (char *) "val", NULL
28054 };
28055
28056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
28057 ecode1 = SWIG_AsVal_long(obj0, &val1);
28058 if (!SWIG_IsOK(ecode1)) {
28059 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
28060 }
28061 arg1 = static_cast< long >(val1);
28062 {
28063 PyThreadState* __tstate = wxPyBeginAllowThreads();
28064 wxPyApp::SetMacExitMenuItemId(arg1);
28065 wxPyEndAllowThreads(__tstate);
28066 if (PyErr_Occurred()) SWIG_fail;
28067 }
28068 resultobj = SWIG_Py_Void();
28069 return resultobj;
28070 fail:
28071 return NULL;
28072 }
28073
28074
28075 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28076 PyObject *resultobj = 0;
28077 wxString *arg1 = 0 ;
28078 bool temp1 = false ;
28079 PyObject * obj0 = 0 ;
28080 char * kwnames[] = {
28081 (char *) "val", NULL
28082 };
28083
28084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
28085 {
28086 arg1 = wxString_in_helper(obj0);
28087 if (arg1 == NULL) SWIG_fail;
28088 temp1 = true;
28089 }
28090 {
28091 PyThreadState* __tstate = wxPyBeginAllowThreads();
28092 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
28093 wxPyEndAllowThreads(__tstate);
28094 if (PyErr_Occurred()) SWIG_fail;
28095 }
28096 resultobj = SWIG_Py_Void();
28097 {
28098 if (temp1)
28099 delete arg1;
28100 }
28101 return resultobj;
28102 fail:
28103 {
28104 if (temp1)
28105 delete arg1;
28106 }
28107 return NULL;
28108 }
28109
28110
28111 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28112 PyObject *resultobj = 0;
28113 wxPyApp *arg1 = (wxPyApp *) 0 ;
28114 void *argp1 = 0 ;
28115 int res1 = 0 ;
28116 PyObject *swig_obj[1] ;
28117
28118 if (!args) SWIG_fail;
28119 swig_obj[0] = args;
28120 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28121 if (!SWIG_IsOK(res1)) {
28122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
28123 }
28124 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28125 {
28126 PyThreadState* __tstate = wxPyBeginAllowThreads();
28127 (arg1)->_BootstrapApp();
28128 wxPyEndAllowThreads(__tstate);
28129 if (PyErr_Occurred()) SWIG_fail;
28130 }
28131 resultobj = SWIG_Py_Void();
28132 return resultobj;
28133 fail:
28134 return NULL;
28135 }
28136
28137
28138 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28139 PyObject *resultobj = 0;
28140 int result;
28141
28142 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
28143 {
28144 PyThreadState* __tstate = wxPyBeginAllowThreads();
28145 result = (int)wxPyApp_GetComCtl32Version();
28146 wxPyEndAllowThreads(__tstate);
28147 if (PyErr_Occurred()) SWIG_fail;
28148 }
28149 resultobj = SWIG_From_int(static_cast< int >(result));
28150 return resultobj;
28151 fail:
28152 return NULL;
28153 }
28154
28155
28156 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28157 PyObject *obj;
28158 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28159 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
28160 return SWIG_Py_Void();
28161 }
28162
28163 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28164 return SWIG_Python_InitShadowInstance(args);
28165 }
28166
28167 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28168 PyObject *resultobj = 0;
28169
28170 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
28171 {
28172 PyThreadState* __tstate = wxPyBeginAllowThreads();
28173 wxExit();
28174 wxPyEndAllowThreads(__tstate);
28175 if (PyErr_Occurred()) SWIG_fail;
28176 }
28177 resultobj = SWIG_Py_Void();
28178 return resultobj;
28179 fail:
28180 return NULL;
28181 }
28182
28183
28184 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28185 PyObject *resultobj = 0;
28186 bool result;
28187
28188 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
28189 {
28190 PyThreadState* __tstate = wxPyBeginAllowThreads();
28191 result = (bool)wxYield();
28192 wxPyEndAllowThreads(__tstate);
28193 if (PyErr_Occurred()) SWIG_fail;
28194 }
28195 {
28196 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28197 }
28198 return resultobj;
28199 fail:
28200 return NULL;
28201 }
28202
28203
28204 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28205 PyObject *resultobj = 0;
28206 bool result;
28207
28208 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
28209 {
28210 PyThreadState* __tstate = wxPyBeginAllowThreads();
28211 result = (bool)wxYieldIfNeeded();
28212 wxPyEndAllowThreads(__tstate);
28213 if (PyErr_Occurred()) SWIG_fail;
28214 }
28215 {
28216 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28217 }
28218 return resultobj;
28219 fail:
28220 return NULL;
28221 }
28222
28223
28224 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28225 PyObject *resultobj = 0;
28226 wxWindow *arg1 = (wxWindow *) NULL ;
28227 bool arg2 = (bool) false ;
28228 bool result;
28229 void *argp1 = 0 ;
28230 int res1 = 0 ;
28231 bool val2 ;
28232 int ecode2 = 0 ;
28233 PyObject * obj0 = 0 ;
28234 PyObject * obj1 = 0 ;
28235 char * kwnames[] = {
28236 (char *) "win",(char *) "onlyIfNeeded", NULL
28237 };
28238
28239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
28240 if (obj0) {
28241 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28242 if (!SWIG_IsOK(res1)) {
28243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
28244 }
28245 arg1 = reinterpret_cast< wxWindow * >(argp1);
28246 }
28247 if (obj1) {
28248 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28249 if (!SWIG_IsOK(ecode2)) {
28250 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
28251 }
28252 arg2 = static_cast< bool >(val2);
28253 }
28254 {
28255 PyThreadState* __tstate = wxPyBeginAllowThreads();
28256 result = (bool)wxSafeYield(arg1,arg2);
28257 wxPyEndAllowThreads(__tstate);
28258 if (PyErr_Occurred()) SWIG_fail;
28259 }
28260 {
28261 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28262 }
28263 return resultobj;
28264 fail:
28265 return NULL;
28266 }
28267
28268
28269 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28270 PyObject *resultobj = 0;
28271
28272 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
28273 {
28274 PyThreadState* __tstate = wxPyBeginAllowThreads();
28275 wxWakeUpIdle();
28276 wxPyEndAllowThreads(__tstate);
28277 if (PyErr_Occurred()) SWIG_fail;
28278 }
28279 resultobj = SWIG_Py_Void();
28280 return resultobj;
28281 fail:
28282 return NULL;
28283 }
28284
28285
28286 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28287 PyObject *resultobj = 0;
28288 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
28289 wxEvent *arg2 = 0 ;
28290 void *argp1 = 0 ;
28291 int res1 = 0 ;
28292 void *argp2 = 0 ;
28293 int res2 = 0 ;
28294 PyObject * obj0 = 0 ;
28295 PyObject * obj1 = 0 ;
28296 char * kwnames[] = {
28297 (char *) "dest",(char *) "event", NULL
28298 };
28299
28300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28301 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
28302 if (!SWIG_IsOK(res1)) {
28303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
28304 }
28305 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
28306 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
28307 if (!SWIG_IsOK(res2)) {
28308 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28309 }
28310 if (!argp2) {
28311 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28312 }
28313 arg2 = reinterpret_cast< wxEvent * >(argp2);
28314 {
28315 PyThreadState* __tstate = wxPyBeginAllowThreads();
28316 wxPostEvent(arg1,*arg2);
28317 wxPyEndAllowThreads(__tstate);
28318 if (PyErr_Occurred()) SWIG_fail;
28319 }
28320 resultobj = SWIG_Py_Void();
28321 return resultobj;
28322 fail:
28323 return NULL;
28324 }
28325
28326
28327 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28328 PyObject *resultobj = 0;
28329
28330 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
28331 {
28332 PyThreadState* __tstate = wxPyBeginAllowThreads();
28333 wxApp_CleanUp();
28334 wxPyEndAllowThreads(__tstate);
28335 if (PyErr_Occurred()) SWIG_fail;
28336 }
28337 resultobj = SWIG_Py_Void();
28338 return resultobj;
28339 fail:
28340 return NULL;
28341 }
28342
28343
28344 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28345 PyObject *resultobj = 0;
28346 wxPyApp *result = 0 ;
28347
28348 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
28349 {
28350 PyThreadState* __tstate = wxPyBeginAllowThreads();
28351 result = (wxPyApp *)wxPyGetApp();
28352 wxPyEndAllowThreads(__tstate);
28353 if (PyErr_Occurred()) SWIG_fail;
28354 }
28355 {
28356 resultobj = wxPyMake_wxObject(result, 0);
28357 }
28358 return resultobj;
28359 fail:
28360 return NULL;
28361 }
28362
28363
28364 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28365 PyObject *resultobj = 0;
28366 char *arg1 = (char *) 0 ;
28367 int res1 ;
28368 char *buf1 = 0 ;
28369 int alloc1 = 0 ;
28370 PyObject * obj0 = 0 ;
28371 char * kwnames[] = {
28372 (char *) "encoding", NULL
28373 };
28374
28375 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
28376 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
28377 if (!SWIG_IsOK(res1)) {
28378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
28379 }
28380 arg1 = buf1;
28381 {
28382 PyThreadState* __tstate = wxPyBeginAllowThreads();
28383 wxSetDefaultPyEncoding((char const *)arg1);
28384 wxPyEndAllowThreads(__tstate);
28385 if (PyErr_Occurred()) SWIG_fail;
28386 }
28387 resultobj = SWIG_Py_Void();
28388 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28389 return resultobj;
28390 fail:
28391 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28392 return NULL;
28393 }
28394
28395
28396 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28397 PyObject *resultobj = 0;
28398 char *result = 0 ;
28399
28400 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
28401 {
28402 PyThreadState* __tstate = wxPyBeginAllowThreads();
28403 result = (char *)wxGetDefaultPyEncoding();
28404 wxPyEndAllowThreads(__tstate);
28405 if (PyErr_Occurred()) SWIG_fail;
28406 }
28407 resultobj = SWIG_FromCharPtr(result);
28408 return resultobj;
28409 fail:
28410 return NULL;
28411 }
28412
28413
28414 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28415 PyObject *resultobj = 0;
28416 wxEventLoop *result = 0 ;
28417
28418 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
28419 {
28420 PyThreadState* __tstate = wxPyBeginAllowThreads();
28421 result = (wxEventLoop *)new wxEventLoop();
28422 wxPyEndAllowThreads(__tstate);
28423 if (PyErr_Occurred()) SWIG_fail;
28424 }
28425 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
28426 return resultobj;
28427 fail:
28428 return NULL;
28429 }
28430
28431
28432 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28433 PyObject *resultobj = 0;
28434 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28435 void *argp1 = 0 ;
28436 int res1 = 0 ;
28437 PyObject *swig_obj[1] ;
28438
28439 if (!args) SWIG_fail;
28440 swig_obj[0] = args;
28441 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
28442 if (!SWIG_IsOK(res1)) {
28443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28444 }
28445 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28446 {
28447 PyThreadState* __tstate = wxPyBeginAllowThreads();
28448 delete arg1;
28449
28450 wxPyEndAllowThreads(__tstate);
28451 if (PyErr_Occurred()) SWIG_fail;
28452 }
28453 resultobj = SWIG_Py_Void();
28454 return resultobj;
28455 fail:
28456 return NULL;
28457 }
28458
28459
28460 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28461 PyObject *resultobj = 0;
28462 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28463 int result;
28464 void *argp1 = 0 ;
28465 int res1 = 0 ;
28466 PyObject *swig_obj[1] ;
28467
28468 if (!args) SWIG_fail;
28469 swig_obj[0] = args;
28470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28471 if (!SWIG_IsOK(res1)) {
28472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28473 }
28474 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28475 {
28476 PyThreadState* __tstate = wxPyBeginAllowThreads();
28477 result = (int)(arg1)->Run();
28478 wxPyEndAllowThreads(__tstate);
28479 if (PyErr_Occurred()) SWIG_fail;
28480 }
28481 resultobj = SWIG_From_int(static_cast< int >(result));
28482 return resultobj;
28483 fail:
28484 return NULL;
28485 }
28486
28487
28488 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28489 PyObject *resultobj = 0;
28490 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28491 int arg2 = (int) 0 ;
28492 void *argp1 = 0 ;
28493 int res1 = 0 ;
28494 int val2 ;
28495 int ecode2 = 0 ;
28496 PyObject * obj0 = 0 ;
28497 PyObject * obj1 = 0 ;
28498 char * kwnames[] = {
28499 (char *) "self",(char *) "rc", NULL
28500 };
28501
28502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
28503 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28504 if (!SWIG_IsOK(res1)) {
28505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28506 }
28507 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28508 if (obj1) {
28509 ecode2 = SWIG_AsVal_int(obj1, &val2);
28510 if (!SWIG_IsOK(ecode2)) {
28511 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
28512 }
28513 arg2 = static_cast< int >(val2);
28514 }
28515 {
28516 PyThreadState* __tstate = wxPyBeginAllowThreads();
28517 (arg1)->Exit(arg2);
28518 wxPyEndAllowThreads(__tstate);
28519 if (PyErr_Occurred()) SWIG_fail;
28520 }
28521 resultobj = SWIG_Py_Void();
28522 return resultobj;
28523 fail:
28524 return NULL;
28525 }
28526
28527
28528 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28529 PyObject *resultobj = 0;
28530 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28531 bool result;
28532 void *argp1 = 0 ;
28533 int res1 = 0 ;
28534 PyObject *swig_obj[1] ;
28535
28536 if (!args) SWIG_fail;
28537 swig_obj[0] = args;
28538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28539 if (!SWIG_IsOK(res1)) {
28540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28541 }
28542 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28543 {
28544 PyThreadState* __tstate = wxPyBeginAllowThreads();
28545 result = (bool)((wxEventLoop const *)arg1)->Pending();
28546 wxPyEndAllowThreads(__tstate);
28547 if (PyErr_Occurred()) SWIG_fail;
28548 }
28549 {
28550 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28551 }
28552 return resultobj;
28553 fail:
28554 return NULL;
28555 }
28556
28557
28558 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28559 PyObject *resultobj = 0;
28560 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28561 bool result;
28562 void *argp1 = 0 ;
28563 int res1 = 0 ;
28564 PyObject *swig_obj[1] ;
28565
28566 if (!args) SWIG_fail;
28567 swig_obj[0] = args;
28568 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28569 if (!SWIG_IsOK(res1)) {
28570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28571 }
28572 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28573 {
28574 PyThreadState* __tstate = wxPyBeginAllowThreads();
28575 result = (bool)(arg1)->Dispatch();
28576 wxPyEndAllowThreads(__tstate);
28577 if (PyErr_Occurred()) SWIG_fail;
28578 }
28579 {
28580 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28581 }
28582 return resultobj;
28583 fail:
28584 return NULL;
28585 }
28586
28587
28588 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28589 PyObject *resultobj = 0;
28590 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28591 bool result;
28592 void *argp1 = 0 ;
28593 int res1 = 0 ;
28594 PyObject *swig_obj[1] ;
28595
28596 if (!args) SWIG_fail;
28597 swig_obj[0] = args;
28598 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28599 if (!SWIG_IsOK(res1)) {
28600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28601 }
28602 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28603 {
28604 PyThreadState* __tstate = wxPyBeginAllowThreads();
28605 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
28606 wxPyEndAllowThreads(__tstate);
28607 if (PyErr_Occurred()) SWIG_fail;
28608 }
28609 {
28610 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28611 }
28612 return resultobj;
28613 fail:
28614 return NULL;
28615 }
28616
28617
28618 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28619 PyObject *resultobj = 0;
28620 wxEventLoop *result = 0 ;
28621
28622 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
28623 {
28624 PyThreadState* __tstate = wxPyBeginAllowThreads();
28625 result = (wxEventLoop *)wxEventLoop::GetActive();
28626 wxPyEndAllowThreads(__tstate);
28627 if (PyErr_Occurred()) SWIG_fail;
28628 }
28629 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
28630 return resultobj;
28631 fail:
28632 return NULL;
28633 }
28634
28635
28636 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28637 PyObject *resultobj = 0;
28638 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28639 void *argp1 = 0 ;
28640 int res1 = 0 ;
28641 PyObject * obj0 = 0 ;
28642 char * kwnames[] = {
28643 (char *) "loop", NULL
28644 };
28645
28646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
28647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28648 if (!SWIG_IsOK(res1)) {
28649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28650 }
28651 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28652 {
28653 PyThreadState* __tstate = wxPyBeginAllowThreads();
28654 wxEventLoop::SetActive(arg1);
28655 wxPyEndAllowThreads(__tstate);
28656 if (PyErr_Occurred()) SWIG_fail;
28657 }
28658 resultobj = SWIG_Py_Void();
28659 return resultobj;
28660 fail:
28661 return NULL;
28662 }
28663
28664
28665 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28666 PyObject *obj;
28667 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28668 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
28669 return SWIG_Py_Void();
28670 }
28671
28672 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28673 return SWIG_Python_InitShadowInstance(args);
28674 }
28675
28676 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28677 PyObject *resultobj = 0;
28678 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28679 wxEventLoopActivator *result = 0 ;
28680 void *argp1 = 0 ;
28681 int res1 = 0 ;
28682 PyObject * obj0 = 0 ;
28683 char * kwnames[] = {
28684 (char *) "evtLoop", NULL
28685 };
28686
28687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
28688 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28689 if (!SWIG_IsOK(res1)) {
28690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28691 }
28692 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28693 {
28694 PyThreadState* __tstate = wxPyBeginAllowThreads();
28695 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
28696 wxPyEndAllowThreads(__tstate);
28697 if (PyErr_Occurred()) SWIG_fail;
28698 }
28699 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
28700 return resultobj;
28701 fail:
28702 return NULL;
28703 }
28704
28705
28706 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28707 PyObject *resultobj = 0;
28708 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
28709 void *argp1 = 0 ;
28710 int res1 = 0 ;
28711 PyObject *swig_obj[1] ;
28712
28713 if (!args) SWIG_fail;
28714 swig_obj[0] = args;
28715 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
28716 if (!SWIG_IsOK(res1)) {
28717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
28718 }
28719 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
28720 {
28721 PyThreadState* __tstate = wxPyBeginAllowThreads();
28722 delete arg1;
28723
28724 wxPyEndAllowThreads(__tstate);
28725 if (PyErr_Occurred()) SWIG_fail;
28726 }
28727 resultobj = SWIG_Py_Void();
28728 return resultobj;
28729 fail:
28730 return NULL;
28731 }
28732
28733
28734 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28735 PyObject *obj;
28736 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28737 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
28738 return SWIG_Py_Void();
28739 }
28740
28741 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28742 return SWIG_Python_InitShadowInstance(args);
28743 }
28744
28745 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28746 PyObject *resultobj = 0;
28747 int arg1 = (int) 0 ;
28748 int arg2 = (int) 0 ;
28749 int arg3 = (int) 0 ;
28750 wxAcceleratorEntry *result = 0 ;
28751 int val1 ;
28752 int ecode1 = 0 ;
28753 int val2 ;
28754 int ecode2 = 0 ;
28755 int val3 ;
28756 int ecode3 = 0 ;
28757 PyObject * obj0 = 0 ;
28758 PyObject * obj1 = 0 ;
28759 PyObject * obj2 = 0 ;
28760 char * kwnames[] = {
28761 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
28762 };
28763
28764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28765 if (obj0) {
28766 ecode1 = SWIG_AsVal_int(obj0, &val1);
28767 if (!SWIG_IsOK(ecode1)) {
28768 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
28769 }
28770 arg1 = static_cast< int >(val1);
28771 }
28772 if (obj1) {
28773 ecode2 = SWIG_AsVal_int(obj1, &val2);
28774 if (!SWIG_IsOK(ecode2)) {
28775 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
28776 }
28777 arg2 = static_cast< int >(val2);
28778 }
28779 if (obj2) {
28780 ecode3 = SWIG_AsVal_int(obj2, &val3);
28781 if (!SWIG_IsOK(ecode3)) {
28782 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
28783 }
28784 arg3 = static_cast< int >(val3);
28785 }
28786 {
28787 PyThreadState* __tstate = wxPyBeginAllowThreads();
28788 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
28789 wxPyEndAllowThreads(__tstate);
28790 if (PyErr_Occurred()) SWIG_fail;
28791 }
28792 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
28793 return resultobj;
28794 fail:
28795 return NULL;
28796 }
28797
28798
28799 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28800 PyObject *resultobj = 0;
28801 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28802 void *argp1 = 0 ;
28803 int res1 = 0 ;
28804 PyObject *swig_obj[1] ;
28805
28806 if (!args) SWIG_fail;
28807 swig_obj[0] = args;
28808 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
28809 if (!SWIG_IsOK(res1)) {
28810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28811 }
28812 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28813 {
28814 PyThreadState* __tstate = wxPyBeginAllowThreads();
28815 delete arg1;
28816
28817 wxPyEndAllowThreads(__tstate);
28818 if (PyErr_Occurred()) SWIG_fail;
28819 }
28820 resultobj = SWIG_Py_Void();
28821 return resultobj;
28822 fail:
28823 return NULL;
28824 }
28825
28826
28827 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28828 PyObject *resultobj = 0;
28829 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28830 int arg2 ;
28831 int arg3 ;
28832 int arg4 ;
28833 void *argp1 = 0 ;
28834 int res1 = 0 ;
28835 int val2 ;
28836 int ecode2 = 0 ;
28837 int val3 ;
28838 int ecode3 = 0 ;
28839 int val4 ;
28840 int ecode4 = 0 ;
28841 PyObject * obj0 = 0 ;
28842 PyObject * obj1 = 0 ;
28843 PyObject * obj2 = 0 ;
28844 PyObject * obj3 = 0 ;
28845 char * kwnames[] = {
28846 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
28847 };
28848
28849 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28850 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28851 if (!SWIG_IsOK(res1)) {
28852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28853 }
28854 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28855 ecode2 = SWIG_AsVal_int(obj1, &val2);
28856 if (!SWIG_IsOK(ecode2)) {
28857 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
28858 }
28859 arg2 = static_cast< int >(val2);
28860 ecode3 = SWIG_AsVal_int(obj2, &val3);
28861 if (!SWIG_IsOK(ecode3)) {
28862 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
28863 }
28864 arg3 = static_cast< int >(val3);
28865 ecode4 = SWIG_AsVal_int(obj3, &val4);
28866 if (!SWIG_IsOK(ecode4)) {
28867 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
28868 }
28869 arg4 = static_cast< int >(val4);
28870 {
28871 PyThreadState* __tstate = wxPyBeginAllowThreads();
28872 (arg1)->Set(arg2,arg3,arg4);
28873 wxPyEndAllowThreads(__tstate);
28874 if (PyErr_Occurred()) SWIG_fail;
28875 }
28876 resultobj = SWIG_Py_Void();
28877 return resultobj;
28878 fail:
28879 return NULL;
28880 }
28881
28882
28883 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28884 PyObject *resultobj = 0;
28885 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28886 int result;
28887 void *argp1 = 0 ;
28888 int res1 = 0 ;
28889 PyObject *swig_obj[1] ;
28890
28891 if (!args) SWIG_fail;
28892 swig_obj[0] = args;
28893 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28894 if (!SWIG_IsOK(res1)) {
28895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28896 }
28897 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28898 {
28899 PyThreadState* __tstate = wxPyBeginAllowThreads();
28900 result = (int)(arg1)->GetFlags();
28901 wxPyEndAllowThreads(__tstate);
28902 if (PyErr_Occurred()) SWIG_fail;
28903 }
28904 resultobj = SWIG_From_int(static_cast< int >(result));
28905 return resultobj;
28906 fail:
28907 return NULL;
28908 }
28909
28910
28911 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28912 PyObject *resultobj = 0;
28913 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28914 int result;
28915 void *argp1 = 0 ;
28916 int res1 = 0 ;
28917 PyObject *swig_obj[1] ;
28918
28919 if (!args) SWIG_fail;
28920 swig_obj[0] = args;
28921 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28922 if (!SWIG_IsOK(res1)) {
28923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28924 }
28925 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28926 {
28927 PyThreadState* __tstate = wxPyBeginAllowThreads();
28928 result = (int)(arg1)->GetKeyCode();
28929 wxPyEndAllowThreads(__tstate);
28930 if (PyErr_Occurred()) SWIG_fail;
28931 }
28932 resultobj = SWIG_From_int(static_cast< int >(result));
28933 return resultobj;
28934 fail:
28935 return NULL;
28936 }
28937
28938
28939 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28940 PyObject *resultobj = 0;
28941 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28942 int result;
28943 void *argp1 = 0 ;
28944 int res1 = 0 ;
28945 PyObject *swig_obj[1] ;
28946
28947 if (!args) SWIG_fail;
28948 swig_obj[0] = args;
28949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28950 if (!SWIG_IsOK(res1)) {
28951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28952 }
28953 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28954 {
28955 PyThreadState* __tstate = wxPyBeginAllowThreads();
28956 result = (int)(arg1)->GetCommand();
28957 wxPyEndAllowThreads(__tstate);
28958 if (PyErr_Occurred()) SWIG_fail;
28959 }
28960 resultobj = SWIG_From_int(static_cast< int >(result));
28961 return resultobj;
28962 fail:
28963 return NULL;
28964 }
28965
28966
28967 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28968 PyObject *obj;
28969 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28970 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
28971 return SWIG_Py_Void();
28972 }
28973
28974 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28975 return SWIG_Python_InitShadowInstance(args);
28976 }
28977
28978 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28979 PyObject *resultobj = 0;
28980 int arg1 ;
28981 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
28982 wxAcceleratorTable *result = 0 ;
28983 PyObject * obj0 = 0 ;
28984 char * kwnames[] = {
28985 (char *) "n", NULL
28986 };
28987
28988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
28989 {
28990 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
28991 if (arg2) arg1 = PyList_Size(obj0);
28992 else arg1 = 0;
28993 }
28994 {
28995 PyThreadState* __tstate = wxPyBeginAllowThreads();
28996 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
28997 wxPyEndAllowThreads(__tstate);
28998 if (PyErr_Occurred()) SWIG_fail;
28999 }
29000 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
29001 return resultobj;
29002 fail:
29003 return NULL;
29004 }
29005
29006
29007 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29008 PyObject *resultobj = 0;
29009 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29010 void *argp1 = 0 ;
29011 int res1 = 0 ;
29012 PyObject *swig_obj[1] ;
29013
29014 if (!args) SWIG_fail;
29015 swig_obj[0] = args;
29016 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
29017 if (!SWIG_IsOK(res1)) {
29018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
29019 }
29020 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29021 {
29022 PyThreadState* __tstate = wxPyBeginAllowThreads();
29023 delete arg1;
29024
29025 wxPyEndAllowThreads(__tstate);
29026 if (PyErr_Occurred()) SWIG_fail;
29027 }
29028 resultobj = SWIG_Py_Void();
29029 return resultobj;
29030 fail:
29031 return NULL;
29032 }
29033
29034
29035 SWIGINTERN PyObject *_wrap_AcceleratorTable_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29036 PyObject *resultobj = 0;
29037 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29038 bool result;
29039 void *argp1 = 0 ;
29040 int res1 = 0 ;
29041 PyObject *swig_obj[1] ;
29042
29043 if (!args) SWIG_fail;
29044 swig_obj[0] = args;
29045 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
29046 if (!SWIG_IsOK(res1)) {
29047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_Ok" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
29048 }
29049 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29050 {
29051 PyThreadState* __tstate = wxPyBeginAllowThreads();
29052 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
29053 wxPyEndAllowThreads(__tstate);
29054 if (PyErr_Occurred()) SWIG_fail;
29055 }
29056 {
29057 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29058 }
29059 return resultobj;
29060 fail:
29061 return NULL;
29062 }
29063
29064
29065 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29066 PyObject *obj;
29067 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29068 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
29069 return SWIG_Py_Void();
29070 }
29071
29072 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29073 return SWIG_Python_InitShadowInstance(args);
29074 }
29075
29076 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
29077 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
29078 return 1;
29079 }
29080
29081
29082 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
29083 PyObject *pyobj = 0;
29084
29085 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
29086 return pyobj;
29087 }
29088
29089
29090 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29091 PyObject *resultobj = 0;
29092 wxString *arg1 = 0 ;
29093 wxAcceleratorEntry *result = 0 ;
29094 bool temp1 = false ;
29095 PyObject * obj0 = 0 ;
29096 char * kwnames[] = {
29097 (char *) "label", NULL
29098 };
29099
29100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
29101 {
29102 arg1 = wxString_in_helper(obj0);
29103 if (arg1 == NULL) SWIG_fail;
29104 temp1 = true;
29105 }
29106 {
29107 PyThreadState* __tstate = wxPyBeginAllowThreads();
29108 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
29109 wxPyEndAllowThreads(__tstate);
29110 if (PyErr_Occurred()) SWIG_fail;
29111 }
29112 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29113 {
29114 if (temp1)
29115 delete arg1;
29116 }
29117 return resultobj;
29118 fail:
29119 {
29120 if (temp1)
29121 delete arg1;
29122 }
29123 return NULL;
29124 }
29125
29126
29127 SWIGINTERN int PanelNameStr_set(PyObject *) {
29128 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
29129 return 1;
29130 }
29131
29132
29133 SWIGINTERN PyObject *PanelNameStr_get(void) {
29134 PyObject *pyobj = 0;
29135
29136 {
29137 #if wxUSE_UNICODE
29138 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29139 #else
29140 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29141 #endif
29142 }
29143 return pyobj;
29144 }
29145
29146
29147 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29148 PyObject *resultobj = 0;
29149 wxVisualAttributes *result = 0 ;
29150
29151 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
29152 {
29153 PyThreadState* __tstate = wxPyBeginAllowThreads();
29154 result = (wxVisualAttributes *)new_wxVisualAttributes();
29155 wxPyEndAllowThreads(__tstate);
29156 if (PyErr_Occurred()) SWIG_fail;
29157 }
29158 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
29159 return resultobj;
29160 fail:
29161 return NULL;
29162 }
29163
29164
29165 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29166 PyObject *resultobj = 0;
29167 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29168 void *argp1 = 0 ;
29169 int res1 = 0 ;
29170 PyObject *swig_obj[1] ;
29171
29172 if (!args) SWIG_fail;
29173 swig_obj[0] = args;
29174 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
29175 if (!SWIG_IsOK(res1)) {
29176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29177 }
29178 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29179 {
29180 PyThreadState* __tstate = wxPyBeginAllowThreads();
29181 delete_wxVisualAttributes(arg1);
29182
29183 wxPyEndAllowThreads(__tstate);
29184 if (PyErr_Occurred()) SWIG_fail;
29185 }
29186 resultobj = SWIG_Py_Void();
29187 return resultobj;
29188 fail:
29189 return NULL;
29190 }
29191
29192
29193 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29194 PyObject *resultobj = 0;
29195 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29196 wxFont *arg2 = (wxFont *) 0 ;
29197 void *argp1 = 0 ;
29198 int res1 = 0 ;
29199 void *argp2 = 0 ;
29200 int res2 = 0 ;
29201 PyObject *swig_obj[2] ;
29202
29203 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
29204 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29205 if (!SWIG_IsOK(res1)) {
29206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29207 }
29208 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29209 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
29210 if (!SWIG_IsOK(res2)) {
29211 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
29212 }
29213 arg2 = reinterpret_cast< wxFont * >(argp2);
29214 if (arg1) (arg1)->font = *arg2;
29215
29216 resultobj = SWIG_Py_Void();
29217 return resultobj;
29218 fail:
29219 return NULL;
29220 }
29221
29222
29223 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29224 PyObject *resultobj = 0;
29225 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29226 wxFont *result = 0 ;
29227 void *argp1 = 0 ;
29228 int res1 = 0 ;
29229 PyObject *swig_obj[1] ;
29230
29231 if (!args) SWIG_fail;
29232 swig_obj[0] = args;
29233 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29234 if (!SWIG_IsOK(res1)) {
29235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29236 }
29237 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29238 result = (wxFont *)& ((arg1)->font);
29239 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
29240 return resultobj;
29241 fail:
29242 return NULL;
29243 }
29244
29245
29246 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29247 PyObject *resultobj = 0;
29248 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29249 wxColour *arg2 = (wxColour *) 0 ;
29250 void *argp1 = 0 ;
29251 int res1 = 0 ;
29252 void *argp2 = 0 ;
29253 int res2 = 0 ;
29254 PyObject *swig_obj[2] ;
29255
29256 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
29257 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29258 if (!SWIG_IsOK(res1)) {
29259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29260 }
29261 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29262 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29263 if (!SWIG_IsOK(res2)) {
29264 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29265 }
29266 arg2 = reinterpret_cast< wxColour * >(argp2);
29267 if (arg1) (arg1)->colFg = *arg2;
29268
29269 resultobj = SWIG_Py_Void();
29270 return resultobj;
29271 fail:
29272 return NULL;
29273 }
29274
29275
29276 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29277 PyObject *resultobj = 0;
29278 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29279 wxColour *result = 0 ;
29280 void *argp1 = 0 ;
29281 int res1 = 0 ;
29282 PyObject *swig_obj[1] ;
29283
29284 if (!args) SWIG_fail;
29285 swig_obj[0] = args;
29286 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29287 if (!SWIG_IsOK(res1)) {
29288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29289 }
29290 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29291 result = (wxColour *)& ((arg1)->colFg);
29292 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29293 return resultobj;
29294 fail:
29295 return NULL;
29296 }
29297
29298
29299 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29300 PyObject *resultobj = 0;
29301 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29302 wxColour *arg2 = (wxColour *) 0 ;
29303 void *argp1 = 0 ;
29304 int res1 = 0 ;
29305 void *argp2 = 0 ;
29306 int res2 = 0 ;
29307 PyObject *swig_obj[2] ;
29308
29309 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
29310 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29311 if (!SWIG_IsOK(res1)) {
29312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29313 }
29314 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29315 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29316 if (!SWIG_IsOK(res2)) {
29317 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29318 }
29319 arg2 = reinterpret_cast< wxColour * >(argp2);
29320 if (arg1) (arg1)->colBg = *arg2;
29321
29322 resultobj = SWIG_Py_Void();
29323 return resultobj;
29324 fail:
29325 return NULL;
29326 }
29327
29328
29329 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29330 PyObject *resultobj = 0;
29331 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29332 wxColour *result = 0 ;
29333 void *argp1 = 0 ;
29334 int res1 = 0 ;
29335 PyObject *swig_obj[1] ;
29336
29337 if (!args) SWIG_fail;
29338 swig_obj[0] = args;
29339 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29340 if (!SWIG_IsOK(res1)) {
29341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29342 }
29343 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29344 result = (wxColour *)& ((arg1)->colBg);
29345 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29346 return resultobj;
29347 fail:
29348 return NULL;
29349 }
29350
29351
29352 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29353 PyObject *obj;
29354 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29355 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
29356 return SWIG_Py_Void();
29357 }
29358
29359 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29360 return SWIG_Python_InitShadowInstance(args);
29361 }
29362
29363 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29364 PyObject *resultobj = 0;
29365 wxWindow *arg1 = (wxWindow *) 0 ;
29366 int arg2 = (int) (int)-1 ;
29367 wxPoint const &arg3_defvalue = wxDefaultPosition ;
29368 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
29369 wxSize const &arg4_defvalue = wxDefaultSize ;
29370 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
29371 long arg5 = (long) 0 ;
29372 wxString const &arg6_defvalue = wxPyPanelNameStr ;
29373 wxString *arg6 = (wxString *) &arg6_defvalue ;
29374 wxWindow *result = 0 ;
29375 void *argp1 = 0 ;
29376 int res1 = 0 ;
29377 int val2 ;
29378 int ecode2 = 0 ;
29379 wxPoint temp3 ;
29380 wxSize temp4 ;
29381 long val5 ;
29382 int ecode5 = 0 ;
29383 bool temp6 = false ;
29384 PyObject * obj0 = 0 ;
29385 PyObject * obj1 = 0 ;
29386 PyObject * obj2 = 0 ;
29387 PyObject * obj3 = 0 ;
29388 PyObject * obj4 = 0 ;
29389 PyObject * obj5 = 0 ;
29390 char * kwnames[] = {
29391 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29392 };
29393
29394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
29395 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29396 if (!SWIG_IsOK(res1)) {
29397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
29398 }
29399 arg1 = reinterpret_cast< wxWindow * >(argp1);
29400 if (obj1) {
29401 ecode2 = SWIG_AsVal_int(obj1, &val2);
29402 if (!SWIG_IsOK(ecode2)) {
29403 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
29404 }
29405 arg2 = static_cast< int >(val2);
29406 }
29407 if (obj2) {
29408 {
29409 arg3 = &temp3;
29410 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29411 }
29412 }
29413 if (obj3) {
29414 {
29415 arg4 = &temp4;
29416 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
29417 }
29418 }
29419 if (obj4) {
29420 ecode5 = SWIG_AsVal_long(obj4, &val5);
29421 if (!SWIG_IsOK(ecode5)) {
29422 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
29423 }
29424 arg5 = static_cast< long >(val5);
29425 }
29426 if (obj5) {
29427 {
29428 arg6 = wxString_in_helper(obj5);
29429 if (arg6 == NULL) SWIG_fail;
29430 temp6 = true;
29431 }
29432 }
29433 {
29434 if (!wxPyCheckForApp()) SWIG_fail;
29435 PyThreadState* __tstate = wxPyBeginAllowThreads();
29436 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
29437 wxPyEndAllowThreads(__tstate);
29438 if (PyErr_Occurred()) SWIG_fail;
29439 }
29440 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
29441 {
29442 if (temp6)
29443 delete arg6;
29444 }
29445 return resultobj;
29446 fail:
29447 {
29448 if (temp6)
29449 delete arg6;
29450 }
29451 return NULL;
29452 }
29453
29454
29455 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29456 PyObject *resultobj = 0;
29457 wxWindow *result = 0 ;
29458
29459 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
29460 {
29461 if (!wxPyCheckForApp()) SWIG_fail;
29462 PyThreadState* __tstate = wxPyBeginAllowThreads();
29463 result = (wxWindow *)new wxWindow();
29464 wxPyEndAllowThreads(__tstate);
29465 if (PyErr_Occurred()) SWIG_fail;
29466 }
29467 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
29468 return resultobj;
29469 fail:
29470 return NULL;
29471 }
29472
29473
29474 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29475 PyObject *resultobj = 0;
29476 wxWindow *arg1 = (wxWindow *) 0 ;
29477 wxWindow *arg2 = (wxWindow *) 0 ;
29478 int arg3 = (int) (int)-1 ;
29479 wxPoint const &arg4_defvalue = wxDefaultPosition ;
29480 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
29481 wxSize const &arg5_defvalue = wxDefaultSize ;
29482 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
29483 long arg6 = (long) 0 ;
29484 wxString const &arg7_defvalue = wxPyPanelNameStr ;
29485 wxString *arg7 = (wxString *) &arg7_defvalue ;
29486 bool result;
29487 void *argp1 = 0 ;
29488 int res1 = 0 ;
29489 void *argp2 = 0 ;
29490 int res2 = 0 ;
29491 int val3 ;
29492 int ecode3 = 0 ;
29493 wxPoint temp4 ;
29494 wxSize temp5 ;
29495 long val6 ;
29496 int ecode6 = 0 ;
29497 bool temp7 = false ;
29498 PyObject * obj0 = 0 ;
29499 PyObject * obj1 = 0 ;
29500 PyObject * obj2 = 0 ;
29501 PyObject * obj3 = 0 ;
29502 PyObject * obj4 = 0 ;
29503 PyObject * obj5 = 0 ;
29504 PyObject * obj6 = 0 ;
29505 char * kwnames[] = {
29506 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29507 };
29508
29509 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
29510 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29511 if (!SWIG_IsOK(res1)) {
29512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
29513 }
29514 arg1 = reinterpret_cast< wxWindow * >(argp1);
29515 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
29516 if (!SWIG_IsOK(res2)) {
29517 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
29518 }
29519 arg2 = reinterpret_cast< wxWindow * >(argp2);
29520 if (obj2) {
29521 ecode3 = SWIG_AsVal_int(obj2, &val3);
29522 if (!SWIG_IsOK(ecode3)) {
29523 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
29524 }
29525 arg3 = static_cast< int >(val3);
29526 }
29527 if (obj3) {
29528 {
29529 arg4 = &temp4;
29530 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
29531 }
29532 }
29533 if (obj4) {
29534 {
29535 arg5 = &temp5;
29536 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
29537 }
29538 }
29539 if (obj5) {
29540 ecode6 = SWIG_AsVal_long(obj5, &val6);
29541 if (!SWIG_IsOK(ecode6)) {
29542 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
29543 }
29544 arg6 = static_cast< long >(val6);
29545 }
29546 if (obj6) {
29547 {
29548 arg7 = wxString_in_helper(obj6);
29549 if (arg7 == NULL) SWIG_fail;
29550 temp7 = true;
29551 }
29552 }
29553 {
29554 PyThreadState* __tstate = wxPyBeginAllowThreads();
29555 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
29556 wxPyEndAllowThreads(__tstate);
29557 if (PyErr_Occurred()) SWIG_fail;
29558 }
29559 {
29560 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29561 }
29562 {
29563 if (temp7)
29564 delete arg7;
29565 }
29566 return resultobj;
29567 fail:
29568 {
29569 if (temp7)
29570 delete arg7;
29571 }
29572 return NULL;
29573 }
29574
29575
29576 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29577 PyObject *resultobj = 0;
29578 wxWindow *arg1 = (wxWindow *) 0 ;
29579 bool arg2 = (bool) false ;
29580 bool result;
29581 void *argp1 = 0 ;
29582 int res1 = 0 ;
29583 bool val2 ;
29584 int ecode2 = 0 ;
29585 PyObject * obj0 = 0 ;
29586 PyObject * obj1 = 0 ;
29587 char * kwnames[] = {
29588 (char *) "self",(char *) "force", NULL
29589 };
29590
29591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
29592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29593 if (!SWIG_IsOK(res1)) {
29594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
29595 }
29596 arg1 = reinterpret_cast< wxWindow * >(argp1);
29597 if (obj1) {
29598 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29599 if (!SWIG_IsOK(ecode2)) {
29600 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
29601 }
29602 arg2 = static_cast< bool >(val2);
29603 }
29604 {
29605 PyThreadState* __tstate = wxPyBeginAllowThreads();
29606 result = (bool)(arg1)->Close(arg2);
29607 wxPyEndAllowThreads(__tstate);
29608 if (PyErr_Occurred()) SWIG_fail;
29609 }
29610 {
29611 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29612 }
29613 return resultobj;
29614 fail:
29615 return NULL;
29616 }
29617
29618
29619 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29620 PyObject *resultobj = 0;
29621 wxWindow *arg1 = (wxWindow *) 0 ;
29622 bool result;
29623 void *argp1 = 0 ;
29624 int res1 = 0 ;
29625 PyObject *swig_obj[1] ;
29626
29627 if (!args) SWIG_fail;
29628 swig_obj[0] = args;
29629 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29630 if (!SWIG_IsOK(res1)) {
29631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
29632 }
29633 arg1 = reinterpret_cast< wxWindow * >(argp1);
29634 {
29635 PyThreadState* __tstate = wxPyBeginAllowThreads();
29636 result = (bool)(arg1)->Destroy();
29637 wxPyEndAllowThreads(__tstate);
29638 if (PyErr_Occurred()) SWIG_fail;
29639 }
29640 {
29641 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29642 }
29643 return resultobj;
29644 fail:
29645 return NULL;
29646 }
29647
29648
29649 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29650 PyObject *resultobj = 0;
29651 wxWindow *arg1 = (wxWindow *) 0 ;
29652 bool result;
29653 void *argp1 = 0 ;
29654 int res1 = 0 ;
29655 PyObject *swig_obj[1] ;
29656
29657 if (!args) SWIG_fail;
29658 swig_obj[0] = args;
29659 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29660 if (!SWIG_IsOK(res1)) {
29661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
29662 }
29663 arg1 = reinterpret_cast< wxWindow * >(argp1);
29664 {
29665 PyThreadState* __tstate = wxPyBeginAllowThreads();
29666 result = (bool)(arg1)->DestroyChildren();
29667 wxPyEndAllowThreads(__tstate);
29668 if (PyErr_Occurred()) SWIG_fail;
29669 }
29670 {
29671 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29672 }
29673 return resultobj;
29674 fail:
29675 return NULL;
29676 }
29677
29678
29679 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29680 PyObject *resultobj = 0;
29681 wxWindow *arg1 = (wxWindow *) 0 ;
29682 bool result;
29683 void *argp1 = 0 ;
29684 int res1 = 0 ;
29685 PyObject *swig_obj[1] ;
29686
29687 if (!args) SWIG_fail;
29688 swig_obj[0] = args;
29689 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29690 if (!SWIG_IsOK(res1)) {
29691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
29692 }
29693 arg1 = reinterpret_cast< wxWindow * >(argp1);
29694 {
29695 PyThreadState* __tstate = wxPyBeginAllowThreads();
29696 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
29697 wxPyEndAllowThreads(__tstate);
29698 if (PyErr_Occurred()) SWIG_fail;
29699 }
29700 {
29701 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29702 }
29703 return resultobj;
29704 fail:
29705 return NULL;
29706 }
29707
29708
29709 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29710 PyObject *resultobj = 0;
29711 wxWindow *arg1 = (wxWindow *) 0 ;
29712 wxString *arg2 = 0 ;
29713 void *argp1 = 0 ;
29714 int res1 = 0 ;
29715 bool temp2 = false ;
29716 PyObject * obj0 = 0 ;
29717 PyObject * obj1 = 0 ;
29718 char * kwnames[] = {
29719 (char *) "self",(char *) "label", NULL
29720 };
29721
29722 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
29723 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29724 if (!SWIG_IsOK(res1)) {
29725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
29726 }
29727 arg1 = reinterpret_cast< wxWindow * >(argp1);
29728 {
29729 arg2 = wxString_in_helper(obj1);
29730 if (arg2 == NULL) SWIG_fail;
29731 temp2 = true;
29732 }
29733 {
29734 PyThreadState* __tstate = wxPyBeginAllowThreads();
29735 (arg1)->SetLabel((wxString const &)*arg2);
29736 wxPyEndAllowThreads(__tstate);
29737 if (PyErr_Occurred()) SWIG_fail;
29738 }
29739 resultobj = SWIG_Py_Void();
29740 {
29741 if (temp2)
29742 delete arg2;
29743 }
29744 return resultobj;
29745 fail:
29746 {
29747 if (temp2)
29748 delete arg2;
29749 }
29750 return NULL;
29751 }
29752
29753
29754 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29755 PyObject *resultobj = 0;
29756 wxWindow *arg1 = (wxWindow *) 0 ;
29757 wxString result;
29758 void *argp1 = 0 ;
29759 int res1 = 0 ;
29760 PyObject *swig_obj[1] ;
29761
29762 if (!args) SWIG_fail;
29763 swig_obj[0] = args;
29764 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29765 if (!SWIG_IsOK(res1)) {
29766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
29767 }
29768 arg1 = reinterpret_cast< wxWindow * >(argp1);
29769 {
29770 PyThreadState* __tstate = wxPyBeginAllowThreads();
29771 result = ((wxWindow const *)arg1)->GetLabel();
29772 wxPyEndAllowThreads(__tstate);
29773 if (PyErr_Occurred()) SWIG_fail;
29774 }
29775 {
29776 #if wxUSE_UNICODE
29777 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29778 #else
29779 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29780 #endif
29781 }
29782 return resultobj;
29783 fail:
29784 return NULL;
29785 }
29786
29787
29788 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29789 PyObject *resultobj = 0;
29790 wxWindow *arg1 = (wxWindow *) 0 ;
29791 wxString *arg2 = 0 ;
29792 void *argp1 = 0 ;
29793 int res1 = 0 ;
29794 bool temp2 = false ;
29795 PyObject * obj0 = 0 ;
29796 PyObject * obj1 = 0 ;
29797 char * kwnames[] = {
29798 (char *) "self",(char *) "name", NULL
29799 };
29800
29801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
29802 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29803 if (!SWIG_IsOK(res1)) {
29804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
29805 }
29806 arg1 = reinterpret_cast< wxWindow * >(argp1);
29807 {
29808 arg2 = wxString_in_helper(obj1);
29809 if (arg2 == NULL) SWIG_fail;
29810 temp2 = true;
29811 }
29812 {
29813 PyThreadState* __tstate = wxPyBeginAllowThreads();
29814 (arg1)->SetName((wxString const &)*arg2);
29815 wxPyEndAllowThreads(__tstate);
29816 if (PyErr_Occurred()) SWIG_fail;
29817 }
29818 resultobj = SWIG_Py_Void();
29819 {
29820 if (temp2)
29821 delete arg2;
29822 }
29823 return resultobj;
29824 fail:
29825 {
29826 if (temp2)
29827 delete arg2;
29828 }
29829 return NULL;
29830 }
29831
29832
29833 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29834 PyObject *resultobj = 0;
29835 wxWindow *arg1 = (wxWindow *) 0 ;
29836 wxString result;
29837 void *argp1 = 0 ;
29838 int res1 = 0 ;
29839 PyObject *swig_obj[1] ;
29840
29841 if (!args) SWIG_fail;
29842 swig_obj[0] = args;
29843 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29844 if (!SWIG_IsOK(res1)) {
29845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
29846 }
29847 arg1 = reinterpret_cast< wxWindow * >(argp1);
29848 {
29849 PyThreadState* __tstate = wxPyBeginAllowThreads();
29850 result = ((wxWindow const *)arg1)->GetName();
29851 wxPyEndAllowThreads(__tstate);
29852 if (PyErr_Occurred()) SWIG_fail;
29853 }
29854 {
29855 #if wxUSE_UNICODE
29856 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29857 #else
29858 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29859 #endif
29860 }
29861 return resultobj;
29862 fail:
29863 return NULL;
29864 }
29865
29866
29867 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29868 PyObject *resultobj = 0;
29869 wxWindow *arg1 = (wxWindow *) 0 ;
29870 wxWindowVariant arg2 ;
29871 void *argp1 = 0 ;
29872 int res1 = 0 ;
29873 int val2 ;
29874 int ecode2 = 0 ;
29875 PyObject * obj0 = 0 ;
29876 PyObject * obj1 = 0 ;
29877 char * kwnames[] = {
29878 (char *) "self",(char *) "variant", NULL
29879 };
29880
29881 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
29882 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29883 if (!SWIG_IsOK(res1)) {
29884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
29885 }
29886 arg1 = reinterpret_cast< wxWindow * >(argp1);
29887 ecode2 = SWIG_AsVal_int(obj1, &val2);
29888 if (!SWIG_IsOK(ecode2)) {
29889 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
29890 }
29891 arg2 = static_cast< wxWindowVariant >(val2);
29892 {
29893 PyThreadState* __tstate = wxPyBeginAllowThreads();
29894 (arg1)->SetWindowVariant(arg2);
29895 wxPyEndAllowThreads(__tstate);
29896 if (PyErr_Occurred()) SWIG_fail;
29897 }
29898 resultobj = SWIG_Py_Void();
29899 return resultobj;
29900 fail:
29901 return NULL;
29902 }
29903
29904
29905 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29906 PyObject *resultobj = 0;
29907 wxWindow *arg1 = (wxWindow *) 0 ;
29908 wxWindowVariant result;
29909 void *argp1 = 0 ;
29910 int res1 = 0 ;
29911 PyObject *swig_obj[1] ;
29912
29913 if (!args) SWIG_fail;
29914 swig_obj[0] = args;
29915 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29916 if (!SWIG_IsOK(res1)) {
29917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
29918 }
29919 arg1 = reinterpret_cast< wxWindow * >(argp1);
29920 {
29921 PyThreadState* __tstate = wxPyBeginAllowThreads();
29922 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
29923 wxPyEndAllowThreads(__tstate);
29924 if (PyErr_Occurred()) SWIG_fail;
29925 }
29926 resultobj = SWIG_From_int(static_cast< int >(result));
29927 return resultobj;
29928 fail:
29929 return NULL;
29930 }
29931
29932
29933 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29934 PyObject *resultobj = 0;
29935 wxWindow *arg1 = (wxWindow *) 0 ;
29936 int arg2 ;
29937 void *argp1 = 0 ;
29938 int res1 = 0 ;
29939 int val2 ;
29940 int ecode2 = 0 ;
29941 PyObject * obj0 = 0 ;
29942 PyObject * obj1 = 0 ;
29943 char * kwnames[] = {
29944 (char *) "self",(char *) "winid", NULL
29945 };
29946
29947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
29948 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29949 if (!SWIG_IsOK(res1)) {
29950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
29951 }
29952 arg1 = reinterpret_cast< wxWindow * >(argp1);
29953 ecode2 = SWIG_AsVal_int(obj1, &val2);
29954 if (!SWIG_IsOK(ecode2)) {
29955 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
29956 }
29957 arg2 = static_cast< int >(val2);
29958 {
29959 PyThreadState* __tstate = wxPyBeginAllowThreads();
29960 (arg1)->SetId(arg2);
29961 wxPyEndAllowThreads(__tstate);
29962 if (PyErr_Occurred()) SWIG_fail;
29963 }
29964 resultobj = SWIG_Py_Void();
29965 return resultobj;
29966 fail:
29967 return NULL;
29968 }
29969
29970
29971 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29972 PyObject *resultobj = 0;
29973 wxWindow *arg1 = (wxWindow *) 0 ;
29974 int result;
29975 void *argp1 = 0 ;
29976 int res1 = 0 ;
29977 PyObject *swig_obj[1] ;
29978
29979 if (!args) SWIG_fail;
29980 swig_obj[0] = args;
29981 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29982 if (!SWIG_IsOK(res1)) {
29983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
29984 }
29985 arg1 = reinterpret_cast< wxWindow * >(argp1);
29986 {
29987 PyThreadState* __tstate = wxPyBeginAllowThreads();
29988 result = (int)((wxWindow const *)arg1)->GetId();
29989 wxPyEndAllowThreads(__tstate);
29990 if (PyErr_Occurred()) SWIG_fail;
29991 }
29992 resultobj = SWIG_From_int(static_cast< int >(result));
29993 return resultobj;
29994 fail:
29995 return NULL;
29996 }
29997
29998
29999 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30000 PyObject *resultobj = 0;
30001 int result;
30002
30003 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
30004 {
30005 PyThreadState* __tstate = wxPyBeginAllowThreads();
30006 result = (int)wxWindow::NewControlId();
30007 wxPyEndAllowThreads(__tstate);
30008 if (PyErr_Occurred()) SWIG_fail;
30009 }
30010 resultobj = SWIG_From_int(static_cast< int >(result));
30011 return resultobj;
30012 fail:
30013 return NULL;
30014 }
30015
30016
30017 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30018 PyObject *resultobj = 0;
30019 int arg1 ;
30020 int result;
30021 int val1 ;
30022 int ecode1 = 0 ;
30023 PyObject * obj0 = 0 ;
30024 char * kwnames[] = {
30025 (char *) "winid", NULL
30026 };
30027
30028 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
30029 ecode1 = SWIG_AsVal_int(obj0, &val1);
30030 if (!SWIG_IsOK(ecode1)) {
30031 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
30032 }
30033 arg1 = static_cast< int >(val1);
30034 {
30035 PyThreadState* __tstate = wxPyBeginAllowThreads();
30036 result = (int)wxWindow::NextControlId(arg1);
30037 wxPyEndAllowThreads(__tstate);
30038 if (PyErr_Occurred()) SWIG_fail;
30039 }
30040 resultobj = SWIG_From_int(static_cast< int >(result));
30041 return resultobj;
30042 fail:
30043 return NULL;
30044 }
30045
30046
30047 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30048 PyObject *resultobj = 0;
30049 int arg1 ;
30050 int result;
30051 int val1 ;
30052 int ecode1 = 0 ;
30053 PyObject * obj0 = 0 ;
30054 char * kwnames[] = {
30055 (char *) "winid", NULL
30056 };
30057
30058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
30059 ecode1 = SWIG_AsVal_int(obj0, &val1);
30060 if (!SWIG_IsOK(ecode1)) {
30061 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
30062 }
30063 arg1 = static_cast< int >(val1);
30064 {
30065 PyThreadState* __tstate = wxPyBeginAllowThreads();
30066 result = (int)wxWindow::PrevControlId(arg1);
30067 wxPyEndAllowThreads(__tstate);
30068 if (PyErr_Occurred()) SWIG_fail;
30069 }
30070 resultobj = SWIG_From_int(static_cast< int >(result));
30071 return resultobj;
30072 fail:
30073 return NULL;
30074 }
30075
30076
30077 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30078 PyObject *resultobj = 0;
30079 wxWindow *arg1 = (wxWindow *) 0 ;
30080 wxSize *arg2 = 0 ;
30081 void *argp1 = 0 ;
30082 int res1 = 0 ;
30083 wxSize temp2 ;
30084 PyObject * obj0 = 0 ;
30085 PyObject * obj1 = 0 ;
30086 char * kwnames[] = {
30087 (char *) "self",(char *) "size", NULL
30088 };
30089
30090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
30091 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30092 if (!SWIG_IsOK(res1)) {
30093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30094 }
30095 arg1 = reinterpret_cast< wxWindow * >(argp1);
30096 {
30097 arg2 = &temp2;
30098 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30099 }
30100 {
30101 PyThreadState* __tstate = wxPyBeginAllowThreads();
30102 (arg1)->SetSize((wxSize const &)*arg2);
30103 wxPyEndAllowThreads(__tstate);
30104 if (PyErr_Occurred()) SWIG_fail;
30105 }
30106 resultobj = SWIG_Py_Void();
30107 return resultobj;
30108 fail:
30109 return NULL;
30110 }
30111
30112
30113 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30114 PyObject *resultobj = 0;
30115 wxWindow *arg1 = (wxWindow *) 0 ;
30116 int arg2 ;
30117 int arg3 ;
30118 int arg4 ;
30119 int arg5 ;
30120 int arg6 = (int) wxSIZE_AUTO ;
30121 void *argp1 = 0 ;
30122 int res1 = 0 ;
30123 int val2 ;
30124 int ecode2 = 0 ;
30125 int val3 ;
30126 int ecode3 = 0 ;
30127 int val4 ;
30128 int ecode4 = 0 ;
30129 int val5 ;
30130 int ecode5 = 0 ;
30131 int val6 ;
30132 int ecode6 = 0 ;
30133 PyObject * obj0 = 0 ;
30134 PyObject * obj1 = 0 ;
30135 PyObject * obj2 = 0 ;
30136 PyObject * obj3 = 0 ;
30137 PyObject * obj4 = 0 ;
30138 PyObject * obj5 = 0 ;
30139 char * kwnames[] = {
30140 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
30141 };
30142
30143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
30144 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30145 if (!SWIG_IsOK(res1)) {
30146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
30147 }
30148 arg1 = reinterpret_cast< wxWindow * >(argp1);
30149 ecode2 = SWIG_AsVal_int(obj1, &val2);
30150 if (!SWIG_IsOK(ecode2)) {
30151 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
30152 }
30153 arg2 = static_cast< int >(val2);
30154 ecode3 = SWIG_AsVal_int(obj2, &val3);
30155 if (!SWIG_IsOK(ecode3)) {
30156 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
30157 }
30158 arg3 = static_cast< int >(val3);
30159 ecode4 = SWIG_AsVal_int(obj3, &val4);
30160 if (!SWIG_IsOK(ecode4)) {
30161 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
30162 }
30163 arg4 = static_cast< int >(val4);
30164 ecode5 = SWIG_AsVal_int(obj4, &val5);
30165 if (!SWIG_IsOK(ecode5)) {
30166 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
30167 }
30168 arg5 = static_cast< int >(val5);
30169 if (obj5) {
30170 ecode6 = SWIG_AsVal_int(obj5, &val6);
30171 if (!SWIG_IsOK(ecode6)) {
30172 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
30173 }
30174 arg6 = static_cast< int >(val6);
30175 }
30176 {
30177 PyThreadState* __tstate = wxPyBeginAllowThreads();
30178 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
30179 wxPyEndAllowThreads(__tstate);
30180 if (PyErr_Occurred()) SWIG_fail;
30181 }
30182 resultobj = SWIG_Py_Void();
30183 return resultobj;
30184 fail:
30185 return NULL;
30186 }
30187
30188
30189 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30190 PyObject *resultobj = 0;
30191 wxWindow *arg1 = (wxWindow *) 0 ;
30192 wxRect *arg2 = 0 ;
30193 int arg3 = (int) wxSIZE_AUTO ;
30194 void *argp1 = 0 ;
30195 int res1 = 0 ;
30196 wxRect temp2 ;
30197 int val3 ;
30198 int ecode3 = 0 ;
30199 PyObject * obj0 = 0 ;
30200 PyObject * obj1 = 0 ;
30201 PyObject * obj2 = 0 ;
30202 char * kwnames[] = {
30203 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
30204 };
30205
30206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30207 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30208 if (!SWIG_IsOK(res1)) {
30209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30210 }
30211 arg1 = reinterpret_cast< wxWindow * >(argp1);
30212 {
30213 arg2 = &temp2;
30214 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30215 }
30216 if (obj2) {
30217 ecode3 = SWIG_AsVal_int(obj2, &val3);
30218 if (!SWIG_IsOK(ecode3)) {
30219 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
30220 }
30221 arg3 = static_cast< int >(val3);
30222 }
30223 {
30224 PyThreadState* __tstate = wxPyBeginAllowThreads();
30225 (arg1)->SetSize((wxRect const &)*arg2,arg3);
30226 wxPyEndAllowThreads(__tstate);
30227 if (PyErr_Occurred()) SWIG_fail;
30228 }
30229 resultobj = SWIG_Py_Void();
30230 return resultobj;
30231 fail:
30232 return NULL;
30233 }
30234
30235
30236 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30237 PyObject *resultobj = 0;
30238 wxWindow *arg1 = (wxWindow *) 0 ;
30239 int arg2 ;
30240 int arg3 ;
30241 void *argp1 = 0 ;
30242 int res1 = 0 ;
30243 int val2 ;
30244 int ecode2 = 0 ;
30245 int val3 ;
30246 int ecode3 = 0 ;
30247 PyObject * obj0 = 0 ;
30248 PyObject * obj1 = 0 ;
30249 PyObject * obj2 = 0 ;
30250 char * kwnames[] = {
30251 (char *) "self",(char *) "width",(char *) "height", NULL
30252 };
30253
30254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30255 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30256 if (!SWIG_IsOK(res1)) {
30257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30258 }
30259 arg1 = reinterpret_cast< wxWindow * >(argp1);
30260 ecode2 = SWIG_AsVal_int(obj1, &val2);
30261 if (!SWIG_IsOK(ecode2)) {
30262 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
30263 }
30264 arg2 = static_cast< int >(val2);
30265 ecode3 = SWIG_AsVal_int(obj2, &val3);
30266 if (!SWIG_IsOK(ecode3)) {
30267 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
30268 }
30269 arg3 = static_cast< int >(val3);
30270 {
30271 PyThreadState* __tstate = wxPyBeginAllowThreads();
30272 (arg1)->SetSize(arg2,arg3);
30273 wxPyEndAllowThreads(__tstate);
30274 if (PyErr_Occurred()) SWIG_fail;
30275 }
30276 resultobj = SWIG_Py_Void();
30277 return resultobj;
30278 fail:
30279 return NULL;
30280 }
30281
30282
30283 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30284 PyObject *resultobj = 0;
30285 wxWindow *arg1 = (wxWindow *) 0 ;
30286 wxPoint *arg2 = 0 ;
30287 int arg3 = (int) wxSIZE_USE_EXISTING ;
30288 void *argp1 = 0 ;
30289 int res1 = 0 ;
30290 wxPoint temp2 ;
30291 int val3 ;
30292 int ecode3 = 0 ;
30293 PyObject * obj0 = 0 ;
30294 PyObject * obj1 = 0 ;
30295 PyObject * obj2 = 0 ;
30296 char * kwnames[] = {
30297 (char *) "self",(char *) "pt",(char *) "flags", NULL
30298 };
30299
30300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30301 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30302 if (!SWIG_IsOK(res1)) {
30303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
30304 }
30305 arg1 = reinterpret_cast< wxWindow * >(argp1);
30306 {
30307 arg2 = &temp2;
30308 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30309 }
30310 if (obj2) {
30311 ecode3 = SWIG_AsVal_int(obj2, &val3);
30312 if (!SWIG_IsOK(ecode3)) {
30313 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
30314 }
30315 arg3 = static_cast< int >(val3);
30316 }
30317 {
30318 PyThreadState* __tstate = wxPyBeginAllowThreads();
30319 (arg1)->Move((wxPoint const &)*arg2,arg3);
30320 wxPyEndAllowThreads(__tstate);
30321 if (PyErr_Occurred()) SWIG_fail;
30322 }
30323 resultobj = SWIG_Py_Void();
30324 return resultobj;
30325 fail:
30326 return NULL;
30327 }
30328
30329
30330 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30331 PyObject *resultobj = 0;
30332 wxWindow *arg1 = (wxWindow *) 0 ;
30333 int arg2 ;
30334 int arg3 ;
30335 int arg4 = (int) wxSIZE_USE_EXISTING ;
30336 void *argp1 = 0 ;
30337 int res1 = 0 ;
30338 int val2 ;
30339 int ecode2 = 0 ;
30340 int val3 ;
30341 int ecode3 = 0 ;
30342 int val4 ;
30343 int ecode4 = 0 ;
30344 PyObject * obj0 = 0 ;
30345 PyObject * obj1 = 0 ;
30346 PyObject * obj2 = 0 ;
30347 PyObject * obj3 = 0 ;
30348 char * kwnames[] = {
30349 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
30350 };
30351
30352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30353 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30354 if (!SWIG_IsOK(res1)) {
30355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
30356 }
30357 arg1 = reinterpret_cast< wxWindow * >(argp1);
30358 ecode2 = SWIG_AsVal_int(obj1, &val2);
30359 if (!SWIG_IsOK(ecode2)) {
30360 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
30361 }
30362 arg2 = static_cast< int >(val2);
30363 ecode3 = SWIG_AsVal_int(obj2, &val3);
30364 if (!SWIG_IsOK(ecode3)) {
30365 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
30366 }
30367 arg3 = static_cast< int >(val3);
30368 if (obj3) {
30369 ecode4 = SWIG_AsVal_int(obj3, &val4);
30370 if (!SWIG_IsOK(ecode4)) {
30371 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
30372 }
30373 arg4 = static_cast< int >(val4);
30374 }
30375 {
30376 PyThreadState* __tstate = wxPyBeginAllowThreads();
30377 (arg1)->Move(arg2,arg3,arg4);
30378 wxPyEndAllowThreads(__tstate);
30379 if (PyErr_Occurred()) SWIG_fail;
30380 }
30381 resultobj = SWIG_Py_Void();
30382 return resultobj;
30383 fail:
30384 return NULL;
30385 }
30386
30387
30388 SWIGINTERN PyObject *_wrap_Window_SetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30389 PyObject *resultobj = 0;
30390 wxWindow *arg1 = (wxWindow *) 0 ;
30391 wxSize const &arg2_defvalue = wxDefaultSize ;
30392 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
30393 void *argp1 = 0 ;
30394 int res1 = 0 ;
30395 wxSize temp2 ;
30396 PyObject * obj0 = 0 ;
30397 PyObject * obj1 = 0 ;
30398 char * kwnames[] = {
30399 (char *) "self",(char *) "size", NULL
30400 };
30401
30402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) SWIG_fail;
30403 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30404 if (!SWIG_IsOK(res1)) {
30405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30406 }
30407 arg1 = reinterpret_cast< wxWindow * >(argp1);
30408 if (obj1) {
30409 {
30410 arg2 = &temp2;
30411 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30412 }
30413 }
30414 {
30415 PyThreadState* __tstate = wxPyBeginAllowThreads();
30416 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
30417 wxPyEndAllowThreads(__tstate);
30418 if (PyErr_Occurred()) SWIG_fail;
30419 }
30420 resultobj = SWIG_Py_Void();
30421 return resultobj;
30422 fail:
30423 return NULL;
30424 }
30425
30426
30427 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30428 PyObject *resultobj = 0;
30429 wxWindow *arg1 = (wxWindow *) 0 ;
30430 void *argp1 = 0 ;
30431 int res1 = 0 ;
30432 PyObject *swig_obj[1] ;
30433
30434 if (!args) SWIG_fail;
30435 swig_obj[0] = args;
30436 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30437 if (!SWIG_IsOK(res1)) {
30438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
30439 }
30440 arg1 = reinterpret_cast< wxWindow * >(argp1);
30441 {
30442 PyThreadState* __tstate = wxPyBeginAllowThreads();
30443 (arg1)->Raise();
30444 wxPyEndAllowThreads(__tstate);
30445 if (PyErr_Occurred()) SWIG_fail;
30446 }
30447 resultobj = SWIG_Py_Void();
30448 return resultobj;
30449 fail:
30450 return NULL;
30451 }
30452
30453
30454 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30455 PyObject *resultobj = 0;
30456 wxWindow *arg1 = (wxWindow *) 0 ;
30457 void *argp1 = 0 ;
30458 int res1 = 0 ;
30459 PyObject *swig_obj[1] ;
30460
30461 if (!args) SWIG_fail;
30462 swig_obj[0] = args;
30463 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30464 if (!SWIG_IsOK(res1)) {
30465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
30466 }
30467 arg1 = reinterpret_cast< wxWindow * >(argp1);
30468 {
30469 PyThreadState* __tstate = wxPyBeginAllowThreads();
30470 (arg1)->Lower();
30471 wxPyEndAllowThreads(__tstate);
30472 if (PyErr_Occurred()) SWIG_fail;
30473 }
30474 resultobj = SWIG_Py_Void();
30475 return resultobj;
30476 fail:
30477 return NULL;
30478 }
30479
30480
30481 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30482 PyObject *resultobj = 0;
30483 wxWindow *arg1 = (wxWindow *) 0 ;
30484 wxSize *arg2 = 0 ;
30485 void *argp1 = 0 ;
30486 int res1 = 0 ;
30487 wxSize temp2 ;
30488 PyObject * obj0 = 0 ;
30489 PyObject * obj1 = 0 ;
30490 char * kwnames[] = {
30491 (char *) "self",(char *) "size", NULL
30492 };
30493
30494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
30495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30496 if (!SWIG_IsOK(res1)) {
30497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30498 }
30499 arg1 = reinterpret_cast< wxWindow * >(argp1);
30500 {
30501 arg2 = &temp2;
30502 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30503 }
30504 {
30505 PyThreadState* __tstate = wxPyBeginAllowThreads();
30506 (arg1)->SetClientSize((wxSize const &)*arg2);
30507 wxPyEndAllowThreads(__tstate);
30508 if (PyErr_Occurred()) SWIG_fail;
30509 }
30510 resultobj = SWIG_Py_Void();
30511 return resultobj;
30512 fail:
30513 return NULL;
30514 }
30515
30516
30517 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30518 PyObject *resultobj = 0;
30519 wxWindow *arg1 = (wxWindow *) 0 ;
30520 int arg2 ;
30521 int arg3 ;
30522 void *argp1 = 0 ;
30523 int res1 = 0 ;
30524 int val2 ;
30525 int ecode2 = 0 ;
30526 int val3 ;
30527 int ecode3 = 0 ;
30528 PyObject * obj0 = 0 ;
30529 PyObject * obj1 = 0 ;
30530 PyObject * obj2 = 0 ;
30531 char * kwnames[] = {
30532 (char *) "self",(char *) "width",(char *) "height", NULL
30533 };
30534
30535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30536 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30537 if (!SWIG_IsOK(res1)) {
30538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30539 }
30540 arg1 = reinterpret_cast< wxWindow * >(argp1);
30541 ecode2 = SWIG_AsVal_int(obj1, &val2);
30542 if (!SWIG_IsOK(ecode2)) {
30543 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
30544 }
30545 arg2 = static_cast< int >(val2);
30546 ecode3 = SWIG_AsVal_int(obj2, &val3);
30547 if (!SWIG_IsOK(ecode3)) {
30548 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
30549 }
30550 arg3 = static_cast< int >(val3);
30551 {
30552 PyThreadState* __tstate = wxPyBeginAllowThreads();
30553 (arg1)->SetClientSize(arg2,arg3);
30554 wxPyEndAllowThreads(__tstate);
30555 if (PyErr_Occurred()) SWIG_fail;
30556 }
30557 resultobj = SWIG_Py_Void();
30558 return resultobj;
30559 fail:
30560 return NULL;
30561 }
30562
30563
30564 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30565 PyObject *resultobj = 0;
30566 wxWindow *arg1 = (wxWindow *) 0 ;
30567 wxRect *arg2 = 0 ;
30568 void *argp1 = 0 ;
30569 int res1 = 0 ;
30570 wxRect temp2 ;
30571 PyObject * obj0 = 0 ;
30572 PyObject * obj1 = 0 ;
30573 char * kwnames[] = {
30574 (char *) "self",(char *) "rect", NULL
30575 };
30576
30577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
30578 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30579 if (!SWIG_IsOK(res1)) {
30580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30581 }
30582 arg1 = reinterpret_cast< wxWindow * >(argp1);
30583 {
30584 arg2 = &temp2;
30585 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30586 }
30587 {
30588 PyThreadState* __tstate = wxPyBeginAllowThreads();
30589 (arg1)->SetClientSize((wxRect const &)*arg2);
30590 wxPyEndAllowThreads(__tstate);
30591 if (PyErr_Occurred()) SWIG_fail;
30592 }
30593 resultobj = SWIG_Py_Void();
30594 return resultobj;
30595 fail:
30596 return NULL;
30597 }
30598
30599
30600 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30601 PyObject *resultobj = 0;
30602 wxWindow *arg1 = (wxWindow *) 0 ;
30603 wxPoint result;
30604 void *argp1 = 0 ;
30605 int res1 = 0 ;
30606 PyObject *swig_obj[1] ;
30607
30608 if (!args) SWIG_fail;
30609 swig_obj[0] = args;
30610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30611 if (!SWIG_IsOK(res1)) {
30612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
30613 }
30614 arg1 = reinterpret_cast< wxWindow * >(argp1);
30615 {
30616 PyThreadState* __tstate = wxPyBeginAllowThreads();
30617 result = ((wxWindow const *)arg1)->GetPosition();
30618 wxPyEndAllowThreads(__tstate);
30619 if (PyErr_Occurred()) SWIG_fail;
30620 }
30621 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30622 return resultobj;
30623 fail:
30624 return NULL;
30625 }
30626
30627
30628 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30629 PyObject *resultobj = 0;
30630 wxWindow *arg1 = (wxWindow *) 0 ;
30631 int *arg2 = (int *) 0 ;
30632 int *arg3 = (int *) 0 ;
30633 void *argp1 = 0 ;
30634 int res1 = 0 ;
30635 int temp2 ;
30636 int res2 = SWIG_TMPOBJ ;
30637 int temp3 ;
30638 int res3 = SWIG_TMPOBJ ;
30639 PyObject *swig_obj[1] ;
30640
30641 arg2 = &temp2;
30642 arg3 = &temp3;
30643 if (!args) SWIG_fail;
30644 swig_obj[0] = args;
30645 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30646 if (!SWIG_IsOK(res1)) {
30647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30648 }
30649 arg1 = reinterpret_cast< wxWindow * >(argp1);
30650 {
30651 PyThreadState* __tstate = wxPyBeginAllowThreads();
30652 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
30653 wxPyEndAllowThreads(__tstate);
30654 if (PyErr_Occurred()) SWIG_fail;
30655 }
30656 resultobj = SWIG_Py_Void();
30657 if (SWIG_IsTmpObj(res2)) {
30658 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30659 } else {
30660 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30661 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30662 }
30663 if (SWIG_IsTmpObj(res3)) {
30664 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30665 } else {
30666 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30667 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30668 }
30669 return resultobj;
30670 fail:
30671 return NULL;
30672 }
30673
30674
30675 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30676 PyObject *resultobj = 0;
30677 wxWindow *arg1 = (wxWindow *) 0 ;
30678 wxPoint result;
30679 void *argp1 = 0 ;
30680 int res1 = 0 ;
30681 PyObject *swig_obj[1] ;
30682
30683 if (!args) SWIG_fail;
30684 swig_obj[0] = args;
30685 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30686 if (!SWIG_IsOK(res1)) {
30687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
30688 }
30689 arg1 = reinterpret_cast< wxWindow * >(argp1);
30690 {
30691 PyThreadState* __tstate = wxPyBeginAllowThreads();
30692 result = ((wxWindow const *)arg1)->GetScreenPosition();
30693 wxPyEndAllowThreads(__tstate);
30694 if (PyErr_Occurred()) SWIG_fail;
30695 }
30696 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30697 return resultobj;
30698 fail:
30699 return NULL;
30700 }
30701
30702
30703 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30704 PyObject *resultobj = 0;
30705 wxWindow *arg1 = (wxWindow *) 0 ;
30706 int *arg2 = (int *) 0 ;
30707 int *arg3 = (int *) 0 ;
30708 void *argp1 = 0 ;
30709 int res1 = 0 ;
30710 int temp2 ;
30711 int res2 = SWIG_TMPOBJ ;
30712 int temp3 ;
30713 int res3 = SWIG_TMPOBJ ;
30714 PyObject *swig_obj[1] ;
30715
30716 arg2 = &temp2;
30717 arg3 = &temp3;
30718 if (!args) SWIG_fail;
30719 swig_obj[0] = args;
30720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30721 if (!SWIG_IsOK(res1)) {
30722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30723 }
30724 arg1 = reinterpret_cast< wxWindow * >(argp1);
30725 {
30726 PyThreadState* __tstate = wxPyBeginAllowThreads();
30727 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
30728 wxPyEndAllowThreads(__tstate);
30729 if (PyErr_Occurred()) SWIG_fail;
30730 }
30731 resultobj = SWIG_Py_Void();
30732 if (SWIG_IsTmpObj(res2)) {
30733 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30734 } else {
30735 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30736 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30737 }
30738 if (SWIG_IsTmpObj(res3)) {
30739 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30740 } else {
30741 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30742 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30743 }
30744 return resultobj;
30745 fail:
30746 return NULL;
30747 }
30748
30749
30750 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30751 PyObject *resultobj = 0;
30752 wxWindow *arg1 = (wxWindow *) 0 ;
30753 wxRect result;
30754 void *argp1 = 0 ;
30755 int res1 = 0 ;
30756 PyObject *swig_obj[1] ;
30757
30758 if (!args) SWIG_fail;
30759 swig_obj[0] = args;
30760 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30761 if (!SWIG_IsOK(res1)) {
30762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
30763 }
30764 arg1 = reinterpret_cast< wxWindow * >(argp1);
30765 {
30766 PyThreadState* __tstate = wxPyBeginAllowThreads();
30767 result = ((wxWindow const *)arg1)->GetScreenRect();
30768 wxPyEndAllowThreads(__tstate);
30769 if (PyErr_Occurred()) SWIG_fail;
30770 }
30771 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
30772 return resultobj;
30773 fail:
30774 return NULL;
30775 }
30776
30777
30778 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30779 PyObject *resultobj = 0;
30780 wxWindow *arg1 = (wxWindow *) 0 ;
30781 wxSize result;
30782 void *argp1 = 0 ;
30783 int res1 = 0 ;
30784 PyObject *swig_obj[1] ;
30785
30786 if (!args) SWIG_fail;
30787 swig_obj[0] = args;
30788 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30789 if (!SWIG_IsOK(res1)) {
30790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
30791 }
30792 arg1 = reinterpret_cast< wxWindow * >(argp1);
30793 {
30794 PyThreadState* __tstate = wxPyBeginAllowThreads();
30795 result = ((wxWindow const *)arg1)->GetSize();
30796 wxPyEndAllowThreads(__tstate);
30797 if (PyErr_Occurred()) SWIG_fail;
30798 }
30799 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
30800 return resultobj;
30801 fail:
30802 return NULL;
30803 }
30804
30805
30806 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30807 PyObject *resultobj = 0;
30808 wxWindow *arg1 = (wxWindow *) 0 ;
30809 int *arg2 = (int *) 0 ;
30810 int *arg3 = (int *) 0 ;
30811 void *argp1 = 0 ;
30812 int res1 = 0 ;
30813 int temp2 ;
30814 int res2 = SWIG_TMPOBJ ;
30815 int temp3 ;
30816 int res3 = SWIG_TMPOBJ ;
30817 PyObject *swig_obj[1] ;
30818
30819 arg2 = &temp2;
30820 arg3 = &temp3;
30821 if (!args) SWIG_fail;
30822 swig_obj[0] = args;
30823 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30824 if (!SWIG_IsOK(res1)) {
30825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30826 }
30827 arg1 = reinterpret_cast< wxWindow * >(argp1);
30828 {
30829 PyThreadState* __tstate = wxPyBeginAllowThreads();
30830 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
30831 wxPyEndAllowThreads(__tstate);
30832 if (PyErr_Occurred()) SWIG_fail;
30833 }
30834 resultobj = SWIG_Py_Void();
30835 if (SWIG_IsTmpObj(res2)) {
30836 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30837 } else {
30838 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30839 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30840 }
30841 if (SWIG_IsTmpObj(res3)) {
30842 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30843 } else {
30844 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30845 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30846 }
30847 return resultobj;
30848 fail:
30849 return NULL;
30850 }
30851
30852
30853 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30854 PyObject *resultobj = 0;
30855 wxWindow *arg1 = (wxWindow *) 0 ;
30856 wxRect result;
30857 void *argp1 = 0 ;
30858 int res1 = 0 ;
30859 PyObject *swig_obj[1] ;
30860
30861 if (!args) SWIG_fail;
30862 swig_obj[0] = args;
30863 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30864 if (!SWIG_IsOK(res1)) {
30865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
30866 }
30867 arg1 = reinterpret_cast< wxWindow * >(argp1);
30868 {
30869 PyThreadState* __tstate = wxPyBeginAllowThreads();
30870 result = ((wxWindow const *)arg1)->GetRect();
30871 wxPyEndAllowThreads(__tstate);
30872 if (PyErr_Occurred()) SWIG_fail;
30873 }
30874 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
30875 return resultobj;
30876 fail:
30877 return NULL;
30878 }
30879
30880
30881 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30882 PyObject *resultobj = 0;
30883 wxWindow *arg1 = (wxWindow *) 0 ;
30884 wxSize result;
30885 void *argp1 = 0 ;
30886 int res1 = 0 ;
30887 PyObject *swig_obj[1] ;
30888
30889 if (!args) SWIG_fail;
30890 swig_obj[0] = args;
30891 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30892 if (!SWIG_IsOK(res1)) {
30893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
30894 }
30895 arg1 = reinterpret_cast< wxWindow * >(argp1);
30896 {
30897 PyThreadState* __tstate = wxPyBeginAllowThreads();
30898 result = ((wxWindow const *)arg1)->GetClientSize();
30899 wxPyEndAllowThreads(__tstate);
30900 if (PyErr_Occurred()) SWIG_fail;
30901 }
30902 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
30903 return resultobj;
30904 fail:
30905 return NULL;
30906 }
30907
30908
30909 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30910 PyObject *resultobj = 0;
30911 wxWindow *arg1 = (wxWindow *) 0 ;
30912 int *arg2 = (int *) 0 ;
30913 int *arg3 = (int *) 0 ;
30914 void *argp1 = 0 ;
30915 int res1 = 0 ;
30916 int temp2 ;
30917 int res2 = SWIG_TMPOBJ ;
30918 int temp3 ;
30919 int res3 = SWIG_TMPOBJ ;
30920 PyObject *swig_obj[1] ;
30921
30922 arg2 = &temp2;
30923 arg3 = &temp3;
30924 if (!args) SWIG_fail;
30925 swig_obj[0] = args;
30926 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30927 if (!SWIG_IsOK(res1)) {
30928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30929 }
30930 arg1 = reinterpret_cast< wxWindow * >(argp1);
30931 {
30932 PyThreadState* __tstate = wxPyBeginAllowThreads();
30933 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
30934 wxPyEndAllowThreads(__tstate);
30935 if (PyErr_Occurred()) SWIG_fail;
30936 }
30937 resultobj = SWIG_Py_Void();
30938 if (SWIG_IsTmpObj(res2)) {
30939 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30940 } else {
30941 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30942 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30943 }
30944 if (SWIG_IsTmpObj(res3)) {
30945 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30946 } else {
30947 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30948 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30949 }
30950 return resultobj;
30951 fail:
30952 return NULL;
30953 }
30954
30955
30956 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30957 PyObject *resultobj = 0;
30958 wxWindow *arg1 = (wxWindow *) 0 ;
30959 wxPoint result;
30960 void *argp1 = 0 ;
30961 int res1 = 0 ;
30962 PyObject *swig_obj[1] ;
30963
30964 if (!args) SWIG_fail;
30965 swig_obj[0] = args;
30966 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30967 if (!SWIG_IsOK(res1)) {
30968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
30969 }
30970 arg1 = reinterpret_cast< wxWindow * >(argp1);
30971 {
30972 PyThreadState* __tstate = wxPyBeginAllowThreads();
30973 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
30974 wxPyEndAllowThreads(__tstate);
30975 if (PyErr_Occurred()) SWIG_fail;
30976 }
30977 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30978 return resultobj;
30979 fail:
30980 return NULL;
30981 }
30982
30983
30984 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30985 PyObject *resultobj = 0;
30986 wxWindow *arg1 = (wxWindow *) 0 ;
30987 wxRect result;
30988 void *argp1 = 0 ;
30989 int res1 = 0 ;
30990 PyObject *swig_obj[1] ;
30991
30992 if (!args) SWIG_fail;
30993 swig_obj[0] = args;
30994 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30995 if (!SWIG_IsOK(res1)) {
30996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
30997 }
30998 arg1 = reinterpret_cast< wxWindow * >(argp1);
30999 {
31000 PyThreadState* __tstate = wxPyBeginAllowThreads();
31001 result = ((wxWindow const *)arg1)->GetClientRect();
31002 wxPyEndAllowThreads(__tstate);
31003 if (PyErr_Occurred()) SWIG_fail;
31004 }
31005 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31006 return resultobj;
31007 fail:
31008 return NULL;
31009 }
31010
31011
31012 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31013 PyObject *resultobj = 0;
31014 wxWindow *arg1 = (wxWindow *) 0 ;
31015 wxSize result;
31016 void *argp1 = 0 ;
31017 int res1 = 0 ;
31018 PyObject *swig_obj[1] ;
31019
31020 if (!args) SWIG_fail;
31021 swig_obj[0] = args;
31022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31023 if (!SWIG_IsOK(res1)) {
31024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31025 }
31026 arg1 = reinterpret_cast< wxWindow * >(argp1);
31027 {
31028 PyThreadState* __tstate = wxPyBeginAllowThreads();
31029 result = ((wxWindow const *)arg1)->GetBestSize();
31030 wxPyEndAllowThreads(__tstate);
31031 if (PyErr_Occurred()) SWIG_fail;
31032 }
31033 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31034 return resultobj;
31035 fail:
31036 return NULL;
31037 }
31038
31039
31040 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31041 PyObject *resultobj = 0;
31042 wxWindow *arg1 = (wxWindow *) 0 ;
31043 int *arg2 = (int *) 0 ;
31044 int *arg3 = (int *) 0 ;
31045 void *argp1 = 0 ;
31046 int res1 = 0 ;
31047 int temp2 ;
31048 int res2 = SWIG_TMPOBJ ;
31049 int temp3 ;
31050 int res3 = SWIG_TMPOBJ ;
31051 PyObject *swig_obj[1] ;
31052
31053 arg2 = &temp2;
31054 arg3 = &temp3;
31055 if (!args) SWIG_fail;
31056 swig_obj[0] = args;
31057 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31058 if (!SWIG_IsOK(res1)) {
31059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31060 }
31061 arg1 = reinterpret_cast< wxWindow * >(argp1);
31062 {
31063 PyThreadState* __tstate = wxPyBeginAllowThreads();
31064 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
31065 wxPyEndAllowThreads(__tstate);
31066 if (PyErr_Occurred()) SWIG_fail;
31067 }
31068 resultobj = SWIG_Py_Void();
31069 if (SWIG_IsTmpObj(res2)) {
31070 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31071 } else {
31072 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31073 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31074 }
31075 if (SWIG_IsTmpObj(res3)) {
31076 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31077 } else {
31078 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31079 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31080 }
31081 return resultobj;
31082 fail:
31083 return NULL;
31084 }
31085
31086
31087 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31088 PyObject *resultobj = 0;
31089 wxWindow *arg1 = (wxWindow *) 0 ;
31090 void *argp1 = 0 ;
31091 int res1 = 0 ;
31092 PyObject *swig_obj[1] ;
31093
31094 if (!args) SWIG_fail;
31095 swig_obj[0] = args;
31096 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31097 if (!SWIG_IsOK(res1)) {
31098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31099 }
31100 arg1 = reinterpret_cast< wxWindow * >(argp1);
31101 {
31102 PyThreadState* __tstate = wxPyBeginAllowThreads();
31103 (arg1)->InvalidateBestSize();
31104 wxPyEndAllowThreads(__tstate);
31105 if (PyErr_Occurred()) SWIG_fail;
31106 }
31107 resultobj = SWIG_Py_Void();
31108 return resultobj;
31109 fail:
31110 return NULL;
31111 }
31112
31113
31114 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31115 PyObject *resultobj = 0;
31116 wxWindow *arg1 = (wxWindow *) 0 ;
31117 wxSize *arg2 = 0 ;
31118 void *argp1 = 0 ;
31119 int res1 = 0 ;
31120 wxSize temp2 ;
31121 PyObject * obj0 = 0 ;
31122 PyObject * obj1 = 0 ;
31123 char * kwnames[] = {
31124 (char *) "self",(char *) "size", NULL
31125 };
31126
31127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
31128 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31129 if (!SWIG_IsOK(res1)) {
31130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31131 }
31132 arg1 = reinterpret_cast< wxWindow * >(argp1);
31133 {
31134 arg2 = &temp2;
31135 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31136 }
31137 {
31138 PyThreadState* __tstate = wxPyBeginAllowThreads();
31139 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
31140 wxPyEndAllowThreads(__tstate);
31141 if (PyErr_Occurred()) SWIG_fail;
31142 }
31143 resultobj = SWIG_Py_Void();
31144 return resultobj;
31145 fail:
31146 return NULL;
31147 }
31148
31149
31150 SWIGINTERN PyObject *_wrap_Window_GetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31151 PyObject *resultobj = 0;
31152 wxWindow *arg1 = (wxWindow *) 0 ;
31153 wxSize result;
31154 void *argp1 = 0 ;
31155 int res1 = 0 ;
31156 PyObject *swig_obj[1] ;
31157
31158 if (!args) SWIG_fail;
31159 swig_obj[0] = args;
31160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31161 if (!SWIG_IsOK(res1)) {
31162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31163 }
31164 arg1 = reinterpret_cast< wxWindow * >(argp1);
31165 {
31166 PyThreadState* __tstate = wxPyBeginAllowThreads();
31167 result = ((wxWindow const *)arg1)->GetBestFittingSize();
31168 wxPyEndAllowThreads(__tstate);
31169 if (PyErr_Occurred()) SWIG_fail;
31170 }
31171 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31172 return resultobj;
31173 fail:
31174 return NULL;
31175 }
31176
31177
31178 SWIGINTERN PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31179 PyObject *resultobj = 0;
31180 wxWindow *arg1 = (wxWindow *) 0 ;
31181 wxSize result;
31182 void *argp1 = 0 ;
31183 int res1 = 0 ;
31184 PyObject *swig_obj[1] ;
31185
31186 if (!args) SWIG_fail;
31187 swig_obj[0] = args;
31188 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31189 if (!SWIG_IsOK(res1)) {
31190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAdjustedBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31191 }
31192 arg1 = reinterpret_cast< wxWindow * >(argp1);
31193 {
31194 PyThreadState* __tstate = wxPyBeginAllowThreads();
31195 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
31196 wxPyEndAllowThreads(__tstate);
31197 if (PyErr_Occurred()) SWIG_fail;
31198 }
31199 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31200 return resultobj;
31201 fail:
31202 return NULL;
31203 }
31204
31205
31206 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31207 PyObject *resultobj = 0;
31208 wxWindow *arg1 = (wxWindow *) 0 ;
31209 int arg2 = (int) wxBOTH ;
31210 void *argp1 = 0 ;
31211 int res1 = 0 ;
31212 int val2 ;
31213 int ecode2 = 0 ;
31214 PyObject * obj0 = 0 ;
31215 PyObject * obj1 = 0 ;
31216 char * kwnames[] = {
31217 (char *) "self",(char *) "direction", NULL
31218 };
31219
31220 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
31221 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31222 if (!SWIG_IsOK(res1)) {
31223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
31224 }
31225 arg1 = reinterpret_cast< wxWindow * >(argp1);
31226 if (obj1) {
31227 ecode2 = SWIG_AsVal_int(obj1, &val2);
31228 if (!SWIG_IsOK(ecode2)) {
31229 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
31230 }
31231 arg2 = static_cast< int >(val2);
31232 }
31233 {
31234 PyThreadState* __tstate = wxPyBeginAllowThreads();
31235 (arg1)->Center(arg2);
31236 wxPyEndAllowThreads(__tstate);
31237 if (PyErr_Occurred()) SWIG_fail;
31238 }
31239 resultobj = SWIG_Py_Void();
31240 return resultobj;
31241 fail:
31242 return NULL;
31243 }
31244
31245
31246 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31247 PyObject *resultobj = 0;
31248 wxWindow *arg1 = (wxWindow *) 0 ;
31249 int arg2 = (int) wxBOTH ;
31250 void *argp1 = 0 ;
31251 int res1 = 0 ;
31252 int val2 ;
31253 int ecode2 = 0 ;
31254 PyObject * obj0 = 0 ;
31255 PyObject * obj1 = 0 ;
31256 char * kwnames[] = {
31257 (char *) "self",(char *) "dir", NULL
31258 };
31259
31260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
31261 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31262 if (!SWIG_IsOK(res1)) {
31263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
31264 }
31265 arg1 = reinterpret_cast< wxWindow * >(argp1);
31266 if (obj1) {
31267 ecode2 = SWIG_AsVal_int(obj1, &val2);
31268 if (!SWIG_IsOK(ecode2)) {
31269 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
31270 }
31271 arg2 = static_cast< int >(val2);
31272 }
31273 {
31274 PyThreadState* __tstate = wxPyBeginAllowThreads();
31275 (arg1)->CenterOnParent(arg2);
31276 wxPyEndAllowThreads(__tstate);
31277 if (PyErr_Occurred()) SWIG_fail;
31278 }
31279 resultobj = SWIG_Py_Void();
31280 return resultobj;
31281 fail:
31282 return NULL;
31283 }
31284
31285
31286 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31287 PyObject *resultobj = 0;
31288 wxWindow *arg1 = (wxWindow *) 0 ;
31289 void *argp1 = 0 ;
31290 int res1 = 0 ;
31291 PyObject *swig_obj[1] ;
31292
31293 if (!args) SWIG_fail;
31294 swig_obj[0] = args;
31295 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31296 if (!SWIG_IsOK(res1)) {
31297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
31298 }
31299 arg1 = reinterpret_cast< wxWindow * >(argp1);
31300 {
31301 PyThreadState* __tstate = wxPyBeginAllowThreads();
31302 (arg1)->Fit();
31303 wxPyEndAllowThreads(__tstate);
31304 if (PyErr_Occurred()) SWIG_fail;
31305 }
31306 resultobj = SWIG_Py_Void();
31307 return resultobj;
31308 fail:
31309 return NULL;
31310 }
31311
31312
31313 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31314 PyObject *resultobj = 0;
31315 wxWindow *arg1 = (wxWindow *) 0 ;
31316 void *argp1 = 0 ;
31317 int res1 = 0 ;
31318 PyObject *swig_obj[1] ;
31319
31320 if (!args) SWIG_fail;
31321 swig_obj[0] = args;
31322 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31323 if (!SWIG_IsOK(res1)) {
31324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
31325 }
31326 arg1 = reinterpret_cast< wxWindow * >(argp1);
31327 {
31328 PyThreadState* __tstate = wxPyBeginAllowThreads();
31329 (arg1)->FitInside();
31330 wxPyEndAllowThreads(__tstate);
31331 if (PyErr_Occurred()) SWIG_fail;
31332 }
31333 resultobj = SWIG_Py_Void();
31334 return resultobj;
31335 fail:
31336 return NULL;
31337 }
31338
31339
31340 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31341 PyObject *resultobj = 0;
31342 wxWindow *arg1 = (wxWindow *) 0 ;
31343 int arg2 ;
31344 int arg3 ;
31345 int arg4 = (int) -1 ;
31346 int arg5 = (int) -1 ;
31347 int arg6 = (int) -1 ;
31348 int arg7 = (int) -1 ;
31349 void *argp1 = 0 ;
31350 int res1 = 0 ;
31351 int val2 ;
31352 int ecode2 = 0 ;
31353 int val3 ;
31354 int ecode3 = 0 ;
31355 int val4 ;
31356 int ecode4 = 0 ;
31357 int val5 ;
31358 int ecode5 = 0 ;
31359 int val6 ;
31360 int ecode6 = 0 ;
31361 int val7 ;
31362 int ecode7 = 0 ;
31363 PyObject * obj0 = 0 ;
31364 PyObject * obj1 = 0 ;
31365 PyObject * obj2 = 0 ;
31366 PyObject * obj3 = 0 ;
31367 PyObject * obj4 = 0 ;
31368 PyObject * obj5 = 0 ;
31369 PyObject * obj6 = 0 ;
31370 char * kwnames[] = {
31371 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
31372 };
31373
31374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
31375 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31376 if (!SWIG_IsOK(res1)) {
31377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31378 }
31379 arg1 = reinterpret_cast< wxWindow * >(argp1);
31380 ecode2 = SWIG_AsVal_int(obj1, &val2);
31381 if (!SWIG_IsOK(ecode2)) {
31382 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
31383 }
31384 arg2 = static_cast< int >(val2);
31385 ecode3 = SWIG_AsVal_int(obj2, &val3);
31386 if (!SWIG_IsOK(ecode3)) {
31387 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
31388 }
31389 arg3 = static_cast< int >(val3);
31390 if (obj3) {
31391 ecode4 = SWIG_AsVal_int(obj3, &val4);
31392 if (!SWIG_IsOK(ecode4)) {
31393 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
31394 }
31395 arg4 = static_cast< int >(val4);
31396 }
31397 if (obj4) {
31398 ecode5 = SWIG_AsVal_int(obj4, &val5);
31399 if (!SWIG_IsOK(ecode5)) {
31400 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
31401 }
31402 arg5 = static_cast< int >(val5);
31403 }
31404 if (obj5) {
31405 ecode6 = SWIG_AsVal_int(obj5, &val6);
31406 if (!SWIG_IsOK(ecode6)) {
31407 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
31408 }
31409 arg6 = static_cast< int >(val6);
31410 }
31411 if (obj6) {
31412 ecode7 = SWIG_AsVal_int(obj6, &val7);
31413 if (!SWIG_IsOK(ecode7)) {
31414 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
31415 }
31416 arg7 = static_cast< int >(val7);
31417 }
31418 {
31419 PyThreadState* __tstate = wxPyBeginAllowThreads();
31420 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
31421 wxPyEndAllowThreads(__tstate);
31422 if (PyErr_Occurred()) SWIG_fail;
31423 }
31424 resultobj = SWIG_Py_Void();
31425 return resultobj;
31426 fail:
31427 return NULL;
31428 }
31429
31430
31431 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31432 PyObject *resultobj = 0;
31433 wxWindow *arg1 = (wxWindow *) 0 ;
31434 wxSize *arg2 = 0 ;
31435 wxSize const &arg3_defvalue = wxDefaultSize ;
31436 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31437 wxSize const &arg4_defvalue = wxDefaultSize ;
31438 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
31439 void *argp1 = 0 ;
31440 int res1 = 0 ;
31441 wxSize temp2 ;
31442 wxSize temp3 ;
31443 wxSize temp4 ;
31444 PyObject * obj0 = 0 ;
31445 PyObject * obj1 = 0 ;
31446 PyObject * obj2 = 0 ;
31447 PyObject * obj3 = 0 ;
31448 char * kwnames[] = {
31449 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
31450 };
31451
31452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
31453 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31454 if (!SWIG_IsOK(res1)) {
31455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31456 }
31457 arg1 = reinterpret_cast< wxWindow * >(argp1);
31458 {
31459 arg2 = &temp2;
31460 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31461 }
31462 if (obj2) {
31463 {
31464 arg3 = &temp3;
31465 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31466 }
31467 }
31468 if (obj3) {
31469 {
31470 arg4 = &temp4;
31471 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
31472 }
31473 }
31474 {
31475 PyThreadState* __tstate = wxPyBeginAllowThreads();
31476 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
31477 wxPyEndAllowThreads(__tstate);
31478 if (PyErr_Occurred()) SWIG_fail;
31479 }
31480 resultobj = SWIG_Py_Void();
31481 return resultobj;
31482 fail:
31483 return NULL;
31484 }
31485
31486
31487 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31488 PyObject *resultobj = 0;
31489 wxWindow *arg1 = (wxWindow *) 0 ;
31490 int arg2 ;
31491 int arg3 ;
31492 int arg4 = (int) -1 ;
31493 int arg5 = (int) -1 ;
31494 void *argp1 = 0 ;
31495 int res1 = 0 ;
31496 int val2 ;
31497 int ecode2 = 0 ;
31498 int val3 ;
31499 int ecode3 = 0 ;
31500 int val4 ;
31501 int ecode4 = 0 ;
31502 int val5 ;
31503 int ecode5 = 0 ;
31504 PyObject * obj0 = 0 ;
31505 PyObject * obj1 = 0 ;
31506 PyObject * obj2 = 0 ;
31507 PyObject * obj3 = 0 ;
31508 PyObject * obj4 = 0 ;
31509 char * kwnames[] = {
31510 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
31511 };
31512
31513 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
31514 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31515 if (!SWIG_IsOK(res1)) {
31516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31517 }
31518 arg1 = reinterpret_cast< wxWindow * >(argp1);
31519 ecode2 = SWIG_AsVal_int(obj1, &val2);
31520 if (!SWIG_IsOK(ecode2)) {
31521 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
31522 }
31523 arg2 = static_cast< int >(val2);
31524 ecode3 = SWIG_AsVal_int(obj2, &val3);
31525 if (!SWIG_IsOK(ecode3)) {
31526 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
31527 }
31528 arg3 = static_cast< int >(val3);
31529 if (obj3) {
31530 ecode4 = SWIG_AsVal_int(obj3, &val4);
31531 if (!SWIG_IsOK(ecode4)) {
31532 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
31533 }
31534 arg4 = static_cast< int >(val4);
31535 }
31536 if (obj4) {
31537 ecode5 = SWIG_AsVal_int(obj4, &val5);
31538 if (!SWIG_IsOK(ecode5)) {
31539 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
31540 }
31541 arg5 = static_cast< int >(val5);
31542 }
31543 {
31544 PyThreadState* __tstate = wxPyBeginAllowThreads();
31545 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
31546 wxPyEndAllowThreads(__tstate);
31547 if (PyErr_Occurred()) SWIG_fail;
31548 }
31549 resultobj = SWIG_Py_Void();
31550 return resultobj;
31551 fail:
31552 return NULL;
31553 }
31554
31555
31556 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31557 PyObject *resultobj = 0;
31558 wxWindow *arg1 = (wxWindow *) 0 ;
31559 wxSize *arg2 = 0 ;
31560 wxSize const &arg3_defvalue = wxDefaultSize ;
31561 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31562 void *argp1 = 0 ;
31563 int res1 = 0 ;
31564 wxSize temp2 ;
31565 wxSize temp3 ;
31566 PyObject * obj0 = 0 ;
31567 PyObject * obj1 = 0 ;
31568 PyObject * obj2 = 0 ;
31569 char * kwnames[] = {
31570 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
31571 };
31572
31573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31575 if (!SWIG_IsOK(res1)) {
31576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31577 }
31578 arg1 = reinterpret_cast< wxWindow * >(argp1);
31579 {
31580 arg2 = &temp2;
31581 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31582 }
31583 if (obj2) {
31584 {
31585 arg3 = &temp3;
31586 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31587 }
31588 }
31589 {
31590 PyThreadState* __tstate = wxPyBeginAllowThreads();
31591 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
31592 wxPyEndAllowThreads(__tstate);
31593 if (PyErr_Occurred()) SWIG_fail;
31594 }
31595 resultobj = SWIG_Py_Void();
31596 return resultobj;
31597 fail:
31598 return NULL;
31599 }
31600
31601
31602 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31603 PyObject *resultobj = 0;
31604 wxWindow *arg1 = (wxWindow *) 0 ;
31605 wxSize result;
31606 void *argp1 = 0 ;
31607 int res1 = 0 ;
31608 PyObject *swig_obj[1] ;
31609
31610 if (!args) SWIG_fail;
31611 swig_obj[0] = args;
31612 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31613 if (!SWIG_IsOK(res1)) {
31614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31615 }
31616 arg1 = reinterpret_cast< wxWindow * >(argp1);
31617 {
31618 PyThreadState* __tstate = wxPyBeginAllowThreads();
31619 result = ((wxWindow const *)arg1)->GetMaxSize();
31620 wxPyEndAllowThreads(__tstate);
31621 if (PyErr_Occurred()) SWIG_fail;
31622 }
31623 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31624 return resultobj;
31625 fail:
31626 return NULL;
31627 }
31628
31629
31630 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31631 PyObject *resultobj = 0;
31632 wxWindow *arg1 = (wxWindow *) 0 ;
31633 wxSize result;
31634 void *argp1 = 0 ;
31635 int res1 = 0 ;
31636 PyObject *swig_obj[1] ;
31637
31638 if (!args) SWIG_fail;
31639 swig_obj[0] = args;
31640 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31641 if (!SWIG_IsOK(res1)) {
31642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31643 }
31644 arg1 = reinterpret_cast< wxWindow * >(argp1);
31645 {
31646 PyThreadState* __tstate = wxPyBeginAllowThreads();
31647 result = ((wxWindow const *)arg1)->GetMinSize();
31648 wxPyEndAllowThreads(__tstate);
31649 if (PyErr_Occurred()) SWIG_fail;
31650 }
31651 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31652 return resultobj;
31653 fail:
31654 return NULL;
31655 }
31656
31657
31658 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31659 PyObject *resultobj = 0;
31660 wxWindow *arg1 = (wxWindow *) 0 ;
31661 wxSize *arg2 = 0 ;
31662 void *argp1 = 0 ;
31663 int res1 = 0 ;
31664 wxSize temp2 ;
31665 PyObject * obj0 = 0 ;
31666 PyObject * obj1 = 0 ;
31667 char * kwnames[] = {
31668 (char *) "self",(char *) "minSize", NULL
31669 };
31670
31671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
31672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31673 if (!SWIG_IsOK(res1)) {
31674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31675 }
31676 arg1 = reinterpret_cast< wxWindow * >(argp1);
31677 {
31678 arg2 = &temp2;
31679 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31680 }
31681 {
31682 PyThreadState* __tstate = wxPyBeginAllowThreads();
31683 (arg1)->SetMinSize((wxSize const &)*arg2);
31684 wxPyEndAllowThreads(__tstate);
31685 if (PyErr_Occurred()) SWIG_fail;
31686 }
31687 resultobj = SWIG_Py_Void();
31688 return resultobj;
31689 fail:
31690 return NULL;
31691 }
31692
31693
31694 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31695 PyObject *resultobj = 0;
31696 wxWindow *arg1 = (wxWindow *) 0 ;
31697 wxSize *arg2 = 0 ;
31698 void *argp1 = 0 ;
31699 int res1 = 0 ;
31700 wxSize temp2 ;
31701 PyObject * obj0 = 0 ;
31702 PyObject * obj1 = 0 ;
31703 char * kwnames[] = {
31704 (char *) "self",(char *) "maxSize", NULL
31705 };
31706
31707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
31708 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31709 if (!SWIG_IsOK(res1)) {
31710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31711 }
31712 arg1 = reinterpret_cast< wxWindow * >(argp1);
31713 {
31714 arg2 = &temp2;
31715 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31716 }
31717 {
31718 PyThreadState* __tstate = wxPyBeginAllowThreads();
31719 (arg1)->SetMaxSize((wxSize const &)*arg2);
31720 wxPyEndAllowThreads(__tstate);
31721 if (PyErr_Occurred()) SWIG_fail;
31722 }
31723 resultobj = SWIG_Py_Void();
31724 return resultobj;
31725 fail:
31726 return NULL;
31727 }
31728
31729
31730 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31731 PyObject *resultobj = 0;
31732 wxWindow *arg1 = (wxWindow *) 0 ;
31733 int result;
31734 void *argp1 = 0 ;
31735 int res1 = 0 ;
31736 PyObject *swig_obj[1] ;
31737
31738 if (!args) SWIG_fail;
31739 swig_obj[0] = args;
31740 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31741 if (!SWIG_IsOK(res1)) {
31742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
31743 }
31744 arg1 = reinterpret_cast< wxWindow * >(argp1);
31745 {
31746 PyThreadState* __tstate = wxPyBeginAllowThreads();
31747 result = (int)((wxWindow const *)arg1)->GetMinWidth();
31748 wxPyEndAllowThreads(__tstate);
31749 if (PyErr_Occurred()) SWIG_fail;
31750 }
31751 resultobj = SWIG_From_int(static_cast< int >(result));
31752 return resultobj;
31753 fail:
31754 return NULL;
31755 }
31756
31757
31758 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31759 PyObject *resultobj = 0;
31760 wxWindow *arg1 = (wxWindow *) 0 ;
31761 int result;
31762 void *argp1 = 0 ;
31763 int res1 = 0 ;
31764 PyObject *swig_obj[1] ;
31765
31766 if (!args) SWIG_fail;
31767 swig_obj[0] = args;
31768 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31769 if (!SWIG_IsOK(res1)) {
31770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
31771 }
31772 arg1 = reinterpret_cast< wxWindow * >(argp1);
31773 {
31774 PyThreadState* __tstate = wxPyBeginAllowThreads();
31775 result = (int)((wxWindow const *)arg1)->GetMinHeight();
31776 wxPyEndAllowThreads(__tstate);
31777 if (PyErr_Occurred()) SWIG_fail;
31778 }
31779 resultobj = SWIG_From_int(static_cast< int >(result));
31780 return resultobj;
31781 fail:
31782 return NULL;
31783 }
31784
31785
31786 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31787 PyObject *resultobj = 0;
31788 wxWindow *arg1 = (wxWindow *) 0 ;
31789 int result;
31790 void *argp1 = 0 ;
31791 int res1 = 0 ;
31792 PyObject *swig_obj[1] ;
31793
31794 if (!args) SWIG_fail;
31795 swig_obj[0] = args;
31796 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31797 if (!SWIG_IsOK(res1)) {
31798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
31799 }
31800 arg1 = reinterpret_cast< wxWindow * >(argp1);
31801 {
31802 PyThreadState* __tstate = wxPyBeginAllowThreads();
31803 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
31804 wxPyEndAllowThreads(__tstate);
31805 if (PyErr_Occurred()) SWIG_fail;
31806 }
31807 resultobj = SWIG_From_int(static_cast< int >(result));
31808 return resultobj;
31809 fail:
31810 return NULL;
31811 }
31812
31813
31814 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31815 PyObject *resultobj = 0;
31816 wxWindow *arg1 = (wxWindow *) 0 ;
31817 int result;
31818 void *argp1 = 0 ;
31819 int res1 = 0 ;
31820 PyObject *swig_obj[1] ;
31821
31822 if (!args) SWIG_fail;
31823 swig_obj[0] = args;
31824 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31825 if (!SWIG_IsOK(res1)) {
31826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
31827 }
31828 arg1 = reinterpret_cast< wxWindow * >(argp1);
31829 {
31830 PyThreadState* __tstate = wxPyBeginAllowThreads();
31831 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
31832 wxPyEndAllowThreads(__tstate);
31833 if (PyErr_Occurred()) SWIG_fail;
31834 }
31835 resultobj = SWIG_From_int(static_cast< int >(result));
31836 return resultobj;
31837 fail:
31838 return NULL;
31839 }
31840
31841
31842 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31843 PyObject *resultobj = 0;
31844 wxWindow *arg1 = (wxWindow *) 0 ;
31845 wxSize *arg2 = 0 ;
31846 void *argp1 = 0 ;
31847 int res1 = 0 ;
31848 wxSize temp2 ;
31849 PyObject * obj0 = 0 ;
31850 PyObject * obj1 = 0 ;
31851 char * kwnames[] = {
31852 (char *) "self",(char *) "size", NULL
31853 };
31854
31855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
31856 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31857 if (!SWIG_IsOK(res1)) {
31858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31859 }
31860 arg1 = reinterpret_cast< wxWindow * >(argp1);
31861 {
31862 arg2 = &temp2;
31863 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31864 }
31865 {
31866 PyThreadState* __tstate = wxPyBeginAllowThreads();
31867 (arg1)->SetVirtualSize((wxSize const &)*arg2);
31868 wxPyEndAllowThreads(__tstate);
31869 if (PyErr_Occurred()) SWIG_fail;
31870 }
31871 resultobj = SWIG_Py_Void();
31872 return resultobj;
31873 fail:
31874 return NULL;
31875 }
31876
31877
31878 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31879 PyObject *resultobj = 0;
31880 wxWindow *arg1 = (wxWindow *) 0 ;
31881 int arg2 ;
31882 int arg3 ;
31883 void *argp1 = 0 ;
31884 int res1 = 0 ;
31885 int val2 ;
31886 int ecode2 = 0 ;
31887 int val3 ;
31888 int ecode3 = 0 ;
31889 PyObject * obj0 = 0 ;
31890 PyObject * obj1 = 0 ;
31891 PyObject * obj2 = 0 ;
31892 char * kwnames[] = {
31893 (char *) "self",(char *) "w",(char *) "h", NULL
31894 };
31895
31896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31897 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31898 if (!SWIG_IsOK(res1)) {
31899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
31900 }
31901 arg1 = reinterpret_cast< wxWindow * >(argp1);
31902 ecode2 = SWIG_AsVal_int(obj1, &val2);
31903 if (!SWIG_IsOK(ecode2)) {
31904 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
31905 }
31906 arg2 = static_cast< int >(val2);
31907 ecode3 = SWIG_AsVal_int(obj2, &val3);
31908 if (!SWIG_IsOK(ecode3)) {
31909 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
31910 }
31911 arg3 = static_cast< int >(val3);
31912 {
31913 PyThreadState* __tstate = wxPyBeginAllowThreads();
31914 (arg1)->SetVirtualSize(arg2,arg3);
31915 wxPyEndAllowThreads(__tstate);
31916 if (PyErr_Occurred()) SWIG_fail;
31917 }
31918 resultobj = SWIG_Py_Void();
31919 return resultobj;
31920 fail:
31921 return NULL;
31922 }
31923
31924
31925 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31926 PyObject *resultobj = 0;
31927 wxWindow *arg1 = (wxWindow *) 0 ;
31928 wxSize result;
31929 void *argp1 = 0 ;
31930 int res1 = 0 ;
31931 PyObject *swig_obj[1] ;
31932
31933 if (!args) SWIG_fail;
31934 swig_obj[0] = args;
31935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31936 if (!SWIG_IsOK(res1)) {
31937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31938 }
31939 arg1 = reinterpret_cast< wxWindow * >(argp1);
31940 {
31941 PyThreadState* __tstate = wxPyBeginAllowThreads();
31942 result = ((wxWindow const *)arg1)->GetVirtualSize();
31943 wxPyEndAllowThreads(__tstate);
31944 if (PyErr_Occurred()) SWIG_fail;
31945 }
31946 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31947 return resultobj;
31948 fail:
31949 return NULL;
31950 }
31951
31952
31953 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31954 PyObject *resultobj = 0;
31955 wxWindow *arg1 = (wxWindow *) 0 ;
31956 int *arg2 = (int *) 0 ;
31957 int *arg3 = (int *) 0 ;
31958 void *argp1 = 0 ;
31959 int res1 = 0 ;
31960 int temp2 ;
31961 int res2 = SWIG_TMPOBJ ;
31962 int temp3 ;
31963 int res3 = SWIG_TMPOBJ ;
31964 PyObject *swig_obj[1] ;
31965
31966 arg2 = &temp2;
31967 arg3 = &temp3;
31968 if (!args) SWIG_fail;
31969 swig_obj[0] = args;
31970 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31971 if (!SWIG_IsOK(res1)) {
31972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31973 }
31974 arg1 = reinterpret_cast< wxWindow * >(argp1);
31975 {
31976 PyThreadState* __tstate = wxPyBeginAllowThreads();
31977 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
31978 wxPyEndAllowThreads(__tstate);
31979 if (PyErr_Occurred()) SWIG_fail;
31980 }
31981 resultobj = SWIG_Py_Void();
31982 if (SWIG_IsTmpObj(res2)) {
31983 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31984 } else {
31985 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31986 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31987 }
31988 if (SWIG_IsTmpObj(res3)) {
31989 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31990 } else {
31991 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31992 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31993 }
31994 return resultobj;
31995 fail:
31996 return NULL;
31997 }
31998
31999
32000 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32001 PyObject *resultobj = 0;
32002 wxWindow *arg1 = (wxWindow *) 0 ;
32003 wxSize result;
32004 void *argp1 = 0 ;
32005 int res1 = 0 ;
32006 PyObject *swig_obj[1] ;
32007
32008 if (!args) SWIG_fail;
32009 swig_obj[0] = args;
32010 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32011 if (!SWIG_IsOK(res1)) {
32012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32013 }
32014 arg1 = reinterpret_cast< wxWindow * >(argp1);
32015 {
32016 PyThreadState* __tstate = wxPyBeginAllowThreads();
32017 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
32018 wxPyEndAllowThreads(__tstate);
32019 if (PyErr_Occurred()) SWIG_fail;
32020 }
32021 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32022 return resultobj;
32023 fail:
32024 return NULL;
32025 }
32026
32027
32028 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32029 PyObject *resultobj = 0;
32030 wxWindow *arg1 = (wxWindow *) 0 ;
32031 bool arg2 = (bool) true ;
32032 bool result;
32033 void *argp1 = 0 ;
32034 int res1 = 0 ;
32035 bool val2 ;
32036 int ecode2 = 0 ;
32037 PyObject * obj0 = 0 ;
32038 PyObject * obj1 = 0 ;
32039 char * kwnames[] = {
32040 (char *) "self",(char *) "show", NULL
32041 };
32042
32043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
32044 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32045 if (!SWIG_IsOK(res1)) {
32046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
32047 }
32048 arg1 = reinterpret_cast< wxWindow * >(argp1);
32049 if (obj1) {
32050 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32051 if (!SWIG_IsOK(ecode2)) {
32052 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
32053 }
32054 arg2 = static_cast< bool >(val2);
32055 }
32056 {
32057 PyThreadState* __tstate = wxPyBeginAllowThreads();
32058 result = (bool)(arg1)->Show(arg2);
32059 wxPyEndAllowThreads(__tstate);
32060 if (PyErr_Occurred()) SWIG_fail;
32061 }
32062 {
32063 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32064 }
32065 return resultobj;
32066 fail:
32067 return NULL;
32068 }
32069
32070
32071 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32072 PyObject *resultobj = 0;
32073 wxWindow *arg1 = (wxWindow *) 0 ;
32074 bool result;
32075 void *argp1 = 0 ;
32076 int res1 = 0 ;
32077 PyObject *swig_obj[1] ;
32078
32079 if (!args) SWIG_fail;
32080 swig_obj[0] = args;
32081 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32082 if (!SWIG_IsOK(res1)) {
32083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
32084 }
32085 arg1 = reinterpret_cast< wxWindow * >(argp1);
32086 {
32087 PyThreadState* __tstate = wxPyBeginAllowThreads();
32088 result = (bool)(arg1)->Hide();
32089 wxPyEndAllowThreads(__tstate);
32090 if (PyErr_Occurred()) SWIG_fail;
32091 }
32092 {
32093 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32094 }
32095 return resultobj;
32096 fail:
32097 return NULL;
32098 }
32099
32100
32101 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32102 PyObject *resultobj = 0;
32103 wxWindow *arg1 = (wxWindow *) 0 ;
32104 bool arg2 = (bool) true ;
32105 bool result;
32106 void *argp1 = 0 ;
32107 int res1 = 0 ;
32108 bool val2 ;
32109 int ecode2 = 0 ;
32110 PyObject * obj0 = 0 ;
32111 PyObject * obj1 = 0 ;
32112 char * kwnames[] = {
32113 (char *) "self",(char *) "enable", NULL
32114 };
32115
32116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
32117 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32118 if (!SWIG_IsOK(res1)) {
32119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
32120 }
32121 arg1 = reinterpret_cast< wxWindow * >(argp1);
32122 if (obj1) {
32123 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32124 if (!SWIG_IsOK(ecode2)) {
32125 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
32126 }
32127 arg2 = static_cast< bool >(val2);
32128 }
32129 {
32130 PyThreadState* __tstate = wxPyBeginAllowThreads();
32131 result = (bool)(arg1)->Enable(arg2);
32132 wxPyEndAllowThreads(__tstate);
32133 if (PyErr_Occurred()) SWIG_fail;
32134 }
32135 {
32136 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32137 }
32138 return resultobj;
32139 fail:
32140 return NULL;
32141 }
32142
32143
32144 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32145 PyObject *resultobj = 0;
32146 wxWindow *arg1 = (wxWindow *) 0 ;
32147 bool result;
32148 void *argp1 = 0 ;
32149 int res1 = 0 ;
32150 PyObject *swig_obj[1] ;
32151
32152 if (!args) SWIG_fail;
32153 swig_obj[0] = args;
32154 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32155 if (!SWIG_IsOK(res1)) {
32156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
32157 }
32158 arg1 = reinterpret_cast< wxWindow * >(argp1);
32159 {
32160 PyThreadState* __tstate = wxPyBeginAllowThreads();
32161 result = (bool)(arg1)->Disable();
32162 wxPyEndAllowThreads(__tstate);
32163 if (PyErr_Occurred()) SWIG_fail;
32164 }
32165 {
32166 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32167 }
32168 return resultobj;
32169 fail:
32170 return NULL;
32171 }
32172
32173
32174 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32175 PyObject *resultobj = 0;
32176 wxWindow *arg1 = (wxWindow *) 0 ;
32177 bool result;
32178 void *argp1 = 0 ;
32179 int res1 = 0 ;
32180 PyObject *swig_obj[1] ;
32181
32182 if (!args) SWIG_fail;
32183 swig_obj[0] = args;
32184 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32185 if (!SWIG_IsOK(res1)) {
32186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
32187 }
32188 arg1 = reinterpret_cast< wxWindow * >(argp1);
32189 {
32190 PyThreadState* __tstate = wxPyBeginAllowThreads();
32191 result = (bool)((wxWindow const *)arg1)->IsShown();
32192 wxPyEndAllowThreads(__tstate);
32193 if (PyErr_Occurred()) SWIG_fail;
32194 }
32195 {
32196 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32197 }
32198 return resultobj;
32199 fail:
32200 return NULL;
32201 }
32202
32203
32204 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32205 PyObject *resultobj = 0;
32206 wxWindow *arg1 = (wxWindow *) 0 ;
32207 bool result;
32208 void *argp1 = 0 ;
32209 int res1 = 0 ;
32210 PyObject *swig_obj[1] ;
32211
32212 if (!args) SWIG_fail;
32213 swig_obj[0] = args;
32214 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32215 if (!SWIG_IsOK(res1)) {
32216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32217 }
32218 arg1 = reinterpret_cast< wxWindow * >(argp1);
32219 {
32220 PyThreadState* __tstate = wxPyBeginAllowThreads();
32221 result = (bool)((wxWindow const *)arg1)->IsEnabled();
32222 wxPyEndAllowThreads(__tstate);
32223 if (PyErr_Occurred()) SWIG_fail;
32224 }
32225 {
32226 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32227 }
32228 return resultobj;
32229 fail:
32230 return NULL;
32231 }
32232
32233
32234 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32235 PyObject *resultobj = 0;
32236 wxWindow *arg1 = (wxWindow *) 0 ;
32237 long arg2 ;
32238 void *argp1 = 0 ;
32239 int res1 = 0 ;
32240 long val2 ;
32241 int ecode2 = 0 ;
32242 PyObject * obj0 = 0 ;
32243 PyObject * obj1 = 0 ;
32244 char * kwnames[] = {
32245 (char *) "self",(char *) "style", NULL
32246 };
32247
32248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32250 if (!SWIG_IsOK(res1)) {
32251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
32252 }
32253 arg1 = reinterpret_cast< wxWindow * >(argp1);
32254 ecode2 = SWIG_AsVal_long(obj1, &val2);
32255 if (!SWIG_IsOK(ecode2)) {
32256 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
32257 }
32258 arg2 = static_cast< long >(val2);
32259 {
32260 PyThreadState* __tstate = wxPyBeginAllowThreads();
32261 (arg1)->SetWindowStyleFlag(arg2);
32262 wxPyEndAllowThreads(__tstate);
32263 if (PyErr_Occurred()) SWIG_fail;
32264 }
32265 resultobj = SWIG_Py_Void();
32266 return resultobj;
32267 fail:
32268 return NULL;
32269 }
32270
32271
32272 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32273 PyObject *resultobj = 0;
32274 wxWindow *arg1 = (wxWindow *) 0 ;
32275 long result;
32276 void *argp1 = 0 ;
32277 int res1 = 0 ;
32278 PyObject *swig_obj[1] ;
32279
32280 if (!args) SWIG_fail;
32281 swig_obj[0] = args;
32282 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32283 if (!SWIG_IsOK(res1)) {
32284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32285 }
32286 arg1 = reinterpret_cast< wxWindow * >(argp1);
32287 {
32288 PyThreadState* __tstate = wxPyBeginAllowThreads();
32289 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
32290 wxPyEndAllowThreads(__tstate);
32291 if (PyErr_Occurred()) SWIG_fail;
32292 }
32293 resultobj = SWIG_From_long(static_cast< long >(result));
32294 return resultobj;
32295 fail:
32296 return NULL;
32297 }
32298
32299
32300 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32301 PyObject *resultobj = 0;
32302 wxWindow *arg1 = (wxWindow *) 0 ;
32303 int arg2 ;
32304 bool result;
32305 void *argp1 = 0 ;
32306 int res1 = 0 ;
32307 int val2 ;
32308 int ecode2 = 0 ;
32309 PyObject * obj0 = 0 ;
32310 PyObject * obj1 = 0 ;
32311 char * kwnames[] = {
32312 (char *) "self",(char *) "flag", NULL
32313 };
32314
32315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32316 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32317 if (!SWIG_IsOK(res1)) {
32318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32319 }
32320 arg1 = reinterpret_cast< wxWindow * >(argp1);
32321 ecode2 = SWIG_AsVal_int(obj1, &val2);
32322 if (!SWIG_IsOK(ecode2)) {
32323 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
32324 }
32325 arg2 = static_cast< int >(val2);
32326 {
32327 PyThreadState* __tstate = wxPyBeginAllowThreads();
32328 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
32329 wxPyEndAllowThreads(__tstate);
32330 if (PyErr_Occurred()) SWIG_fail;
32331 }
32332 {
32333 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32334 }
32335 return resultobj;
32336 fail:
32337 return NULL;
32338 }
32339
32340
32341 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32342 PyObject *resultobj = 0;
32343 wxWindow *arg1 = (wxWindow *) 0 ;
32344 bool result;
32345 void *argp1 = 0 ;
32346 int res1 = 0 ;
32347 PyObject *swig_obj[1] ;
32348
32349 if (!args) SWIG_fail;
32350 swig_obj[0] = args;
32351 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32352 if (!SWIG_IsOK(res1)) {
32353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
32354 }
32355 arg1 = reinterpret_cast< wxWindow * >(argp1);
32356 {
32357 PyThreadState* __tstate = wxPyBeginAllowThreads();
32358 result = (bool)((wxWindow const *)arg1)->IsRetained();
32359 wxPyEndAllowThreads(__tstate);
32360 if (PyErr_Occurred()) SWIG_fail;
32361 }
32362 {
32363 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32364 }
32365 return resultobj;
32366 fail:
32367 return NULL;
32368 }
32369
32370
32371 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32372 PyObject *resultobj = 0;
32373 wxWindow *arg1 = (wxWindow *) 0 ;
32374 long arg2 ;
32375 void *argp1 = 0 ;
32376 int res1 = 0 ;
32377 long val2 ;
32378 int ecode2 = 0 ;
32379 PyObject * obj0 = 0 ;
32380 PyObject * obj1 = 0 ;
32381 char * kwnames[] = {
32382 (char *) "self",(char *) "exStyle", NULL
32383 };
32384
32385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
32386 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32387 if (!SWIG_IsOK(res1)) {
32388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
32389 }
32390 arg1 = reinterpret_cast< wxWindow * >(argp1);
32391 ecode2 = SWIG_AsVal_long(obj1, &val2);
32392 if (!SWIG_IsOK(ecode2)) {
32393 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
32394 }
32395 arg2 = static_cast< long >(val2);
32396 {
32397 PyThreadState* __tstate = wxPyBeginAllowThreads();
32398 (arg1)->SetExtraStyle(arg2);
32399 wxPyEndAllowThreads(__tstate);
32400 if (PyErr_Occurred()) SWIG_fail;
32401 }
32402 resultobj = SWIG_Py_Void();
32403 return resultobj;
32404 fail:
32405 return NULL;
32406 }
32407
32408
32409 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32410 PyObject *resultobj = 0;
32411 wxWindow *arg1 = (wxWindow *) 0 ;
32412 long result;
32413 void *argp1 = 0 ;
32414 int res1 = 0 ;
32415 PyObject *swig_obj[1] ;
32416
32417 if (!args) SWIG_fail;
32418 swig_obj[0] = args;
32419 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32420 if (!SWIG_IsOK(res1)) {
32421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
32422 }
32423 arg1 = reinterpret_cast< wxWindow * >(argp1);
32424 {
32425 PyThreadState* __tstate = wxPyBeginAllowThreads();
32426 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
32427 wxPyEndAllowThreads(__tstate);
32428 if (PyErr_Occurred()) SWIG_fail;
32429 }
32430 resultobj = SWIG_From_long(static_cast< long >(result));
32431 return resultobj;
32432 fail:
32433 return NULL;
32434 }
32435
32436
32437 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32438 PyObject *resultobj = 0;
32439 wxWindow *arg1 = (wxWindow *) 0 ;
32440 bool arg2 = (bool) true ;
32441 void *argp1 = 0 ;
32442 int res1 = 0 ;
32443 bool val2 ;
32444 int ecode2 = 0 ;
32445 PyObject * obj0 = 0 ;
32446 PyObject * obj1 = 0 ;
32447 char * kwnames[] = {
32448 (char *) "self",(char *) "modal", NULL
32449 };
32450
32451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
32452 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32453 if (!SWIG_IsOK(res1)) {
32454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
32455 }
32456 arg1 = reinterpret_cast< wxWindow * >(argp1);
32457 if (obj1) {
32458 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32459 if (!SWIG_IsOK(ecode2)) {
32460 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
32461 }
32462 arg2 = static_cast< bool >(val2);
32463 }
32464 {
32465 PyThreadState* __tstate = wxPyBeginAllowThreads();
32466 (arg1)->MakeModal(arg2);
32467 wxPyEndAllowThreads(__tstate);
32468 if (PyErr_Occurred()) SWIG_fail;
32469 }
32470 resultobj = SWIG_Py_Void();
32471 return resultobj;
32472 fail:
32473 return NULL;
32474 }
32475
32476
32477 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32478 PyObject *resultobj = 0;
32479 wxWindow *arg1 = (wxWindow *) 0 ;
32480 bool arg2 ;
32481 void *argp1 = 0 ;
32482 int res1 = 0 ;
32483 bool val2 ;
32484 int ecode2 = 0 ;
32485 PyObject * obj0 = 0 ;
32486 PyObject * obj1 = 0 ;
32487 char * kwnames[] = {
32488 (char *) "self",(char *) "enableTheme", NULL
32489 };
32490
32491 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
32492 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32493 if (!SWIG_IsOK(res1)) {
32494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
32495 }
32496 arg1 = reinterpret_cast< wxWindow * >(argp1);
32497 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32498 if (!SWIG_IsOK(ecode2)) {
32499 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
32500 }
32501 arg2 = static_cast< bool >(val2);
32502 {
32503 PyThreadState* __tstate = wxPyBeginAllowThreads();
32504 (arg1)->SetThemeEnabled(arg2);
32505 wxPyEndAllowThreads(__tstate);
32506 if (PyErr_Occurred()) SWIG_fail;
32507 }
32508 resultobj = SWIG_Py_Void();
32509 return resultobj;
32510 fail:
32511 return NULL;
32512 }
32513
32514
32515 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32516 PyObject *resultobj = 0;
32517 wxWindow *arg1 = (wxWindow *) 0 ;
32518 bool result;
32519 void *argp1 = 0 ;
32520 int res1 = 0 ;
32521 PyObject *swig_obj[1] ;
32522
32523 if (!args) SWIG_fail;
32524 swig_obj[0] = args;
32525 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32526 if (!SWIG_IsOK(res1)) {
32527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32528 }
32529 arg1 = reinterpret_cast< wxWindow * >(argp1);
32530 {
32531 PyThreadState* __tstate = wxPyBeginAllowThreads();
32532 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
32533 wxPyEndAllowThreads(__tstate);
32534 if (PyErr_Occurred()) SWIG_fail;
32535 }
32536 {
32537 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32538 }
32539 return resultobj;
32540 fail:
32541 return NULL;
32542 }
32543
32544
32545 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32546 PyObject *resultobj = 0;
32547 wxWindow *arg1 = (wxWindow *) 0 ;
32548 void *argp1 = 0 ;
32549 int res1 = 0 ;
32550 PyObject *swig_obj[1] ;
32551
32552 if (!args) SWIG_fail;
32553 swig_obj[0] = args;
32554 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32555 if (!SWIG_IsOK(res1)) {
32556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
32557 }
32558 arg1 = reinterpret_cast< wxWindow * >(argp1);
32559 {
32560 PyThreadState* __tstate = wxPyBeginAllowThreads();
32561 (arg1)->SetFocus();
32562 wxPyEndAllowThreads(__tstate);
32563 if (PyErr_Occurred()) SWIG_fail;
32564 }
32565 resultobj = SWIG_Py_Void();
32566 return resultobj;
32567 fail:
32568 return NULL;
32569 }
32570
32571
32572 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32573 PyObject *resultobj = 0;
32574 wxWindow *arg1 = (wxWindow *) 0 ;
32575 void *argp1 = 0 ;
32576 int res1 = 0 ;
32577 PyObject *swig_obj[1] ;
32578
32579 if (!args) SWIG_fail;
32580 swig_obj[0] = args;
32581 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32582 if (!SWIG_IsOK(res1)) {
32583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
32584 }
32585 arg1 = reinterpret_cast< wxWindow * >(argp1);
32586 {
32587 PyThreadState* __tstate = wxPyBeginAllowThreads();
32588 (arg1)->SetFocusFromKbd();
32589 wxPyEndAllowThreads(__tstate);
32590 if (PyErr_Occurred()) SWIG_fail;
32591 }
32592 resultobj = SWIG_Py_Void();
32593 return resultobj;
32594 fail:
32595 return NULL;
32596 }
32597
32598
32599 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32600 PyObject *resultobj = 0;
32601 wxWindow *result = 0 ;
32602
32603 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
32604 {
32605 if (!wxPyCheckForApp()) SWIG_fail;
32606 PyThreadState* __tstate = wxPyBeginAllowThreads();
32607 result = (wxWindow *)wxWindow::FindFocus();
32608 wxPyEndAllowThreads(__tstate);
32609 if (PyErr_Occurred()) SWIG_fail;
32610 }
32611 {
32612 resultobj = wxPyMake_wxObject(result, 0);
32613 }
32614 return resultobj;
32615 fail:
32616 return NULL;
32617 }
32618
32619
32620 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32621 PyObject *resultobj = 0;
32622 wxWindow *arg1 = (wxWindow *) 0 ;
32623 bool result;
32624 void *argp1 = 0 ;
32625 int res1 = 0 ;
32626 PyObject *swig_obj[1] ;
32627
32628 if (!args) SWIG_fail;
32629 swig_obj[0] = args;
32630 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32631 if (!SWIG_IsOK(res1)) {
32632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
32633 }
32634 arg1 = reinterpret_cast< wxWindow * >(argp1);
32635 {
32636 PyThreadState* __tstate = wxPyBeginAllowThreads();
32637 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
32638 wxPyEndAllowThreads(__tstate);
32639 if (PyErr_Occurred()) SWIG_fail;
32640 }
32641 {
32642 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32643 }
32644 return resultobj;
32645 fail:
32646 return NULL;
32647 }
32648
32649
32650 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32651 PyObject *resultobj = 0;
32652 wxWindow *arg1 = (wxWindow *) 0 ;
32653 bool result;
32654 void *argp1 = 0 ;
32655 int res1 = 0 ;
32656 PyObject *swig_obj[1] ;
32657
32658 if (!args) SWIG_fail;
32659 swig_obj[0] = args;
32660 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32661 if (!SWIG_IsOK(res1)) {
32662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
32663 }
32664 arg1 = reinterpret_cast< wxWindow * >(argp1);
32665 {
32666 PyThreadState* __tstate = wxPyBeginAllowThreads();
32667 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
32668 wxPyEndAllowThreads(__tstate);
32669 if (PyErr_Occurred()) SWIG_fail;
32670 }
32671 {
32672 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32673 }
32674 return resultobj;
32675 fail:
32676 return NULL;
32677 }
32678
32679
32680 SWIGINTERN PyObject *_wrap_Window_GetDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32681 PyObject *resultobj = 0;
32682 wxWindow *arg1 = (wxWindow *) 0 ;
32683 wxWindow *result = 0 ;
32684 void *argp1 = 0 ;
32685 int res1 = 0 ;
32686 PyObject *swig_obj[1] ;
32687
32688 if (!args) SWIG_fail;
32689 swig_obj[0] = args;
32690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32691 if (!SWIG_IsOK(res1)) {
32692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultItem" "', expected argument " "1"" of type '" "wxWindow const *""'");
32693 }
32694 arg1 = reinterpret_cast< wxWindow * >(argp1);
32695 {
32696 PyThreadState* __tstate = wxPyBeginAllowThreads();
32697 result = (wxWindow *)((wxWindow const *)arg1)->GetDefaultItem();
32698 wxPyEndAllowThreads(__tstate);
32699 if (PyErr_Occurred()) SWIG_fail;
32700 }
32701 {
32702 resultobj = wxPyMake_wxObject(result, 0);
32703 }
32704 return resultobj;
32705 fail:
32706 return NULL;
32707 }
32708
32709
32710 SWIGINTERN PyObject *_wrap_Window_SetDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32711 PyObject *resultobj = 0;
32712 wxWindow *arg1 = (wxWindow *) 0 ;
32713 wxWindow *arg2 = (wxWindow *) 0 ;
32714 wxWindow *result = 0 ;
32715 void *argp1 = 0 ;
32716 int res1 = 0 ;
32717 void *argp2 = 0 ;
32718 int res2 = 0 ;
32719 PyObject * obj0 = 0 ;
32720 PyObject * obj1 = 0 ;
32721 char * kwnames[] = {
32722 (char *) "self",(char *) "child", NULL
32723 };
32724
32725 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDefaultItem",kwnames,&obj0,&obj1)) SWIG_fail;
32726 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32727 if (!SWIG_IsOK(res1)) {
32728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDefaultItem" "', expected argument " "1"" of type '" "wxWindow *""'");
32729 }
32730 arg1 = reinterpret_cast< wxWindow * >(argp1);
32731 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32732 if (!SWIG_IsOK(res2)) {
32733 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDefaultItem" "', expected argument " "2"" of type '" "wxWindow *""'");
32734 }
32735 arg2 = reinterpret_cast< wxWindow * >(argp2);
32736 {
32737 PyThreadState* __tstate = wxPyBeginAllowThreads();
32738 result = (wxWindow *)(arg1)->SetDefaultItem(arg2);
32739 wxPyEndAllowThreads(__tstate);
32740 if (PyErr_Occurred()) SWIG_fail;
32741 }
32742 {
32743 resultobj = wxPyMake_wxObject(result, 0);
32744 }
32745 return resultobj;
32746 fail:
32747 return NULL;
32748 }
32749
32750
32751 SWIGINTERN PyObject *_wrap_Window_SetTmpDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32752 PyObject *resultobj = 0;
32753 wxWindow *arg1 = (wxWindow *) 0 ;
32754 wxWindow *arg2 = (wxWindow *) 0 ;
32755 void *argp1 = 0 ;
32756 int res1 = 0 ;
32757 void *argp2 = 0 ;
32758 int res2 = 0 ;
32759 PyObject * obj0 = 0 ;
32760 PyObject * obj1 = 0 ;
32761 char * kwnames[] = {
32762 (char *) "self",(char *) "win", NULL
32763 };
32764
32765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTmpDefaultItem",kwnames,&obj0,&obj1)) SWIG_fail;
32766 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32767 if (!SWIG_IsOK(res1)) {
32768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTmpDefaultItem" "', expected argument " "1"" of type '" "wxWindow *""'");
32769 }
32770 arg1 = reinterpret_cast< wxWindow * >(argp1);
32771 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32772 if (!SWIG_IsOK(res2)) {
32773 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetTmpDefaultItem" "', expected argument " "2"" of type '" "wxWindow *""'");
32774 }
32775 arg2 = reinterpret_cast< wxWindow * >(argp2);
32776 {
32777 PyThreadState* __tstate = wxPyBeginAllowThreads();
32778 (arg1)->SetTmpDefaultItem(arg2);
32779 wxPyEndAllowThreads(__tstate);
32780 if (PyErr_Occurred()) SWIG_fail;
32781 }
32782 resultobj = SWIG_Py_Void();
32783 return resultobj;
32784 fail:
32785 return NULL;
32786 }
32787
32788
32789 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32790 PyObject *resultobj = 0;
32791 wxWindow *arg1 = (wxWindow *) 0 ;
32792 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
32793 bool result;
32794 void *argp1 = 0 ;
32795 int res1 = 0 ;
32796 int val2 ;
32797 int ecode2 = 0 ;
32798 PyObject * obj0 = 0 ;
32799 PyObject * obj1 = 0 ;
32800 char * kwnames[] = {
32801 (char *) "self",(char *) "flags", NULL
32802 };
32803
32804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
32805 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32806 if (!SWIG_IsOK(res1)) {
32807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
32808 }
32809 arg1 = reinterpret_cast< wxWindow * >(argp1);
32810 if (obj1) {
32811 ecode2 = SWIG_AsVal_int(obj1, &val2);
32812 if (!SWIG_IsOK(ecode2)) {
32813 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
32814 }
32815 arg2 = static_cast< int >(val2);
32816 }
32817 {
32818 PyThreadState* __tstate = wxPyBeginAllowThreads();
32819 result = (bool)(arg1)->Navigate(arg2);
32820 wxPyEndAllowThreads(__tstate);
32821 if (PyErr_Occurred()) SWIG_fail;
32822 }
32823 {
32824 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32825 }
32826 return resultobj;
32827 fail:
32828 return NULL;
32829 }
32830
32831
32832 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32833 PyObject *resultobj = 0;
32834 wxWindow *arg1 = (wxWindow *) 0 ;
32835 wxWindow *arg2 = (wxWindow *) 0 ;
32836 void *argp1 = 0 ;
32837 int res1 = 0 ;
32838 void *argp2 = 0 ;
32839 int res2 = 0 ;
32840 PyObject * obj0 = 0 ;
32841 PyObject * obj1 = 0 ;
32842 char * kwnames[] = {
32843 (char *) "self",(char *) "win", NULL
32844 };
32845
32846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
32847 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32848 if (!SWIG_IsOK(res1)) {
32849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
32850 }
32851 arg1 = reinterpret_cast< wxWindow * >(argp1);
32852 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32853 if (!SWIG_IsOK(res2)) {
32854 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
32855 }
32856 arg2 = reinterpret_cast< wxWindow * >(argp2);
32857 {
32858 PyThreadState* __tstate = wxPyBeginAllowThreads();
32859 (arg1)->MoveAfterInTabOrder(arg2);
32860 wxPyEndAllowThreads(__tstate);
32861 if (PyErr_Occurred()) SWIG_fail;
32862 }
32863 resultobj = SWIG_Py_Void();
32864 return resultobj;
32865 fail:
32866 return NULL;
32867 }
32868
32869
32870 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32871 PyObject *resultobj = 0;
32872 wxWindow *arg1 = (wxWindow *) 0 ;
32873 wxWindow *arg2 = (wxWindow *) 0 ;
32874 void *argp1 = 0 ;
32875 int res1 = 0 ;
32876 void *argp2 = 0 ;
32877 int res2 = 0 ;
32878 PyObject * obj0 = 0 ;
32879 PyObject * obj1 = 0 ;
32880 char * kwnames[] = {
32881 (char *) "self",(char *) "win", NULL
32882 };
32883
32884 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
32885 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32886 if (!SWIG_IsOK(res1)) {
32887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
32888 }
32889 arg1 = reinterpret_cast< wxWindow * >(argp1);
32890 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32891 if (!SWIG_IsOK(res2)) {
32892 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
32893 }
32894 arg2 = reinterpret_cast< wxWindow * >(argp2);
32895 {
32896 PyThreadState* __tstate = wxPyBeginAllowThreads();
32897 (arg1)->MoveBeforeInTabOrder(arg2);
32898 wxPyEndAllowThreads(__tstate);
32899 if (PyErr_Occurred()) SWIG_fail;
32900 }
32901 resultobj = SWIG_Py_Void();
32902 return resultobj;
32903 fail:
32904 return NULL;
32905 }
32906
32907
32908 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32909 PyObject *resultobj = 0;
32910 wxWindow *arg1 = (wxWindow *) 0 ;
32911 PyObject *result = 0 ;
32912 void *argp1 = 0 ;
32913 int res1 = 0 ;
32914 PyObject *swig_obj[1] ;
32915
32916 if (!args) SWIG_fail;
32917 swig_obj[0] = args;
32918 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32919 if (!SWIG_IsOK(res1)) {
32920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
32921 }
32922 arg1 = reinterpret_cast< wxWindow * >(argp1);
32923 {
32924 PyThreadState* __tstate = wxPyBeginAllowThreads();
32925 result = (PyObject *)wxWindow_GetChildren(arg1);
32926 wxPyEndAllowThreads(__tstate);
32927 if (PyErr_Occurred()) SWIG_fail;
32928 }
32929 resultobj = result;
32930 return resultobj;
32931 fail:
32932 return NULL;
32933 }
32934
32935
32936 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32937 PyObject *resultobj = 0;
32938 wxWindow *arg1 = (wxWindow *) 0 ;
32939 wxWindow *result = 0 ;
32940 void *argp1 = 0 ;
32941 int res1 = 0 ;
32942 PyObject *swig_obj[1] ;
32943
32944 if (!args) SWIG_fail;
32945 swig_obj[0] = args;
32946 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32947 if (!SWIG_IsOK(res1)) {
32948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
32949 }
32950 arg1 = reinterpret_cast< wxWindow * >(argp1);
32951 {
32952 PyThreadState* __tstate = wxPyBeginAllowThreads();
32953 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
32954 wxPyEndAllowThreads(__tstate);
32955 if (PyErr_Occurred()) SWIG_fail;
32956 }
32957 {
32958 resultobj = wxPyMake_wxObject(result, 0);
32959 }
32960 return resultobj;
32961 fail:
32962 return NULL;
32963 }
32964
32965
32966 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32967 PyObject *resultobj = 0;
32968 wxWindow *arg1 = (wxWindow *) 0 ;
32969 wxWindow *result = 0 ;
32970 void *argp1 = 0 ;
32971 int res1 = 0 ;
32972 PyObject *swig_obj[1] ;
32973
32974 if (!args) SWIG_fail;
32975 swig_obj[0] = args;
32976 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32977 if (!SWIG_IsOK(res1)) {
32978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
32979 }
32980 arg1 = reinterpret_cast< wxWindow * >(argp1);
32981 {
32982 PyThreadState* __tstate = wxPyBeginAllowThreads();
32983 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
32984 wxPyEndAllowThreads(__tstate);
32985 if (PyErr_Occurred()) SWIG_fail;
32986 }
32987 {
32988 resultobj = wxPyMake_wxObject(result, 0);
32989 }
32990 return resultobj;
32991 fail:
32992 return NULL;
32993 }
32994
32995
32996 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32997 PyObject *resultobj = 0;
32998 wxWindow *arg1 = (wxWindow *) 0 ;
32999 bool result;
33000 void *argp1 = 0 ;
33001 int res1 = 0 ;
33002 PyObject *swig_obj[1] ;
33003
33004 if (!args) SWIG_fail;
33005 swig_obj[0] = args;
33006 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33007 if (!SWIG_IsOK(res1)) {
33008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
33009 }
33010 arg1 = reinterpret_cast< wxWindow * >(argp1);
33011 {
33012 PyThreadState* __tstate = wxPyBeginAllowThreads();
33013 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
33014 wxPyEndAllowThreads(__tstate);
33015 if (PyErr_Occurred()) SWIG_fail;
33016 }
33017 {
33018 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33019 }
33020 return resultobj;
33021 fail:
33022 return NULL;
33023 }
33024
33025
33026 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33027 PyObject *resultobj = 0;
33028 wxWindow *arg1 = (wxWindow *) 0 ;
33029 wxWindow *arg2 = (wxWindow *) 0 ;
33030 bool result;
33031 void *argp1 = 0 ;
33032 int res1 = 0 ;
33033 void *argp2 = 0 ;
33034 int res2 = 0 ;
33035 PyObject * obj0 = 0 ;
33036 PyObject * obj1 = 0 ;
33037 char * kwnames[] = {
33038 (char *) "self",(char *) "newParent", NULL
33039 };
33040
33041 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
33042 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33043 if (!SWIG_IsOK(res1)) {
33044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
33045 }
33046 arg1 = reinterpret_cast< wxWindow * >(argp1);
33047 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33048 if (!SWIG_IsOK(res2)) {
33049 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
33050 }
33051 arg2 = reinterpret_cast< wxWindow * >(argp2);
33052 {
33053 PyThreadState* __tstate = wxPyBeginAllowThreads();
33054 result = (bool)(arg1)->Reparent(arg2);
33055 wxPyEndAllowThreads(__tstate);
33056 if (PyErr_Occurred()) SWIG_fail;
33057 }
33058 {
33059 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33060 }
33061 return resultobj;
33062 fail:
33063 return NULL;
33064 }
33065
33066
33067 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33068 PyObject *resultobj = 0;
33069 wxWindow *arg1 = (wxWindow *) 0 ;
33070 wxWindow *arg2 = (wxWindow *) 0 ;
33071 void *argp1 = 0 ;
33072 int res1 = 0 ;
33073 void *argp2 = 0 ;
33074 int res2 = 0 ;
33075 PyObject * obj0 = 0 ;
33076 PyObject * obj1 = 0 ;
33077 char * kwnames[] = {
33078 (char *) "self",(char *) "child", NULL
33079 };
33080
33081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
33082 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33083 if (!SWIG_IsOK(res1)) {
33084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33085 }
33086 arg1 = reinterpret_cast< wxWindow * >(argp1);
33087 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33088 if (!SWIG_IsOK(res2)) {
33089 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33090 }
33091 arg2 = reinterpret_cast< wxWindow * >(argp2);
33092 {
33093 PyThreadState* __tstate = wxPyBeginAllowThreads();
33094 (arg1)->AddChild(arg2);
33095 wxPyEndAllowThreads(__tstate);
33096 if (PyErr_Occurred()) SWIG_fail;
33097 }
33098 resultobj = SWIG_Py_Void();
33099 return resultobj;
33100 fail:
33101 return NULL;
33102 }
33103
33104
33105 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33106 PyObject *resultobj = 0;
33107 wxWindow *arg1 = (wxWindow *) 0 ;
33108 wxWindow *arg2 = (wxWindow *) 0 ;
33109 void *argp1 = 0 ;
33110 int res1 = 0 ;
33111 void *argp2 = 0 ;
33112 int res2 = 0 ;
33113 PyObject * obj0 = 0 ;
33114 PyObject * obj1 = 0 ;
33115 char * kwnames[] = {
33116 (char *) "self",(char *) "child", NULL
33117 };
33118
33119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
33120 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33121 if (!SWIG_IsOK(res1)) {
33122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33123 }
33124 arg1 = reinterpret_cast< wxWindow * >(argp1);
33125 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33126 if (!SWIG_IsOK(res2)) {
33127 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33128 }
33129 arg2 = reinterpret_cast< wxWindow * >(argp2);
33130 {
33131 PyThreadState* __tstate = wxPyBeginAllowThreads();
33132 (arg1)->RemoveChild(arg2);
33133 wxPyEndAllowThreads(__tstate);
33134 if (PyErr_Occurred()) SWIG_fail;
33135 }
33136 resultobj = SWIG_Py_Void();
33137 return resultobj;
33138 fail:
33139 return NULL;
33140 }
33141
33142
33143 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33144 PyObject *resultobj = 0;
33145 wxWindow *arg1 = (wxWindow *) 0 ;
33146 long arg2 ;
33147 wxWindow *result = 0 ;
33148 void *argp1 = 0 ;
33149 int res1 = 0 ;
33150 long val2 ;
33151 int ecode2 = 0 ;
33152 PyObject * obj0 = 0 ;
33153 PyObject * obj1 = 0 ;
33154 char * kwnames[] = {
33155 (char *) "self",(char *) "winid", NULL
33156 };
33157
33158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
33159 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33160 if (!SWIG_IsOK(res1)) {
33161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
33162 }
33163 arg1 = reinterpret_cast< wxWindow * >(argp1);
33164 ecode2 = SWIG_AsVal_long(obj1, &val2);
33165 if (!SWIG_IsOK(ecode2)) {
33166 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
33167 }
33168 arg2 = static_cast< long >(val2);
33169 {
33170 PyThreadState* __tstate = wxPyBeginAllowThreads();
33171 result = (wxWindow *)(arg1)->FindWindow(arg2);
33172 wxPyEndAllowThreads(__tstate);
33173 if (PyErr_Occurred()) SWIG_fail;
33174 }
33175 {
33176 resultobj = wxPyMake_wxObject(result, 0);
33177 }
33178 return resultobj;
33179 fail:
33180 return NULL;
33181 }
33182
33183
33184 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33185 PyObject *resultobj = 0;
33186 wxWindow *arg1 = (wxWindow *) 0 ;
33187 wxString *arg2 = 0 ;
33188 wxWindow *result = 0 ;
33189 void *argp1 = 0 ;
33190 int res1 = 0 ;
33191 bool temp2 = false ;
33192 PyObject * obj0 = 0 ;
33193 PyObject * obj1 = 0 ;
33194 char * kwnames[] = {
33195 (char *) "self",(char *) "name", NULL
33196 };
33197
33198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
33199 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33200 if (!SWIG_IsOK(res1)) {
33201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
33202 }
33203 arg1 = reinterpret_cast< wxWindow * >(argp1);
33204 {
33205 arg2 = wxString_in_helper(obj1);
33206 if (arg2 == NULL) SWIG_fail;
33207 temp2 = true;
33208 }
33209 {
33210 PyThreadState* __tstate = wxPyBeginAllowThreads();
33211 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
33212 wxPyEndAllowThreads(__tstate);
33213 if (PyErr_Occurred()) SWIG_fail;
33214 }
33215 {
33216 resultobj = wxPyMake_wxObject(result, 0);
33217 }
33218 {
33219 if (temp2)
33220 delete arg2;
33221 }
33222 return resultobj;
33223 fail:
33224 {
33225 if (temp2)
33226 delete arg2;
33227 }
33228 return NULL;
33229 }
33230
33231
33232 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33233 PyObject *resultobj = 0;
33234 wxWindow *arg1 = (wxWindow *) 0 ;
33235 wxEvtHandler *result = 0 ;
33236 void *argp1 = 0 ;
33237 int res1 = 0 ;
33238 PyObject *swig_obj[1] ;
33239
33240 if (!args) SWIG_fail;
33241 swig_obj[0] = args;
33242 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33243 if (!SWIG_IsOK(res1)) {
33244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
33245 }
33246 arg1 = reinterpret_cast< wxWindow * >(argp1);
33247 {
33248 PyThreadState* __tstate = wxPyBeginAllowThreads();
33249 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
33250 wxPyEndAllowThreads(__tstate);
33251 if (PyErr_Occurred()) SWIG_fail;
33252 }
33253 {
33254 resultobj = wxPyMake_wxObject(result, 0);
33255 }
33256 return resultobj;
33257 fail:
33258 return NULL;
33259 }
33260
33261
33262 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33263 PyObject *resultobj = 0;
33264 wxWindow *arg1 = (wxWindow *) 0 ;
33265 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33266 void *argp1 = 0 ;
33267 int res1 = 0 ;
33268 void *argp2 = 0 ;
33269 int res2 = 0 ;
33270 PyObject * obj0 = 0 ;
33271 PyObject * obj1 = 0 ;
33272 char * kwnames[] = {
33273 (char *) "self",(char *) "handler", NULL
33274 };
33275
33276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33277 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33278 if (!SWIG_IsOK(res1)) {
33279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33280 }
33281 arg1 = reinterpret_cast< wxWindow * >(argp1);
33282 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33283 if (!SWIG_IsOK(res2)) {
33284 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33285 }
33286 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33287 {
33288 PyThreadState* __tstate = wxPyBeginAllowThreads();
33289 (arg1)->SetEventHandler(arg2);
33290 wxPyEndAllowThreads(__tstate);
33291 if (PyErr_Occurred()) SWIG_fail;
33292 }
33293 resultobj = SWIG_Py_Void();
33294 return resultobj;
33295 fail:
33296 return NULL;
33297 }
33298
33299
33300 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33301 PyObject *resultobj = 0;
33302 wxWindow *arg1 = (wxWindow *) 0 ;
33303 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33304 void *argp1 = 0 ;
33305 int res1 = 0 ;
33306 void *argp2 = 0 ;
33307 int res2 = 0 ;
33308 PyObject * obj0 = 0 ;
33309 PyObject * obj1 = 0 ;
33310 char * kwnames[] = {
33311 (char *) "self",(char *) "handler", NULL
33312 };
33313
33314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33315 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33316 if (!SWIG_IsOK(res1)) {
33317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33318 }
33319 arg1 = reinterpret_cast< wxWindow * >(argp1);
33320 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33321 if (!SWIG_IsOK(res2)) {
33322 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33323 }
33324 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33325 {
33326 PyThreadState* __tstate = wxPyBeginAllowThreads();
33327 (arg1)->PushEventHandler(arg2);
33328 wxPyEndAllowThreads(__tstate);
33329 if (PyErr_Occurred()) SWIG_fail;
33330 }
33331 resultobj = SWIG_Py_Void();
33332 return resultobj;
33333 fail:
33334 return NULL;
33335 }
33336
33337
33338 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33339 PyObject *resultobj = 0;
33340 wxWindow *arg1 = (wxWindow *) 0 ;
33341 bool arg2 = (bool) false ;
33342 wxEvtHandler *result = 0 ;
33343 void *argp1 = 0 ;
33344 int res1 = 0 ;
33345 bool val2 ;
33346 int ecode2 = 0 ;
33347 PyObject * obj0 = 0 ;
33348 PyObject * obj1 = 0 ;
33349 char * kwnames[] = {
33350 (char *) "self",(char *) "deleteHandler", NULL
33351 };
33352
33353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33354 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33355 if (!SWIG_IsOK(res1)) {
33356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33357 }
33358 arg1 = reinterpret_cast< wxWindow * >(argp1);
33359 if (obj1) {
33360 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33361 if (!SWIG_IsOK(ecode2)) {
33362 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
33363 }
33364 arg2 = static_cast< bool >(val2);
33365 }
33366 {
33367 PyThreadState* __tstate = wxPyBeginAllowThreads();
33368 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
33369 wxPyEndAllowThreads(__tstate);
33370 if (PyErr_Occurred()) SWIG_fail;
33371 }
33372 {
33373 resultobj = wxPyMake_wxObject(result, 0);
33374 }
33375 return resultobj;
33376 fail:
33377 return NULL;
33378 }
33379
33380
33381 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33382 PyObject *resultobj = 0;
33383 wxWindow *arg1 = (wxWindow *) 0 ;
33384 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33385 bool result;
33386 void *argp1 = 0 ;
33387 int res1 = 0 ;
33388 void *argp2 = 0 ;
33389 int res2 = 0 ;
33390 PyObject * obj0 = 0 ;
33391 PyObject * obj1 = 0 ;
33392 char * kwnames[] = {
33393 (char *) "self",(char *) "handler", NULL
33394 };
33395
33396 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33397 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33398 if (!SWIG_IsOK(res1)) {
33399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33400 }
33401 arg1 = reinterpret_cast< wxWindow * >(argp1);
33402 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33403 if (!SWIG_IsOK(res2)) {
33404 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33405 }
33406 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33407 {
33408 PyThreadState* __tstate = wxPyBeginAllowThreads();
33409 result = (bool)(arg1)->RemoveEventHandler(arg2);
33410 wxPyEndAllowThreads(__tstate);
33411 if (PyErr_Occurred()) SWIG_fail;
33412 }
33413 {
33414 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33415 }
33416 return resultobj;
33417 fail:
33418 return NULL;
33419 }
33420
33421
33422 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33423 PyObject *resultobj = 0;
33424 wxWindow *arg1 = (wxWindow *) 0 ;
33425 wxValidator *arg2 = 0 ;
33426 void *argp1 = 0 ;
33427 int res1 = 0 ;
33428 void *argp2 = 0 ;
33429 int res2 = 0 ;
33430 PyObject * obj0 = 0 ;
33431 PyObject * obj1 = 0 ;
33432 char * kwnames[] = {
33433 (char *) "self",(char *) "validator", NULL
33434 };
33435
33436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
33437 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33438 if (!SWIG_IsOK(res1)) {
33439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33440 }
33441 arg1 = reinterpret_cast< wxWindow * >(argp1);
33442 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
33443 if (!SWIG_IsOK(res2)) {
33444 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33445 }
33446 if (!argp2) {
33447 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33448 }
33449 arg2 = reinterpret_cast< wxValidator * >(argp2);
33450 {
33451 PyThreadState* __tstate = wxPyBeginAllowThreads();
33452 (arg1)->SetValidator((wxValidator const &)*arg2);
33453 wxPyEndAllowThreads(__tstate);
33454 if (PyErr_Occurred()) SWIG_fail;
33455 }
33456 resultobj = SWIG_Py_Void();
33457 return resultobj;
33458 fail:
33459 return NULL;
33460 }
33461
33462
33463 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33464 PyObject *resultobj = 0;
33465 wxWindow *arg1 = (wxWindow *) 0 ;
33466 wxValidator *result = 0 ;
33467 void *argp1 = 0 ;
33468 int res1 = 0 ;
33469 PyObject *swig_obj[1] ;
33470
33471 if (!args) SWIG_fail;
33472 swig_obj[0] = args;
33473 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33474 if (!SWIG_IsOK(res1)) {
33475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33476 }
33477 arg1 = reinterpret_cast< wxWindow * >(argp1);
33478 {
33479 PyThreadState* __tstate = wxPyBeginAllowThreads();
33480 result = (wxValidator *)(arg1)->GetValidator();
33481 wxPyEndAllowThreads(__tstate);
33482 if (PyErr_Occurred()) SWIG_fail;
33483 }
33484 {
33485 resultobj = wxPyMake_wxObject(result, (bool)0);
33486 }
33487 return resultobj;
33488 fail:
33489 return NULL;
33490 }
33491
33492
33493 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33494 PyObject *resultobj = 0;
33495 wxWindow *arg1 = (wxWindow *) 0 ;
33496 bool result;
33497 void *argp1 = 0 ;
33498 int res1 = 0 ;
33499 PyObject *swig_obj[1] ;
33500
33501 if (!args) SWIG_fail;
33502 swig_obj[0] = args;
33503 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33504 if (!SWIG_IsOK(res1)) {
33505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
33506 }
33507 arg1 = reinterpret_cast< wxWindow * >(argp1);
33508 {
33509 PyThreadState* __tstate = wxPyBeginAllowThreads();
33510 result = (bool)(arg1)->Validate();
33511 wxPyEndAllowThreads(__tstate);
33512 if (PyErr_Occurred()) SWIG_fail;
33513 }
33514 {
33515 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33516 }
33517 return resultobj;
33518 fail:
33519 return NULL;
33520 }
33521
33522
33523 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33524 PyObject *resultobj = 0;
33525 wxWindow *arg1 = (wxWindow *) 0 ;
33526 bool result;
33527 void *argp1 = 0 ;
33528 int res1 = 0 ;
33529 PyObject *swig_obj[1] ;
33530
33531 if (!args) SWIG_fail;
33532 swig_obj[0] = args;
33533 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33534 if (!SWIG_IsOK(res1)) {
33535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33536 }
33537 arg1 = reinterpret_cast< wxWindow * >(argp1);
33538 {
33539 PyThreadState* __tstate = wxPyBeginAllowThreads();
33540 result = (bool)(arg1)->TransferDataToWindow();
33541 wxPyEndAllowThreads(__tstate);
33542 if (PyErr_Occurred()) SWIG_fail;
33543 }
33544 {
33545 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33546 }
33547 return resultobj;
33548 fail:
33549 return NULL;
33550 }
33551
33552
33553 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33554 PyObject *resultobj = 0;
33555 wxWindow *arg1 = (wxWindow *) 0 ;
33556 bool result;
33557 void *argp1 = 0 ;
33558 int res1 = 0 ;
33559 PyObject *swig_obj[1] ;
33560
33561 if (!args) SWIG_fail;
33562 swig_obj[0] = args;
33563 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33564 if (!SWIG_IsOK(res1)) {
33565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33566 }
33567 arg1 = reinterpret_cast< wxWindow * >(argp1);
33568 {
33569 PyThreadState* __tstate = wxPyBeginAllowThreads();
33570 result = (bool)(arg1)->TransferDataFromWindow();
33571 wxPyEndAllowThreads(__tstate);
33572 if (PyErr_Occurred()) SWIG_fail;
33573 }
33574 {
33575 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33576 }
33577 return resultobj;
33578 fail:
33579 return NULL;
33580 }
33581
33582
33583 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33584 PyObject *resultobj = 0;
33585 wxWindow *arg1 = (wxWindow *) 0 ;
33586 void *argp1 = 0 ;
33587 int res1 = 0 ;
33588 PyObject *swig_obj[1] ;
33589
33590 if (!args) SWIG_fail;
33591 swig_obj[0] = args;
33592 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33593 if (!SWIG_IsOK(res1)) {
33594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
33595 }
33596 arg1 = reinterpret_cast< wxWindow * >(argp1);
33597 {
33598 PyThreadState* __tstate = wxPyBeginAllowThreads();
33599 (arg1)->InitDialog();
33600 wxPyEndAllowThreads(__tstate);
33601 if (PyErr_Occurred()) SWIG_fail;
33602 }
33603 resultobj = SWIG_Py_Void();
33604 return resultobj;
33605 fail:
33606 return NULL;
33607 }
33608
33609
33610 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33611 PyObject *resultobj = 0;
33612 wxWindow *arg1 = (wxWindow *) 0 ;
33613 wxAcceleratorTable *arg2 = 0 ;
33614 void *argp1 = 0 ;
33615 int res1 = 0 ;
33616 void *argp2 = 0 ;
33617 int res2 = 0 ;
33618 PyObject * obj0 = 0 ;
33619 PyObject * obj1 = 0 ;
33620 char * kwnames[] = {
33621 (char *) "self",(char *) "accel", NULL
33622 };
33623
33624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
33625 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33626 if (!SWIG_IsOK(res1)) {
33627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33628 }
33629 arg1 = reinterpret_cast< wxWindow * >(argp1);
33630 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
33631 if (!SWIG_IsOK(res2)) {
33632 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33633 }
33634 if (!argp2) {
33635 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33636 }
33637 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
33638 {
33639 PyThreadState* __tstate = wxPyBeginAllowThreads();
33640 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
33641 wxPyEndAllowThreads(__tstate);
33642 if (PyErr_Occurred()) SWIG_fail;
33643 }
33644 resultobj = SWIG_Py_Void();
33645 return resultobj;
33646 fail:
33647 return NULL;
33648 }
33649
33650
33651 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33652 PyObject *resultobj = 0;
33653 wxWindow *arg1 = (wxWindow *) 0 ;
33654 wxAcceleratorTable *result = 0 ;
33655 void *argp1 = 0 ;
33656 int res1 = 0 ;
33657 PyObject *swig_obj[1] ;
33658
33659 if (!args) SWIG_fail;
33660 swig_obj[0] = args;
33661 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33662 if (!SWIG_IsOK(res1)) {
33663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33664 }
33665 arg1 = reinterpret_cast< wxWindow * >(argp1);
33666 {
33667 PyThreadState* __tstate = wxPyBeginAllowThreads();
33668 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
33669 wxPyEndAllowThreads(__tstate);
33670 if (PyErr_Occurred()) SWIG_fail;
33671 }
33672 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
33673 return resultobj;
33674 fail:
33675 return NULL;
33676 }
33677
33678
33679 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33680 PyObject *resultobj = 0;
33681 wxWindow *arg1 = (wxWindow *) 0 ;
33682 int arg2 ;
33683 int arg3 ;
33684 int arg4 ;
33685 bool result;
33686 void *argp1 = 0 ;
33687 int res1 = 0 ;
33688 int val2 ;
33689 int ecode2 = 0 ;
33690 int val3 ;
33691 int ecode3 = 0 ;
33692 int val4 ;
33693 int ecode4 = 0 ;
33694 PyObject * obj0 = 0 ;
33695 PyObject * obj1 = 0 ;
33696 PyObject * obj2 = 0 ;
33697 PyObject * obj3 = 0 ;
33698 char * kwnames[] = {
33699 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
33700 };
33701
33702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33703 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33704 if (!SWIG_IsOK(res1)) {
33705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
33706 }
33707 arg1 = reinterpret_cast< wxWindow * >(argp1);
33708 ecode2 = SWIG_AsVal_int(obj1, &val2);
33709 if (!SWIG_IsOK(ecode2)) {
33710 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
33711 }
33712 arg2 = static_cast< int >(val2);
33713 ecode3 = SWIG_AsVal_int(obj2, &val3);
33714 if (!SWIG_IsOK(ecode3)) {
33715 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
33716 }
33717 arg3 = static_cast< int >(val3);
33718 ecode4 = SWIG_AsVal_int(obj3, &val4);
33719 if (!SWIG_IsOK(ecode4)) {
33720 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
33721 }
33722 arg4 = static_cast< int >(val4);
33723 {
33724 PyThreadState* __tstate = wxPyBeginAllowThreads();
33725 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
33726 wxPyEndAllowThreads(__tstate);
33727 if (PyErr_Occurred()) SWIG_fail;
33728 }
33729 {
33730 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33731 }
33732 return resultobj;
33733 fail:
33734 return NULL;
33735 }
33736
33737
33738 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33739 PyObject *resultobj = 0;
33740 wxWindow *arg1 = (wxWindow *) 0 ;
33741 int arg2 ;
33742 bool result;
33743 void *argp1 = 0 ;
33744 int res1 = 0 ;
33745 int val2 ;
33746 int ecode2 = 0 ;
33747 PyObject * obj0 = 0 ;
33748 PyObject * obj1 = 0 ;
33749 char * kwnames[] = {
33750 (char *) "self",(char *) "hotkeyId", NULL
33751 };
33752
33753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
33754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33755 if (!SWIG_IsOK(res1)) {
33756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
33757 }
33758 arg1 = reinterpret_cast< wxWindow * >(argp1);
33759 ecode2 = SWIG_AsVal_int(obj1, &val2);
33760 if (!SWIG_IsOK(ecode2)) {
33761 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
33762 }
33763 arg2 = static_cast< int >(val2);
33764 {
33765 PyThreadState* __tstate = wxPyBeginAllowThreads();
33766 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
33767 wxPyEndAllowThreads(__tstate);
33768 if (PyErr_Occurred()) SWIG_fail;
33769 }
33770 {
33771 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33772 }
33773 return resultobj;
33774 fail:
33775 return NULL;
33776 }
33777
33778
33779 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33780 PyObject *resultobj = 0;
33781 wxWindow *arg1 = (wxWindow *) 0 ;
33782 wxPoint *arg2 = 0 ;
33783 wxPoint result;
33784 void *argp1 = 0 ;
33785 int res1 = 0 ;
33786 wxPoint temp2 ;
33787 PyObject * obj0 = 0 ;
33788 PyObject * obj1 = 0 ;
33789 char * kwnames[] = {
33790 (char *) "self",(char *) "pt", NULL
33791 };
33792
33793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
33794 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33795 if (!SWIG_IsOK(res1)) {
33796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
33797 }
33798 arg1 = reinterpret_cast< wxWindow * >(argp1);
33799 {
33800 arg2 = &temp2;
33801 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33802 }
33803 {
33804 PyThreadState* __tstate = wxPyBeginAllowThreads();
33805 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
33806 wxPyEndAllowThreads(__tstate);
33807 if (PyErr_Occurred()) SWIG_fail;
33808 }
33809 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
33810 return resultobj;
33811 fail:
33812 return NULL;
33813 }
33814
33815
33816 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33817 PyObject *resultobj = 0;
33818 wxWindow *arg1 = (wxWindow *) 0 ;
33819 wxSize *arg2 = 0 ;
33820 wxSize result;
33821 void *argp1 = 0 ;
33822 int res1 = 0 ;
33823 wxSize temp2 ;
33824 PyObject * obj0 = 0 ;
33825 PyObject * obj1 = 0 ;
33826 char * kwnames[] = {
33827 (char *) "self",(char *) "sz", NULL
33828 };
33829
33830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
33831 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33832 if (!SWIG_IsOK(res1)) {
33833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
33834 }
33835 arg1 = reinterpret_cast< wxWindow * >(argp1);
33836 {
33837 arg2 = &temp2;
33838 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33839 }
33840 {
33841 PyThreadState* __tstate = wxPyBeginAllowThreads();
33842 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
33843 wxPyEndAllowThreads(__tstate);
33844 if (PyErr_Occurred()) SWIG_fail;
33845 }
33846 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33847 return resultobj;
33848 fail:
33849 return NULL;
33850 }
33851
33852
33853 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33854 PyObject *resultobj = 0;
33855 wxWindow *arg1 = (wxWindow *) 0 ;
33856 wxPoint *arg2 = 0 ;
33857 wxPoint result;
33858 void *argp1 = 0 ;
33859 int res1 = 0 ;
33860 wxPoint temp2 ;
33861 PyObject * obj0 = 0 ;
33862 PyObject * obj1 = 0 ;
33863 char * kwnames[] = {
33864 (char *) "self",(char *) "pt", NULL
33865 };
33866
33867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
33868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33869 if (!SWIG_IsOK(res1)) {
33870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
33871 }
33872 arg1 = reinterpret_cast< wxWindow * >(argp1);
33873 {
33874 arg2 = &temp2;
33875 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33876 }
33877 {
33878 PyThreadState* __tstate = wxPyBeginAllowThreads();
33879 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
33880 wxPyEndAllowThreads(__tstate);
33881 if (PyErr_Occurred()) SWIG_fail;
33882 }
33883 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
33884 return resultobj;
33885 fail:
33886 return NULL;
33887 }
33888
33889
33890 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33891 PyObject *resultobj = 0;
33892 wxWindow *arg1 = (wxWindow *) 0 ;
33893 wxSize *arg2 = 0 ;
33894 wxSize result;
33895 void *argp1 = 0 ;
33896 int res1 = 0 ;
33897 wxSize temp2 ;
33898 PyObject * obj0 = 0 ;
33899 PyObject * obj1 = 0 ;
33900 char * kwnames[] = {
33901 (char *) "self",(char *) "sz", NULL
33902 };
33903
33904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
33905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33906 if (!SWIG_IsOK(res1)) {
33907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
33908 }
33909 arg1 = reinterpret_cast< wxWindow * >(argp1);
33910 {
33911 arg2 = &temp2;
33912 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33913 }
33914 {
33915 PyThreadState* __tstate = wxPyBeginAllowThreads();
33916 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
33917 wxPyEndAllowThreads(__tstate);
33918 if (PyErr_Occurred()) SWIG_fail;
33919 }
33920 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33921 return resultobj;
33922 fail:
33923 return NULL;
33924 }
33925
33926
33927 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33928 PyObject *resultobj = 0;
33929 wxWindow *arg1 = (wxWindow *) 0 ;
33930 wxPoint *arg2 = 0 ;
33931 wxPoint result;
33932 void *argp1 = 0 ;
33933 int res1 = 0 ;
33934 wxPoint temp2 ;
33935 PyObject * obj0 = 0 ;
33936 PyObject * obj1 = 0 ;
33937 char * kwnames[] = {
33938 (char *) "self",(char *) "pt", NULL
33939 };
33940
33941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
33942 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33943 if (!SWIG_IsOK(res1)) {
33944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
33945 }
33946 arg1 = reinterpret_cast< wxWindow * >(argp1);
33947 {
33948 arg2 = &temp2;
33949 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33950 }
33951 {
33952 PyThreadState* __tstate = wxPyBeginAllowThreads();
33953 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
33954 wxPyEndAllowThreads(__tstate);
33955 if (PyErr_Occurred()) SWIG_fail;
33956 }
33957 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
33958 return resultobj;
33959 fail:
33960 return NULL;
33961 }
33962
33963
33964 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33965 PyObject *resultobj = 0;
33966 wxWindow *arg1 = (wxWindow *) 0 ;
33967 wxSize *arg2 = 0 ;
33968 wxSize result;
33969 void *argp1 = 0 ;
33970 int res1 = 0 ;
33971 wxSize temp2 ;
33972 PyObject * obj0 = 0 ;
33973 PyObject * obj1 = 0 ;
33974 char * kwnames[] = {
33975 (char *) "self",(char *) "sz", NULL
33976 };
33977
33978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
33979 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33980 if (!SWIG_IsOK(res1)) {
33981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
33982 }
33983 arg1 = reinterpret_cast< wxWindow * >(argp1);
33984 {
33985 arg2 = &temp2;
33986 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33987 }
33988 {
33989 PyThreadState* __tstate = wxPyBeginAllowThreads();
33990 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
33991 wxPyEndAllowThreads(__tstate);
33992 if (PyErr_Occurred()) SWIG_fail;
33993 }
33994 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33995 return resultobj;
33996 fail:
33997 return NULL;
33998 }
33999
34000
34001 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34002 PyObject *resultobj = 0;
34003 wxWindow *arg1 = (wxWindow *) 0 ;
34004 int arg2 ;
34005 int arg3 ;
34006 void *argp1 = 0 ;
34007 int res1 = 0 ;
34008 int val2 ;
34009 int ecode2 = 0 ;
34010 int val3 ;
34011 int ecode3 = 0 ;
34012 PyObject * obj0 = 0 ;
34013 PyObject * obj1 = 0 ;
34014 PyObject * obj2 = 0 ;
34015 char * kwnames[] = {
34016 (char *) "self",(char *) "x",(char *) "y", NULL
34017 };
34018
34019 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34020 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34021 if (!SWIG_IsOK(res1)) {
34022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
34023 }
34024 arg1 = reinterpret_cast< wxWindow * >(argp1);
34025 ecode2 = SWIG_AsVal_int(obj1, &val2);
34026 if (!SWIG_IsOK(ecode2)) {
34027 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
34028 }
34029 arg2 = static_cast< int >(val2);
34030 ecode3 = SWIG_AsVal_int(obj2, &val3);
34031 if (!SWIG_IsOK(ecode3)) {
34032 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
34033 }
34034 arg3 = static_cast< int >(val3);
34035 {
34036 PyThreadState* __tstate = wxPyBeginAllowThreads();
34037 (arg1)->WarpPointer(arg2,arg3);
34038 wxPyEndAllowThreads(__tstate);
34039 if (PyErr_Occurred()) SWIG_fail;
34040 }
34041 resultobj = SWIG_Py_Void();
34042 return resultobj;
34043 fail:
34044 return NULL;
34045 }
34046
34047
34048 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34049 PyObject *resultobj = 0;
34050 wxWindow *arg1 = (wxWindow *) 0 ;
34051 void *argp1 = 0 ;
34052 int res1 = 0 ;
34053 PyObject *swig_obj[1] ;
34054
34055 if (!args) SWIG_fail;
34056 swig_obj[0] = args;
34057 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34058 if (!SWIG_IsOK(res1)) {
34059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34060 }
34061 arg1 = reinterpret_cast< wxWindow * >(argp1);
34062 {
34063 PyThreadState* __tstate = wxPyBeginAllowThreads();
34064 (arg1)->CaptureMouse();
34065 wxPyEndAllowThreads(__tstate);
34066 if (PyErr_Occurred()) SWIG_fail;
34067 }
34068 resultobj = SWIG_Py_Void();
34069 return resultobj;
34070 fail:
34071 return NULL;
34072 }
34073
34074
34075 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34076 PyObject *resultobj = 0;
34077 wxWindow *arg1 = (wxWindow *) 0 ;
34078 void *argp1 = 0 ;
34079 int res1 = 0 ;
34080 PyObject *swig_obj[1] ;
34081
34082 if (!args) SWIG_fail;
34083 swig_obj[0] = args;
34084 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34085 if (!SWIG_IsOK(res1)) {
34086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34087 }
34088 arg1 = reinterpret_cast< wxWindow * >(argp1);
34089 {
34090 PyThreadState* __tstate = wxPyBeginAllowThreads();
34091 (arg1)->ReleaseMouse();
34092 wxPyEndAllowThreads(__tstate);
34093 if (PyErr_Occurred()) SWIG_fail;
34094 }
34095 resultobj = SWIG_Py_Void();
34096 return resultobj;
34097 fail:
34098 return NULL;
34099 }
34100
34101
34102 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34103 PyObject *resultobj = 0;
34104 wxWindow *result = 0 ;
34105
34106 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
34107 {
34108 if (!wxPyCheckForApp()) SWIG_fail;
34109 PyThreadState* __tstate = wxPyBeginAllowThreads();
34110 result = (wxWindow *)wxWindow::GetCapture();
34111 wxPyEndAllowThreads(__tstate);
34112 if (PyErr_Occurred()) SWIG_fail;
34113 }
34114 {
34115 resultobj = wxPyMake_wxObject(result, 0);
34116 }
34117 return resultobj;
34118 fail:
34119 return NULL;
34120 }
34121
34122
34123 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34124 PyObject *resultobj = 0;
34125 wxWindow *arg1 = (wxWindow *) 0 ;
34126 bool result;
34127 void *argp1 = 0 ;
34128 int res1 = 0 ;
34129 PyObject *swig_obj[1] ;
34130
34131 if (!args) SWIG_fail;
34132 swig_obj[0] = args;
34133 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34134 if (!SWIG_IsOK(res1)) {
34135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
34136 }
34137 arg1 = reinterpret_cast< wxWindow * >(argp1);
34138 {
34139 PyThreadState* __tstate = wxPyBeginAllowThreads();
34140 result = (bool)((wxWindow const *)arg1)->HasCapture();
34141 wxPyEndAllowThreads(__tstate);
34142 if (PyErr_Occurred()) SWIG_fail;
34143 }
34144 {
34145 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34146 }
34147 return resultobj;
34148 fail:
34149 return NULL;
34150 }
34151
34152
34153 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34154 PyObject *resultobj = 0;
34155 wxWindow *arg1 = (wxWindow *) 0 ;
34156 bool arg2 = (bool) true ;
34157 wxRect *arg3 = (wxRect *) NULL ;
34158 void *argp1 = 0 ;
34159 int res1 = 0 ;
34160 bool val2 ;
34161 int ecode2 = 0 ;
34162 void *argp3 = 0 ;
34163 int res3 = 0 ;
34164 PyObject * obj0 = 0 ;
34165 PyObject * obj1 = 0 ;
34166 PyObject * obj2 = 0 ;
34167 char * kwnames[] = {
34168 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
34169 };
34170
34171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34172 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34173 if (!SWIG_IsOK(res1)) {
34174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
34175 }
34176 arg1 = reinterpret_cast< wxWindow * >(argp1);
34177 if (obj1) {
34178 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34179 if (!SWIG_IsOK(ecode2)) {
34180 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
34181 }
34182 arg2 = static_cast< bool >(val2);
34183 }
34184 if (obj2) {
34185 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
34186 if (!SWIG_IsOK(res3)) {
34187 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
34188 }
34189 arg3 = reinterpret_cast< wxRect * >(argp3);
34190 }
34191 {
34192 PyThreadState* __tstate = wxPyBeginAllowThreads();
34193 (arg1)->Refresh(arg2,(wxRect const *)arg3);
34194 wxPyEndAllowThreads(__tstate);
34195 if (PyErr_Occurred()) SWIG_fail;
34196 }
34197 resultobj = SWIG_Py_Void();
34198 return resultobj;
34199 fail:
34200 return NULL;
34201 }
34202
34203
34204 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34205 PyObject *resultobj = 0;
34206 wxWindow *arg1 = (wxWindow *) 0 ;
34207 wxRect *arg2 = 0 ;
34208 bool arg3 = (bool) true ;
34209 void *argp1 = 0 ;
34210 int res1 = 0 ;
34211 wxRect temp2 ;
34212 bool val3 ;
34213 int ecode3 = 0 ;
34214 PyObject * obj0 = 0 ;
34215 PyObject * obj1 = 0 ;
34216 PyObject * obj2 = 0 ;
34217 char * kwnames[] = {
34218 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
34219 };
34220
34221 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34222 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34223 if (!SWIG_IsOK(res1)) {
34224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34225 }
34226 arg1 = reinterpret_cast< wxWindow * >(argp1);
34227 {
34228 arg2 = &temp2;
34229 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34230 }
34231 if (obj2) {
34232 ecode3 = SWIG_AsVal_bool(obj2, &val3);
34233 if (!SWIG_IsOK(ecode3)) {
34234 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
34235 }
34236 arg3 = static_cast< bool >(val3);
34237 }
34238 {
34239 PyThreadState* __tstate = wxPyBeginAllowThreads();
34240 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
34241 wxPyEndAllowThreads(__tstate);
34242 if (PyErr_Occurred()) SWIG_fail;
34243 }
34244 resultobj = SWIG_Py_Void();
34245 return resultobj;
34246 fail:
34247 return NULL;
34248 }
34249
34250
34251 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34252 PyObject *resultobj = 0;
34253 wxWindow *arg1 = (wxWindow *) 0 ;
34254 void *argp1 = 0 ;
34255 int res1 = 0 ;
34256 PyObject *swig_obj[1] ;
34257
34258 if (!args) SWIG_fail;
34259 swig_obj[0] = args;
34260 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34261 if (!SWIG_IsOK(res1)) {
34262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
34263 }
34264 arg1 = reinterpret_cast< wxWindow * >(argp1);
34265 {
34266 PyThreadState* __tstate = wxPyBeginAllowThreads();
34267 (arg1)->Update();
34268 wxPyEndAllowThreads(__tstate);
34269 if (PyErr_Occurred()) SWIG_fail;
34270 }
34271 resultobj = SWIG_Py_Void();
34272 return resultobj;
34273 fail:
34274 return NULL;
34275 }
34276
34277
34278 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34279 PyObject *resultobj = 0;
34280 wxWindow *arg1 = (wxWindow *) 0 ;
34281 void *argp1 = 0 ;
34282 int res1 = 0 ;
34283 PyObject *swig_obj[1] ;
34284
34285 if (!args) SWIG_fail;
34286 swig_obj[0] = args;
34287 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34288 if (!SWIG_IsOK(res1)) {
34289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
34290 }
34291 arg1 = reinterpret_cast< wxWindow * >(argp1);
34292 {
34293 PyThreadState* __tstate = wxPyBeginAllowThreads();
34294 (arg1)->ClearBackground();
34295 wxPyEndAllowThreads(__tstate);
34296 if (PyErr_Occurred()) SWIG_fail;
34297 }
34298 resultobj = SWIG_Py_Void();
34299 return resultobj;
34300 fail:
34301 return NULL;
34302 }
34303
34304
34305 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34306 PyObject *resultobj = 0;
34307 wxWindow *arg1 = (wxWindow *) 0 ;
34308 void *argp1 = 0 ;
34309 int res1 = 0 ;
34310 PyObject *swig_obj[1] ;
34311
34312 if (!args) SWIG_fail;
34313 swig_obj[0] = args;
34314 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34315 if (!SWIG_IsOK(res1)) {
34316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
34317 }
34318 arg1 = reinterpret_cast< wxWindow * >(argp1);
34319 {
34320 PyThreadState* __tstate = wxPyBeginAllowThreads();
34321 (arg1)->Freeze();
34322 wxPyEndAllowThreads(__tstate);
34323 if (PyErr_Occurred()) SWIG_fail;
34324 }
34325 resultobj = SWIG_Py_Void();
34326 return resultobj;
34327 fail:
34328 return NULL;
34329 }
34330
34331
34332 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34333 PyObject *resultobj = 0;
34334 wxWindow *arg1 = (wxWindow *) 0 ;
34335 void *argp1 = 0 ;
34336 int res1 = 0 ;
34337 PyObject *swig_obj[1] ;
34338
34339 if (!args) SWIG_fail;
34340 swig_obj[0] = args;
34341 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34342 if (!SWIG_IsOK(res1)) {
34343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
34344 }
34345 arg1 = reinterpret_cast< wxWindow * >(argp1);
34346 {
34347 PyThreadState* __tstate = wxPyBeginAllowThreads();
34348 (arg1)->Thaw();
34349 wxPyEndAllowThreads(__tstate);
34350 if (PyErr_Occurred()) SWIG_fail;
34351 }
34352 resultobj = SWIG_Py_Void();
34353 return resultobj;
34354 fail:
34355 return NULL;
34356 }
34357
34358
34359 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34360 PyObject *resultobj = 0;
34361 wxWindow *arg1 = (wxWindow *) 0 ;
34362 wxDC *arg2 = 0 ;
34363 void *argp1 = 0 ;
34364 int res1 = 0 ;
34365 void *argp2 = 0 ;
34366 int res2 = 0 ;
34367 PyObject * obj0 = 0 ;
34368 PyObject * obj1 = 0 ;
34369 char * kwnames[] = {
34370 (char *) "self",(char *) "dc", NULL
34371 };
34372
34373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
34374 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34375 if (!SWIG_IsOK(res1)) {
34376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
34377 }
34378 arg1 = reinterpret_cast< wxWindow * >(argp1);
34379 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
34380 if (!SWIG_IsOK(res2)) {
34381 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34382 }
34383 if (!argp2) {
34384 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34385 }
34386 arg2 = reinterpret_cast< wxDC * >(argp2);
34387 {
34388 PyThreadState* __tstate = wxPyBeginAllowThreads();
34389 (arg1)->PrepareDC(*arg2);
34390 wxPyEndAllowThreads(__tstate);
34391 if (PyErr_Occurred()) SWIG_fail;
34392 }
34393 resultobj = SWIG_Py_Void();
34394 return resultobj;
34395 fail:
34396 return NULL;
34397 }
34398
34399
34400 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34401 PyObject *resultobj = 0;
34402 wxWindow *arg1 = (wxWindow *) 0 ;
34403 wxRegion *result = 0 ;
34404 void *argp1 = 0 ;
34405 int res1 = 0 ;
34406 PyObject *swig_obj[1] ;
34407
34408 if (!args) SWIG_fail;
34409 swig_obj[0] = args;
34410 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34411 if (!SWIG_IsOK(res1)) {
34412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
34413 }
34414 arg1 = reinterpret_cast< wxWindow * >(argp1);
34415 {
34416 PyThreadState* __tstate = wxPyBeginAllowThreads();
34417 {
34418 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
34419 result = (wxRegion *) &_result_ref;
34420 }
34421 wxPyEndAllowThreads(__tstate);
34422 if (PyErr_Occurred()) SWIG_fail;
34423 }
34424 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
34425 return resultobj;
34426 fail:
34427 return NULL;
34428 }
34429
34430
34431 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34432 PyObject *resultobj = 0;
34433 wxWindow *arg1 = (wxWindow *) 0 ;
34434 wxRect result;
34435 void *argp1 = 0 ;
34436 int res1 = 0 ;
34437 PyObject *swig_obj[1] ;
34438
34439 if (!args) SWIG_fail;
34440 swig_obj[0] = args;
34441 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34442 if (!SWIG_IsOK(res1)) {
34443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34444 }
34445 arg1 = reinterpret_cast< wxWindow * >(argp1);
34446 {
34447 PyThreadState* __tstate = wxPyBeginAllowThreads();
34448 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
34449 wxPyEndAllowThreads(__tstate);
34450 if (PyErr_Occurred()) SWIG_fail;
34451 }
34452 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34453 return resultobj;
34454 fail:
34455 return NULL;
34456 }
34457
34458
34459 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34460 PyObject *resultobj = 0;
34461 wxWindow *arg1 = (wxWindow *) 0 ;
34462 int arg2 ;
34463 int arg3 ;
34464 int arg4 = (int) 1 ;
34465 int arg5 = (int) 1 ;
34466 bool result;
34467 void *argp1 = 0 ;
34468 int res1 = 0 ;
34469 int val2 ;
34470 int ecode2 = 0 ;
34471 int val3 ;
34472 int ecode3 = 0 ;
34473 int val4 ;
34474 int ecode4 = 0 ;
34475 int val5 ;
34476 int ecode5 = 0 ;
34477 PyObject * obj0 = 0 ;
34478 PyObject * obj1 = 0 ;
34479 PyObject * obj2 = 0 ;
34480 PyObject * obj3 = 0 ;
34481 PyObject * obj4 = 0 ;
34482 char * kwnames[] = {
34483 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
34484 };
34485
34486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
34487 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34488 if (!SWIG_IsOK(res1)) {
34489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
34490 }
34491 arg1 = reinterpret_cast< wxWindow * >(argp1);
34492 ecode2 = SWIG_AsVal_int(obj1, &val2);
34493 if (!SWIG_IsOK(ecode2)) {
34494 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
34495 }
34496 arg2 = static_cast< int >(val2);
34497 ecode3 = SWIG_AsVal_int(obj2, &val3);
34498 if (!SWIG_IsOK(ecode3)) {
34499 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
34500 }
34501 arg3 = static_cast< int >(val3);
34502 if (obj3) {
34503 ecode4 = SWIG_AsVal_int(obj3, &val4);
34504 if (!SWIG_IsOK(ecode4)) {
34505 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
34506 }
34507 arg4 = static_cast< int >(val4);
34508 }
34509 if (obj4) {
34510 ecode5 = SWIG_AsVal_int(obj4, &val5);
34511 if (!SWIG_IsOK(ecode5)) {
34512 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
34513 }
34514 arg5 = static_cast< int >(val5);
34515 }
34516 {
34517 PyThreadState* __tstate = wxPyBeginAllowThreads();
34518 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
34519 wxPyEndAllowThreads(__tstate);
34520 if (PyErr_Occurred()) SWIG_fail;
34521 }
34522 {
34523 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34524 }
34525 return resultobj;
34526 fail:
34527 return NULL;
34528 }
34529
34530
34531 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34532 PyObject *resultobj = 0;
34533 wxWindow *arg1 = (wxWindow *) 0 ;
34534 wxPoint *arg2 = 0 ;
34535 bool result;
34536 void *argp1 = 0 ;
34537 int res1 = 0 ;
34538 wxPoint temp2 ;
34539 PyObject * obj0 = 0 ;
34540 PyObject * obj1 = 0 ;
34541 char * kwnames[] = {
34542 (char *) "self",(char *) "pt", NULL
34543 };
34544
34545 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
34546 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34547 if (!SWIG_IsOK(res1)) {
34548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
34549 }
34550 arg1 = reinterpret_cast< wxWindow * >(argp1);
34551 {
34552 arg2 = &temp2;
34553 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34554 }
34555 {
34556 PyThreadState* __tstate = wxPyBeginAllowThreads();
34557 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
34558 wxPyEndAllowThreads(__tstate);
34559 if (PyErr_Occurred()) SWIG_fail;
34560 }
34561 {
34562 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34563 }
34564 return resultobj;
34565 fail:
34566 return NULL;
34567 }
34568
34569
34570 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34571 PyObject *resultobj = 0;
34572 wxWindow *arg1 = (wxWindow *) 0 ;
34573 wxRect *arg2 = 0 ;
34574 bool result;
34575 void *argp1 = 0 ;
34576 int res1 = 0 ;
34577 wxRect temp2 ;
34578 PyObject * obj0 = 0 ;
34579 PyObject * obj1 = 0 ;
34580 char * kwnames[] = {
34581 (char *) "self",(char *) "rect", NULL
34582 };
34583
34584 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
34585 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34586 if (!SWIG_IsOK(res1)) {
34587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34588 }
34589 arg1 = reinterpret_cast< wxWindow * >(argp1);
34590 {
34591 arg2 = &temp2;
34592 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34593 }
34594 {
34595 PyThreadState* __tstate = wxPyBeginAllowThreads();
34596 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
34597 wxPyEndAllowThreads(__tstate);
34598 if (PyErr_Occurred()) SWIG_fail;
34599 }
34600 {
34601 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34602 }
34603 return resultobj;
34604 fail:
34605 return NULL;
34606 }
34607
34608
34609 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34610 PyObject *resultobj = 0;
34611 wxWindow *arg1 = (wxWindow *) 0 ;
34612 SwigValueWrapper<wxVisualAttributes > result;
34613 void *argp1 = 0 ;
34614 int res1 = 0 ;
34615 PyObject *swig_obj[1] ;
34616
34617 if (!args) SWIG_fail;
34618 swig_obj[0] = args;
34619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34620 if (!SWIG_IsOK(res1)) {
34621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
34622 }
34623 arg1 = reinterpret_cast< wxWindow * >(argp1);
34624 {
34625 PyThreadState* __tstate = wxPyBeginAllowThreads();
34626 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
34627 wxPyEndAllowThreads(__tstate);
34628 if (PyErr_Occurred()) SWIG_fail;
34629 }
34630 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34631 return resultobj;
34632 fail:
34633 return NULL;
34634 }
34635
34636
34637 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34638 PyObject *resultobj = 0;
34639 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
34640 SwigValueWrapper<wxVisualAttributes > result;
34641 int val1 ;
34642 int ecode1 = 0 ;
34643 PyObject * obj0 = 0 ;
34644 char * kwnames[] = {
34645 (char *) "variant", NULL
34646 };
34647
34648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
34649 if (obj0) {
34650 ecode1 = SWIG_AsVal_int(obj0, &val1);
34651 if (!SWIG_IsOK(ecode1)) {
34652 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
34653 }
34654 arg1 = static_cast< wxWindowVariant >(val1);
34655 }
34656 {
34657 if (!wxPyCheckForApp()) SWIG_fail;
34658 PyThreadState* __tstate = wxPyBeginAllowThreads();
34659 result = wxWindow::GetClassDefaultAttributes(arg1);
34660 wxPyEndAllowThreads(__tstate);
34661 if (PyErr_Occurred()) SWIG_fail;
34662 }
34663 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34664 return resultobj;
34665 fail:
34666 return NULL;
34667 }
34668
34669
34670 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34671 PyObject *resultobj = 0;
34672 wxWindow *arg1 = (wxWindow *) 0 ;
34673 wxColour *arg2 = 0 ;
34674 bool result;
34675 void *argp1 = 0 ;
34676 int res1 = 0 ;
34677 wxColour temp2 ;
34678 PyObject * obj0 = 0 ;
34679 PyObject * obj1 = 0 ;
34680 char * kwnames[] = {
34681 (char *) "self",(char *) "colour", NULL
34682 };
34683
34684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34685 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34686 if (!SWIG_IsOK(res1)) {
34687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34688 }
34689 arg1 = reinterpret_cast< wxWindow * >(argp1);
34690 {
34691 arg2 = &temp2;
34692 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34693 }
34694 {
34695 PyThreadState* __tstate = wxPyBeginAllowThreads();
34696 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
34697 wxPyEndAllowThreads(__tstate);
34698 if (PyErr_Occurred()) SWIG_fail;
34699 }
34700 {
34701 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34702 }
34703 return resultobj;
34704 fail:
34705 return NULL;
34706 }
34707
34708
34709 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34710 PyObject *resultobj = 0;
34711 wxWindow *arg1 = (wxWindow *) 0 ;
34712 wxColour *arg2 = 0 ;
34713 void *argp1 = 0 ;
34714 int res1 = 0 ;
34715 wxColour temp2 ;
34716 PyObject * obj0 = 0 ;
34717 PyObject * obj1 = 0 ;
34718 char * kwnames[] = {
34719 (char *) "self",(char *) "colour", NULL
34720 };
34721
34722 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34723 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34724 if (!SWIG_IsOK(res1)) {
34725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34726 }
34727 arg1 = reinterpret_cast< wxWindow * >(argp1);
34728 {
34729 arg2 = &temp2;
34730 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34731 }
34732 {
34733 PyThreadState* __tstate = wxPyBeginAllowThreads();
34734 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
34735 wxPyEndAllowThreads(__tstate);
34736 if (PyErr_Occurred()) SWIG_fail;
34737 }
34738 resultobj = SWIG_Py_Void();
34739 return resultobj;
34740 fail:
34741 return NULL;
34742 }
34743
34744
34745 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34746 PyObject *resultobj = 0;
34747 wxWindow *arg1 = (wxWindow *) 0 ;
34748 wxColour *arg2 = 0 ;
34749 bool result;
34750 void *argp1 = 0 ;
34751 int res1 = 0 ;
34752 wxColour temp2 ;
34753 PyObject * obj0 = 0 ;
34754 PyObject * obj1 = 0 ;
34755 char * kwnames[] = {
34756 (char *) "self",(char *) "colour", NULL
34757 };
34758
34759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34760 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34761 if (!SWIG_IsOK(res1)) {
34762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34763 }
34764 arg1 = reinterpret_cast< wxWindow * >(argp1);
34765 {
34766 arg2 = &temp2;
34767 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34768 }
34769 {
34770 PyThreadState* __tstate = wxPyBeginAllowThreads();
34771 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
34772 wxPyEndAllowThreads(__tstate);
34773 if (PyErr_Occurred()) SWIG_fail;
34774 }
34775 {
34776 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34777 }
34778 return resultobj;
34779 fail:
34780 return NULL;
34781 }
34782
34783
34784 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34785 PyObject *resultobj = 0;
34786 wxWindow *arg1 = (wxWindow *) 0 ;
34787 wxColour *arg2 = 0 ;
34788 void *argp1 = 0 ;
34789 int res1 = 0 ;
34790 wxColour temp2 ;
34791 PyObject * obj0 = 0 ;
34792 PyObject * obj1 = 0 ;
34793 char * kwnames[] = {
34794 (char *) "self",(char *) "colour", NULL
34795 };
34796
34797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34798 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34799 if (!SWIG_IsOK(res1)) {
34800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34801 }
34802 arg1 = reinterpret_cast< wxWindow * >(argp1);
34803 {
34804 arg2 = &temp2;
34805 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34806 }
34807 {
34808 PyThreadState* __tstate = wxPyBeginAllowThreads();
34809 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
34810 wxPyEndAllowThreads(__tstate);
34811 if (PyErr_Occurred()) SWIG_fail;
34812 }
34813 resultobj = SWIG_Py_Void();
34814 return resultobj;
34815 fail:
34816 return NULL;
34817 }
34818
34819
34820 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34821 PyObject *resultobj = 0;
34822 wxWindow *arg1 = (wxWindow *) 0 ;
34823 wxColour result;
34824 void *argp1 = 0 ;
34825 int res1 = 0 ;
34826 PyObject *swig_obj[1] ;
34827
34828 if (!args) SWIG_fail;
34829 swig_obj[0] = args;
34830 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34831 if (!SWIG_IsOK(res1)) {
34832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
34833 }
34834 arg1 = reinterpret_cast< wxWindow * >(argp1);
34835 {
34836 PyThreadState* __tstate = wxPyBeginAllowThreads();
34837 result = ((wxWindow const *)arg1)->GetBackgroundColour();
34838 wxPyEndAllowThreads(__tstate);
34839 if (PyErr_Occurred()) SWIG_fail;
34840 }
34841 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
34842 return resultobj;
34843 fail:
34844 return NULL;
34845 }
34846
34847
34848 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34849 PyObject *resultobj = 0;
34850 wxWindow *arg1 = (wxWindow *) 0 ;
34851 wxColour result;
34852 void *argp1 = 0 ;
34853 int res1 = 0 ;
34854 PyObject *swig_obj[1] ;
34855
34856 if (!args) SWIG_fail;
34857 swig_obj[0] = args;
34858 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34859 if (!SWIG_IsOK(res1)) {
34860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
34861 }
34862 arg1 = reinterpret_cast< wxWindow * >(argp1);
34863 {
34864 PyThreadState* __tstate = wxPyBeginAllowThreads();
34865 result = ((wxWindow const *)arg1)->GetForegroundColour();
34866 wxPyEndAllowThreads(__tstate);
34867 if (PyErr_Occurred()) SWIG_fail;
34868 }
34869 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
34870 return resultobj;
34871 fail:
34872 return NULL;
34873 }
34874
34875
34876 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34877 PyObject *resultobj = 0;
34878 wxWindow *arg1 = (wxWindow *) 0 ;
34879 bool result;
34880 void *argp1 = 0 ;
34881 int res1 = 0 ;
34882 PyObject *swig_obj[1] ;
34883
34884 if (!args) SWIG_fail;
34885 swig_obj[0] = args;
34886 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34887 if (!SWIG_IsOK(res1)) {
34888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
34889 }
34890 arg1 = reinterpret_cast< wxWindow * >(argp1);
34891 {
34892 PyThreadState* __tstate = wxPyBeginAllowThreads();
34893 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
34894 wxPyEndAllowThreads(__tstate);
34895 if (PyErr_Occurred()) SWIG_fail;
34896 }
34897 {
34898 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34899 }
34900 return resultobj;
34901 fail:
34902 return NULL;
34903 }
34904
34905
34906 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34907 PyObject *resultobj = 0;
34908 wxWindow *arg1 = (wxWindow *) 0 ;
34909 bool result;
34910 void *argp1 = 0 ;
34911 int res1 = 0 ;
34912 PyObject *swig_obj[1] ;
34913
34914 if (!args) SWIG_fail;
34915 swig_obj[0] = args;
34916 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34917 if (!SWIG_IsOK(res1)) {
34918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
34919 }
34920 arg1 = reinterpret_cast< wxWindow * >(argp1);
34921 {
34922 PyThreadState* __tstate = wxPyBeginAllowThreads();
34923 result = (bool)((wxWindow const *)arg1)->UseBgCol();
34924 wxPyEndAllowThreads(__tstate);
34925 if (PyErr_Occurred()) SWIG_fail;
34926 }
34927 {
34928 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34929 }
34930 return resultobj;
34931 fail:
34932 return NULL;
34933 }
34934
34935
34936 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34937 PyObject *resultobj = 0;
34938 wxWindow *arg1 = (wxWindow *) 0 ;
34939 wxBackgroundStyle arg2 ;
34940 bool result;
34941 void *argp1 = 0 ;
34942 int res1 = 0 ;
34943 int val2 ;
34944 int ecode2 = 0 ;
34945 PyObject * obj0 = 0 ;
34946 PyObject * obj1 = 0 ;
34947 char * kwnames[] = {
34948 (char *) "self",(char *) "style", NULL
34949 };
34950
34951 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
34952 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34953 if (!SWIG_IsOK(res1)) {
34954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
34955 }
34956 arg1 = reinterpret_cast< wxWindow * >(argp1);
34957 ecode2 = SWIG_AsVal_int(obj1, &val2);
34958 if (!SWIG_IsOK(ecode2)) {
34959 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
34960 }
34961 arg2 = static_cast< wxBackgroundStyle >(val2);
34962 {
34963 PyThreadState* __tstate = wxPyBeginAllowThreads();
34964 result = (bool)(arg1)->SetBackgroundStyle(arg2);
34965 wxPyEndAllowThreads(__tstate);
34966 if (PyErr_Occurred()) SWIG_fail;
34967 }
34968 {
34969 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34970 }
34971 return resultobj;
34972 fail:
34973 return NULL;
34974 }
34975
34976
34977 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34978 PyObject *resultobj = 0;
34979 wxWindow *arg1 = (wxWindow *) 0 ;
34980 wxBackgroundStyle result;
34981 void *argp1 = 0 ;
34982 int res1 = 0 ;
34983 PyObject *swig_obj[1] ;
34984
34985 if (!args) SWIG_fail;
34986 swig_obj[0] = args;
34987 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34988 if (!SWIG_IsOK(res1)) {
34989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
34990 }
34991 arg1 = reinterpret_cast< wxWindow * >(argp1);
34992 {
34993 PyThreadState* __tstate = wxPyBeginAllowThreads();
34994 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
34995 wxPyEndAllowThreads(__tstate);
34996 if (PyErr_Occurred()) SWIG_fail;
34997 }
34998 resultobj = SWIG_From_int(static_cast< int >(result));
34999 return resultobj;
35000 fail:
35001 return NULL;
35002 }
35003
35004
35005 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35006 PyObject *resultobj = 0;
35007 wxWindow *arg1 = (wxWindow *) 0 ;
35008 bool result;
35009 void *argp1 = 0 ;
35010 int res1 = 0 ;
35011 PyObject *swig_obj[1] ;
35012
35013 if (!args) SWIG_fail;
35014 swig_obj[0] = args;
35015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35016 if (!SWIG_IsOK(res1)) {
35017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
35018 }
35019 arg1 = reinterpret_cast< wxWindow * >(argp1);
35020 {
35021 PyThreadState* __tstate = wxPyBeginAllowThreads();
35022 result = (bool)(arg1)->HasTransparentBackground();
35023 wxPyEndAllowThreads(__tstate);
35024 if (PyErr_Occurred()) SWIG_fail;
35025 }
35026 {
35027 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35028 }
35029 return resultobj;
35030 fail:
35031 return NULL;
35032 }
35033
35034
35035 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35036 PyObject *resultobj = 0;
35037 wxWindow *arg1 = (wxWindow *) 0 ;
35038 wxCursor *arg2 = 0 ;
35039 bool result;
35040 void *argp1 = 0 ;
35041 int res1 = 0 ;
35042 void *argp2 = 0 ;
35043 int res2 = 0 ;
35044 PyObject * obj0 = 0 ;
35045 PyObject * obj1 = 0 ;
35046 char * kwnames[] = {
35047 (char *) "self",(char *) "cursor", NULL
35048 };
35049
35050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
35051 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35052 if (!SWIG_IsOK(res1)) {
35053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35054 }
35055 arg1 = reinterpret_cast< wxWindow * >(argp1);
35056 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
35057 if (!SWIG_IsOK(res2)) {
35058 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35059 }
35060 if (!argp2) {
35061 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35062 }
35063 arg2 = reinterpret_cast< wxCursor * >(argp2);
35064 {
35065 PyThreadState* __tstate = wxPyBeginAllowThreads();
35066 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
35067 wxPyEndAllowThreads(__tstate);
35068 if (PyErr_Occurred()) SWIG_fail;
35069 }
35070 {
35071 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35072 }
35073 return resultobj;
35074 fail:
35075 return NULL;
35076 }
35077
35078
35079 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35080 PyObject *resultobj = 0;
35081 wxWindow *arg1 = (wxWindow *) 0 ;
35082 wxCursor result;
35083 void *argp1 = 0 ;
35084 int res1 = 0 ;
35085 PyObject *swig_obj[1] ;
35086
35087 if (!args) SWIG_fail;
35088 swig_obj[0] = args;
35089 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35090 if (!SWIG_IsOK(res1)) {
35091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35092 }
35093 arg1 = reinterpret_cast< wxWindow * >(argp1);
35094 {
35095 PyThreadState* __tstate = wxPyBeginAllowThreads();
35096 result = (arg1)->GetCursor();
35097 wxPyEndAllowThreads(__tstate);
35098 if (PyErr_Occurred()) SWIG_fail;
35099 }
35100 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
35101 return resultobj;
35102 fail:
35103 return NULL;
35104 }
35105
35106
35107 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35108 PyObject *resultobj = 0;
35109 wxWindow *arg1 = (wxWindow *) 0 ;
35110 wxFont *arg2 = 0 ;
35111 bool result;
35112 void *argp1 = 0 ;
35113 int res1 = 0 ;
35114 void *argp2 = 0 ;
35115 int res2 = 0 ;
35116 PyObject * obj0 = 0 ;
35117 PyObject * obj1 = 0 ;
35118 char * kwnames[] = {
35119 (char *) "self",(char *) "font", NULL
35120 };
35121
35122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
35123 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35124 if (!SWIG_IsOK(res1)) {
35125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35126 }
35127 arg1 = reinterpret_cast< wxWindow * >(argp1);
35128 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35129 if (!SWIG_IsOK(res2)) {
35130 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35131 }
35132 if (!argp2) {
35133 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35134 }
35135 arg2 = reinterpret_cast< wxFont * >(argp2);
35136 {
35137 PyThreadState* __tstate = wxPyBeginAllowThreads();
35138 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
35139 wxPyEndAllowThreads(__tstate);
35140 if (PyErr_Occurred()) SWIG_fail;
35141 }
35142 {
35143 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35144 }
35145 return resultobj;
35146 fail:
35147 return NULL;
35148 }
35149
35150
35151 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35152 PyObject *resultobj = 0;
35153 wxWindow *arg1 = (wxWindow *) 0 ;
35154 wxFont *arg2 = 0 ;
35155 void *argp1 = 0 ;
35156 int res1 = 0 ;
35157 void *argp2 = 0 ;
35158 int res2 = 0 ;
35159 PyObject * obj0 = 0 ;
35160 PyObject * obj1 = 0 ;
35161 char * kwnames[] = {
35162 (char *) "self",(char *) "font", NULL
35163 };
35164
35165 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
35166 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35167 if (!SWIG_IsOK(res1)) {
35168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35169 }
35170 arg1 = reinterpret_cast< wxWindow * >(argp1);
35171 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35172 if (!SWIG_IsOK(res2)) {
35173 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35174 }
35175 if (!argp2) {
35176 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35177 }
35178 arg2 = reinterpret_cast< wxFont * >(argp2);
35179 {
35180 PyThreadState* __tstate = wxPyBeginAllowThreads();
35181 (arg1)->SetOwnFont((wxFont const &)*arg2);
35182 wxPyEndAllowThreads(__tstate);
35183 if (PyErr_Occurred()) SWIG_fail;
35184 }
35185 resultobj = SWIG_Py_Void();
35186 return resultobj;
35187 fail:
35188 return NULL;
35189 }
35190
35191
35192 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35193 PyObject *resultobj = 0;
35194 wxWindow *arg1 = (wxWindow *) 0 ;
35195 wxFont result;
35196 void *argp1 = 0 ;
35197 int res1 = 0 ;
35198 PyObject *swig_obj[1] ;
35199
35200 if (!args) SWIG_fail;
35201 swig_obj[0] = args;
35202 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35203 if (!SWIG_IsOK(res1)) {
35204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35205 }
35206 arg1 = reinterpret_cast< wxWindow * >(argp1);
35207 {
35208 PyThreadState* __tstate = wxPyBeginAllowThreads();
35209 result = (arg1)->GetFont();
35210 wxPyEndAllowThreads(__tstate);
35211 if (PyErr_Occurred()) SWIG_fail;
35212 }
35213 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
35214 return resultobj;
35215 fail:
35216 return NULL;
35217 }
35218
35219
35220 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35221 PyObject *resultobj = 0;
35222 wxWindow *arg1 = (wxWindow *) 0 ;
35223 wxCaret *arg2 = (wxCaret *) 0 ;
35224 void *argp1 = 0 ;
35225 int res1 = 0 ;
35226 int res2 = 0 ;
35227 PyObject * obj0 = 0 ;
35228 PyObject * obj1 = 0 ;
35229 char * kwnames[] = {
35230 (char *) "self",(char *) "caret", NULL
35231 };
35232
35233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
35234 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35235 if (!SWIG_IsOK(res1)) {
35236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
35237 }
35238 arg1 = reinterpret_cast< wxWindow * >(argp1);
35239 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
35240 if (!SWIG_IsOK(res2)) {
35241 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
35242 }
35243 {
35244 PyThreadState* __tstate = wxPyBeginAllowThreads();
35245 (arg1)->SetCaret(arg2);
35246 wxPyEndAllowThreads(__tstate);
35247 if (PyErr_Occurred()) SWIG_fail;
35248 }
35249 resultobj = SWIG_Py_Void();
35250 return resultobj;
35251 fail:
35252 return NULL;
35253 }
35254
35255
35256 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35257 PyObject *resultobj = 0;
35258 wxWindow *arg1 = (wxWindow *) 0 ;
35259 wxCaret *result = 0 ;
35260 void *argp1 = 0 ;
35261 int res1 = 0 ;
35262 PyObject *swig_obj[1] ;
35263
35264 if (!args) SWIG_fail;
35265 swig_obj[0] = args;
35266 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35267 if (!SWIG_IsOK(res1)) {
35268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
35269 }
35270 arg1 = reinterpret_cast< wxWindow * >(argp1);
35271 {
35272 PyThreadState* __tstate = wxPyBeginAllowThreads();
35273 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
35274 wxPyEndAllowThreads(__tstate);
35275 if (PyErr_Occurred()) SWIG_fail;
35276 }
35277 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
35278 return resultobj;
35279 fail:
35280 return NULL;
35281 }
35282
35283
35284 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35285 PyObject *resultobj = 0;
35286 wxWindow *arg1 = (wxWindow *) 0 ;
35287 int result;
35288 void *argp1 = 0 ;
35289 int res1 = 0 ;
35290 PyObject *swig_obj[1] ;
35291
35292 if (!args) SWIG_fail;
35293 swig_obj[0] = args;
35294 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35295 if (!SWIG_IsOK(res1)) {
35296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35297 }
35298 arg1 = reinterpret_cast< wxWindow * >(argp1);
35299 {
35300 PyThreadState* __tstate = wxPyBeginAllowThreads();
35301 result = (int)((wxWindow const *)arg1)->GetCharHeight();
35302 wxPyEndAllowThreads(__tstate);
35303 if (PyErr_Occurred()) SWIG_fail;
35304 }
35305 resultobj = SWIG_From_int(static_cast< int >(result));
35306 return resultobj;
35307 fail:
35308 return NULL;
35309 }
35310
35311
35312 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35313 PyObject *resultobj = 0;
35314 wxWindow *arg1 = (wxWindow *) 0 ;
35315 int result;
35316 void *argp1 = 0 ;
35317 int res1 = 0 ;
35318 PyObject *swig_obj[1] ;
35319
35320 if (!args) SWIG_fail;
35321 swig_obj[0] = args;
35322 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35323 if (!SWIG_IsOK(res1)) {
35324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35325 }
35326 arg1 = reinterpret_cast< wxWindow * >(argp1);
35327 {
35328 PyThreadState* __tstate = wxPyBeginAllowThreads();
35329 result = (int)((wxWindow const *)arg1)->GetCharWidth();
35330 wxPyEndAllowThreads(__tstate);
35331 if (PyErr_Occurred()) SWIG_fail;
35332 }
35333 resultobj = SWIG_From_int(static_cast< int >(result));
35334 return resultobj;
35335 fail:
35336 return NULL;
35337 }
35338
35339
35340 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35341 PyObject *resultobj = 0;
35342 wxWindow *arg1 = (wxWindow *) 0 ;
35343 wxString *arg2 = 0 ;
35344 int *arg3 = (int *) 0 ;
35345 int *arg4 = (int *) 0 ;
35346 void *argp1 = 0 ;
35347 int res1 = 0 ;
35348 bool temp2 = false ;
35349 int temp3 ;
35350 int res3 = SWIG_TMPOBJ ;
35351 int temp4 ;
35352 int res4 = SWIG_TMPOBJ ;
35353 PyObject * obj0 = 0 ;
35354 PyObject * obj1 = 0 ;
35355 char * kwnames[] = {
35356 (char *) "self",(char *) "string", NULL
35357 };
35358
35359 arg3 = &temp3;
35360 arg4 = &temp4;
35361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
35362 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35363 if (!SWIG_IsOK(res1)) {
35364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35365 }
35366 arg1 = reinterpret_cast< wxWindow * >(argp1);
35367 {
35368 arg2 = wxString_in_helper(obj1);
35369 if (arg2 == NULL) SWIG_fail;
35370 temp2 = true;
35371 }
35372 {
35373 PyThreadState* __tstate = wxPyBeginAllowThreads();
35374 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
35375 wxPyEndAllowThreads(__tstate);
35376 if (PyErr_Occurred()) SWIG_fail;
35377 }
35378 resultobj = SWIG_Py_Void();
35379 if (SWIG_IsTmpObj(res3)) {
35380 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35381 } else {
35382 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35383 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35384 }
35385 if (SWIG_IsTmpObj(res4)) {
35386 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35387 } else {
35388 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35389 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35390 }
35391 {
35392 if (temp2)
35393 delete arg2;
35394 }
35395 return resultobj;
35396 fail:
35397 {
35398 if (temp2)
35399 delete arg2;
35400 }
35401 return NULL;
35402 }
35403
35404
35405 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35406 PyObject *resultobj = 0;
35407 wxWindow *arg1 = (wxWindow *) 0 ;
35408 wxString *arg2 = 0 ;
35409 int *arg3 = (int *) 0 ;
35410 int *arg4 = (int *) 0 ;
35411 int *arg5 = (int *) 0 ;
35412 int *arg6 = (int *) 0 ;
35413 wxFont *arg7 = (wxFont *) NULL ;
35414 void *argp1 = 0 ;
35415 int res1 = 0 ;
35416 bool temp2 = false ;
35417 int temp3 ;
35418 int res3 = SWIG_TMPOBJ ;
35419 int temp4 ;
35420 int res4 = SWIG_TMPOBJ ;
35421 int temp5 ;
35422 int res5 = SWIG_TMPOBJ ;
35423 int temp6 ;
35424 int res6 = SWIG_TMPOBJ ;
35425 void *argp7 = 0 ;
35426 int res7 = 0 ;
35427 PyObject * obj0 = 0 ;
35428 PyObject * obj1 = 0 ;
35429 PyObject * obj2 = 0 ;
35430 char * kwnames[] = {
35431 (char *) "self",(char *) "string",(char *) "font", NULL
35432 };
35433
35434 arg3 = &temp3;
35435 arg4 = &temp4;
35436 arg5 = &temp5;
35437 arg6 = &temp6;
35438 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35439 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35440 if (!SWIG_IsOK(res1)) {
35441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35442 }
35443 arg1 = reinterpret_cast< wxWindow * >(argp1);
35444 {
35445 arg2 = wxString_in_helper(obj1);
35446 if (arg2 == NULL) SWIG_fail;
35447 temp2 = true;
35448 }
35449 if (obj2) {
35450 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
35451 if (!SWIG_IsOK(res7)) {
35452 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
35453 }
35454 arg7 = reinterpret_cast< wxFont * >(argp7);
35455 }
35456 {
35457 PyThreadState* __tstate = wxPyBeginAllowThreads();
35458 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
35459 wxPyEndAllowThreads(__tstate);
35460 if (PyErr_Occurred()) SWIG_fail;
35461 }
35462 resultobj = SWIG_Py_Void();
35463 if (SWIG_IsTmpObj(res3)) {
35464 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35465 } else {
35466 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35467 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35468 }
35469 if (SWIG_IsTmpObj(res4)) {
35470 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35471 } else {
35472 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35473 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35474 }
35475 if (SWIG_IsTmpObj(res5)) {
35476 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
35477 } else {
35478 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35479 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
35480 }
35481 if (SWIG_IsTmpObj(res6)) {
35482 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
35483 } else {
35484 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35485 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
35486 }
35487 {
35488 if (temp2)
35489 delete arg2;
35490 }
35491 return resultobj;
35492 fail:
35493 {
35494 if (temp2)
35495 delete arg2;
35496 }
35497 return NULL;
35498 }
35499
35500
35501 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35502 PyObject *resultobj = 0;
35503 wxWindow *arg1 = (wxWindow *) 0 ;
35504 int *arg2 = (int *) 0 ;
35505 int *arg3 = (int *) 0 ;
35506 void *argp1 = 0 ;
35507 int res1 = 0 ;
35508 int temp2 ;
35509 int res2 = 0 ;
35510 int temp3 ;
35511 int res3 = 0 ;
35512 PyObject * obj0 = 0 ;
35513 PyObject * obj1 = 0 ;
35514 PyObject * obj2 = 0 ;
35515 char * kwnames[] = {
35516 (char *) "self",(char *) "x",(char *) "y", NULL
35517 };
35518
35519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35520 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35521 if (!SWIG_IsOK(res1)) {
35522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35523 }
35524 arg1 = reinterpret_cast< wxWindow * >(argp1);
35525 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35526 int val;
35527 int ecode = SWIG_AsVal_int(obj1, &val);
35528 if (!SWIG_IsOK(ecode)) {
35529 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
35530 }
35531 temp2 = static_cast< int >(val);
35532 arg2 = &temp2;
35533 res2 = SWIG_AddTmpMask(ecode);
35534 }
35535 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35536 int val;
35537 int ecode = SWIG_AsVal_int(obj2, &val);
35538 if (!SWIG_IsOK(ecode)) {
35539 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
35540 }
35541 temp3 = static_cast< int >(val);
35542 arg3 = &temp3;
35543 res3 = SWIG_AddTmpMask(ecode);
35544 }
35545 {
35546 PyThreadState* __tstate = wxPyBeginAllowThreads();
35547 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
35548 wxPyEndAllowThreads(__tstate);
35549 if (PyErr_Occurred()) SWIG_fail;
35550 }
35551 resultobj = SWIG_Py_Void();
35552 if (SWIG_IsTmpObj(res2)) {
35553 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35554 } else {
35555 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35556 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35557 }
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 return resultobj;
35565 fail:
35566 return NULL;
35567 }
35568
35569
35570 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35571 PyObject *resultobj = 0;
35572 wxWindow *arg1 = (wxWindow *) 0 ;
35573 int *arg2 = (int *) 0 ;
35574 int *arg3 = (int *) 0 ;
35575 void *argp1 = 0 ;
35576 int res1 = 0 ;
35577 int temp2 ;
35578 int res2 = 0 ;
35579 int temp3 ;
35580 int res3 = 0 ;
35581 PyObject * obj0 = 0 ;
35582 PyObject * obj1 = 0 ;
35583 PyObject * obj2 = 0 ;
35584 char * kwnames[] = {
35585 (char *) "self",(char *) "x",(char *) "y", NULL
35586 };
35587
35588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35590 if (!SWIG_IsOK(res1)) {
35591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35592 }
35593 arg1 = reinterpret_cast< wxWindow * >(argp1);
35594 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35595 int val;
35596 int ecode = SWIG_AsVal_int(obj1, &val);
35597 if (!SWIG_IsOK(ecode)) {
35598 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
35599 }
35600 temp2 = static_cast< int >(val);
35601 arg2 = &temp2;
35602 res2 = SWIG_AddTmpMask(ecode);
35603 }
35604 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35605 int val;
35606 int ecode = SWIG_AsVal_int(obj2, &val);
35607 if (!SWIG_IsOK(ecode)) {
35608 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
35609 }
35610 temp3 = static_cast< int >(val);
35611 arg3 = &temp3;
35612 res3 = SWIG_AddTmpMask(ecode);
35613 }
35614 {
35615 PyThreadState* __tstate = wxPyBeginAllowThreads();
35616 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
35617 wxPyEndAllowThreads(__tstate);
35618 if (PyErr_Occurred()) SWIG_fail;
35619 }
35620 resultobj = SWIG_Py_Void();
35621 if (SWIG_IsTmpObj(res2)) {
35622 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35623 } else {
35624 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35625 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35626 }
35627 if (SWIG_IsTmpObj(res3)) {
35628 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35629 } else {
35630 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35631 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35632 }
35633 return resultobj;
35634 fail:
35635 return NULL;
35636 }
35637
35638
35639 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35640 PyObject *resultobj = 0;
35641 wxWindow *arg1 = (wxWindow *) 0 ;
35642 wxPoint *arg2 = 0 ;
35643 wxPoint result;
35644 void *argp1 = 0 ;
35645 int res1 = 0 ;
35646 wxPoint temp2 ;
35647 PyObject * obj0 = 0 ;
35648 PyObject * obj1 = 0 ;
35649 char * kwnames[] = {
35650 (char *) "self",(char *) "pt", NULL
35651 };
35652
35653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
35654 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35655 if (!SWIG_IsOK(res1)) {
35656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35657 }
35658 arg1 = reinterpret_cast< wxWindow * >(argp1);
35659 {
35660 arg2 = &temp2;
35661 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35662 }
35663 {
35664 PyThreadState* __tstate = wxPyBeginAllowThreads();
35665 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
35666 wxPyEndAllowThreads(__tstate);
35667 if (PyErr_Occurred()) SWIG_fail;
35668 }
35669 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35670 return resultobj;
35671 fail:
35672 return NULL;
35673 }
35674
35675
35676 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35677 PyObject *resultobj = 0;
35678 wxWindow *arg1 = (wxWindow *) 0 ;
35679 wxPoint *arg2 = 0 ;
35680 wxPoint result;
35681 void *argp1 = 0 ;
35682 int res1 = 0 ;
35683 wxPoint temp2 ;
35684 PyObject * obj0 = 0 ;
35685 PyObject * obj1 = 0 ;
35686 char * kwnames[] = {
35687 (char *) "self",(char *) "pt", NULL
35688 };
35689
35690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
35691 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35692 if (!SWIG_IsOK(res1)) {
35693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
35694 }
35695 arg1 = reinterpret_cast< wxWindow * >(argp1);
35696 {
35697 arg2 = &temp2;
35698 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35699 }
35700 {
35701 PyThreadState* __tstate = wxPyBeginAllowThreads();
35702 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
35703 wxPyEndAllowThreads(__tstate);
35704 if (PyErr_Occurred()) SWIG_fail;
35705 }
35706 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35707 return resultobj;
35708 fail:
35709 return NULL;
35710 }
35711
35712
35713 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35714 PyObject *resultobj = 0;
35715 wxWindow *arg1 = (wxWindow *) 0 ;
35716 int arg2 ;
35717 int arg3 ;
35718 wxHitTest result;
35719 void *argp1 = 0 ;
35720 int res1 = 0 ;
35721 int val2 ;
35722 int ecode2 = 0 ;
35723 int val3 ;
35724 int ecode3 = 0 ;
35725 PyObject * obj0 = 0 ;
35726 PyObject * obj1 = 0 ;
35727 PyObject * obj2 = 0 ;
35728 char * kwnames[] = {
35729 (char *) "self",(char *) "x",(char *) "y", NULL
35730 };
35731
35732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35733 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35734 if (!SWIG_IsOK(res1)) {
35735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35736 }
35737 arg1 = reinterpret_cast< wxWindow * >(argp1);
35738 ecode2 = SWIG_AsVal_int(obj1, &val2);
35739 if (!SWIG_IsOK(ecode2)) {
35740 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
35741 }
35742 arg2 = static_cast< int >(val2);
35743 ecode3 = SWIG_AsVal_int(obj2, &val3);
35744 if (!SWIG_IsOK(ecode3)) {
35745 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
35746 }
35747 arg3 = static_cast< int >(val3);
35748 {
35749 PyThreadState* __tstate = wxPyBeginAllowThreads();
35750 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
35751 wxPyEndAllowThreads(__tstate);
35752 if (PyErr_Occurred()) SWIG_fail;
35753 }
35754 resultobj = SWIG_From_int(static_cast< int >(result));
35755 return resultobj;
35756 fail:
35757 return NULL;
35758 }
35759
35760
35761 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35762 PyObject *resultobj = 0;
35763 wxWindow *arg1 = (wxWindow *) 0 ;
35764 wxPoint *arg2 = 0 ;
35765 wxHitTest result;
35766 void *argp1 = 0 ;
35767 int res1 = 0 ;
35768 wxPoint temp2 ;
35769 PyObject * obj0 = 0 ;
35770 PyObject * obj1 = 0 ;
35771 char * kwnames[] = {
35772 (char *) "self",(char *) "pt", NULL
35773 };
35774
35775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
35776 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35777 if (!SWIG_IsOK(res1)) {
35778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
35779 }
35780 arg1 = reinterpret_cast< wxWindow * >(argp1);
35781 {
35782 arg2 = &temp2;
35783 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35784 }
35785 {
35786 PyThreadState* __tstate = wxPyBeginAllowThreads();
35787 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
35788 wxPyEndAllowThreads(__tstate);
35789 if (PyErr_Occurred()) SWIG_fail;
35790 }
35791 resultobj = SWIG_From_int(static_cast< int >(result));
35792 return resultobj;
35793 fail:
35794 return NULL;
35795 }
35796
35797
35798 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
35799 PyObject *resultobj = 0;
35800 wxWindow *arg1 = (wxWindow *) 0 ;
35801 long arg2 ;
35802 wxBorder result;
35803 void *argp1 = 0 ;
35804 int res1 = 0 ;
35805 long val2 ;
35806 int ecode2 = 0 ;
35807
35808 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
35809 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35810 if (!SWIG_IsOK(res1)) {
35811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
35812 }
35813 arg1 = reinterpret_cast< wxWindow * >(argp1);
35814 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
35815 if (!SWIG_IsOK(ecode2)) {
35816 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
35817 }
35818 arg2 = static_cast< long >(val2);
35819 {
35820 PyThreadState* __tstate = wxPyBeginAllowThreads();
35821 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
35822 wxPyEndAllowThreads(__tstate);
35823 if (PyErr_Occurred()) SWIG_fail;
35824 }
35825 resultobj = SWIG_From_int(static_cast< int >(result));
35826 return resultobj;
35827 fail:
35828 return NULL;
35829 }
35830
35831
35832 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
35833 PyObject *resultobj = 0;
35834 wxWindow *arg1 = (wxWindow *) 0 ;
35835 wxBorder result;
35836 void *argp1 = 0 ;
35837 int res1 = 0 ;
35838
35839 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
35840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35841 if (!SWIG_IsOK(res1)) {
35842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
35843 }
35844 arg1 = reinterpret_cast< wxWindow * >(argp1);
35845 {
35846 PyThreadState* __tstate = wxPyBeginAllowThreads();
35847 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
35848 wxPyEndAllowThreads(__tstate);
35849 if (PyErr_Occurred()) SWIG_fail;
35850 }
35851 resultobj = SWIG_From_int(static_cast< int >(result));
35852 return resultobj;
35853 fail:
35854 return NULL;
35855 }
35856
35857
35858 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
35859 int argc;
35860 PyObject *argv[3];
35861
35862 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
35863 --argc;
35864 if (argc == 1) {
35865 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
35866 }
35867 if (argc == 2) {
35868 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
35869 }
35870
35871 fail:
35872 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
35873 return NULL;
35874 }
35875
35876
35877 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35878 PyObject *resultobj = 0;
35879 wxWindow *arg1 = (wxWindow *) 0 ;
35880 long arg2 = (long) wxUPDATE_UI_NONE ;
35881 void *argp1 = 0 ;
35882 int res1 = 0 ;
35883 long val2 ;
35884 int ecode2 = 0 ;
35885 PyObject * obj0 = 0 ;
35886 PyObject * obj1 = 0 ;
35887 char * kwnames[] = {
35888 (char *) "self",(char *) "flags", NULL
35889 };
35890
35891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
35892 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35893 if (!SWIG_IsOK(res1)) {
35894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
35895 }
35896 arg1 = reinterpret_cast< wxWindow * >(argp1);
35897 if (obj1) {
35898 ecode2 = SWIG_AsVal_long(obj1, &val2);
35899 if (!SWIG_IsOK(ecode2)) {
35900 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
35901 }
35902 arg2 = static_cast< long >(val2);
35903 }
35904 {
35905 PyThreadState* __tstate = wxPyBeginAllowThreads();
35906 (arg1)->UpdateWindowUI(arg2);
35907 wxPyEndAllowThreads(__tstate);
35908 if (PyErr_Occurred()) SWIG_fail;
35909 }
35910 resultobj = SWIG_Py_Void();
35911 return resultobj;
35912 fail:
35913 return NULL;
35914 }
35915
35916
35917 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35918 PyObject *resultobj = 0;
35919 wxWindow *arg1 = (wxWindow *) 0 ;
35920 wxMenu *arg2 = (wxMenu *) 0 ;
35921 int arg3 = (int) -1 ;
35922 int arg4 = (int) -1 ;
35923 bool result;
35924 void *argp1 = 0 ;
35925 int res1 = 0 ;
35926 void *argp2 = 0 ;
35927 int res2 = 0 ;
35928 int val3 ;
35929 int ecode3 = 0 ;
35930 int val4 ;
35931 int ecode4 = 0 ;
35932 PyObject * obj0 = 0 ;
35933 PyObject * obj1 = 0 ;
35934 PyObject * obj2 = 0 ;
35935 PyObject * obj3 = 0 ;
35936 char * kwnames[] = {
35937 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
35938 };
35939
35940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35941 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35942 if (!SWIG_IsOK(res1)) {
35943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
35944 }
35945 arg1 = reinterpret_cast< wxWindow * >(argp1);
35946 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
35947 if (!SWIG_IsOK(res2)) {
35948 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
35949 }
35950 arg2 = reinterpret_cast< wxMenu * >(argp2);
35951 if (obj2) {
35952 ecode3 = SWIG_AsVal_int(obj2, &val3);
35953 if (!SWIG_IsOK(ecode3)) {
35954 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
35955 }
35956 arg3 = static_cast< int >(val3);
35957 }
35958 if (obj3) {
35959 ecode4 = SWIG_AsVal_int(obj3, &val4);
35960 if (!SWIG_IsOK(ecode4)) {
35961 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
35962 }
35963 arg4 = static_cast< int >(val4);
35964 }
35965 {
35966 PyThreadState* __tstate = wxPyBeginAllowThreads();
35967 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
35968 wxPyEndAllowThreads(__tstate);
35969 if (PyErr_Occurred()) SWIG_fail;
35970 }
35971 {
35972 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35973 }
35974 return resultobj;
35975 fail:
35976 return NULL;
35977 }
35978
35979
35980 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35981 PyObject *resultobj = 0;
35982 wxWindow *arg1 = (wxWindow *) 0 ;
35983 wxMenu *arg2 = (wxMenu *) 0 ;
35984 wxPoint const &arg3_defvalue = wxDefaultPosition ;
35985 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
35986 bool result;
35987 void *argp1 = 0 ;
35988 int res1 = 0 ;
35989 void *argp2 = 0 ;
35990 int res2 = 0 ;
35991 wxPoint temp3 ;
35992 PyObject * obj0 = 0 ;
35993 PyObject * obj1 = 0 ;
35994 PyObject * obj2 = 0 ;
35995 char * kwnames[] = {
35996 (char *) "self",(char *) "menu",(char *) "pos", NULL
35997 };
35998
35999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36001 if (!SWIG_IsOK(res1)) {
36002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
36003 }
36004 arg1 = reinterpret_cast< wxWindow * >(argp1);
36005 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36006 if (!SWIG_IsOK(res2)) {
36007 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
36008 }
36009 arg2 = reinterpret_cast< wxMenu * >(argp2);
36010 if (obj2) {
36011 {
36012 arg3 = &temp3;
36013 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
36014 }
36015 }
36016 {
36017 PyThreadState* __tstate = wxPyBeginAllowThreads();
36018 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
36019 wxPyEndAllowThreads(__tstate);
36020 if (PyErr_Occurred()) SWIG_fail;
36021 }
36022 {
36023 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36024 }
36025 return resultobj;
36026 fail:
36027 return NULL;
36028 }
36029
36030
36031 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36032 PyObject *resultobj = 0;
36033 wxWindow *arg1 = (wxWindow *) 0 ;
36034 long result;
36035 void *argp1 = 0 ;
36036 int res1 = 0 ;
36037 PyObject *swig_obj[1] ;
36038
36039 if (!args) SWIG_fail;
36040 swig_obj[0] = args;
36041 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36042 if (!SWIG_IsOK(res1)) {
36043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36044 }
36045 arg1 = reinterpret_cast< wxWindow * >(argp1);
36046 {
36047 PyThreadState* __tstate = wxPyBeginAllowThreads();
36048 result = (long)wxWindow_GetHandle(arg1);
36049 wxPyEndAllowThreads(__tstate);
36050 if (PyErr_Occurred()) SWIG_fail;
36051 }
36052 resultobj = SWIG_From_long(static_cast< long >(result));
36053 return resultobj;
36054 fail:
36055 return NULL;
36056 }
36057
36058
36059 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36060 PyObject *resultobj = 0;
36061 wxWindow *arg1 = (wxWindow *) 0 ;
36062 long arg2 ;
36063 void *argp1 = 0 ;
36064 int res1 = 0 ;
36065 long val2 ;
36066 int ecode2 = 0 ;
36067 PyObject * obj0 = 0 ;
36068 PyObject * obj1 = 0 ;
36069 char * kwnames[] = {
36070 (char *) "self",(char *) "handle", NULL
36071 };
36072
36073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
36074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36075 if (!SWIG_IsOK(res1)) {
36076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36077 }
36078 arg1 = reinterpret_cast< wxWindow * >(argp1);
36079 ecode2 = SWIG_AsVal_long(obj1, &val2);
36080 if (!SWIG_IsOK(ecode2)) {
36081 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
36082 }
36083 arg2 = static_cast< long >(val2);
36084 {
36085 PyThreadState* __tstate = wxPyBeginAllowThreads();
36086 wxWindow_AssociateHandle(arg1,arg2);
36087 wxPyEndAllowThreads(__tstate);
36088 if (PyErr_Occurred()) SWIG_fail;
36089 }
36090 resultobj = SWIG_Py_Void();
36091 return resultobj;
36092 fail:
36093 return NULL;
36094 }
36095
36096
36097 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36098 PyObject *resultobj = 0;
36099 wxWindow *arg1 = (wxWindow *) 0 ;
36100 void *argp1 = 0 ;
36101 int res1 = 0 ;
36102 PyObject *swig_obj[1] ;
36103
36104 if (!args) SWIG_fail;
36105 swig_obj[0] = args;
36106 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36107 if (!SWIG_IsOK(res1)) {
36108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36109 }
36110 arg1 = reinterpret_cast< wxWindow * >(argp1);
36111 {
36112 PyThreadState* __tstate = wxPyBeginAllowThreads();
36113 (arg1)->DissociateHandle();
36114 wxPyEndAllowThreads(__tstate);
36115 if (PyErr_Occurred()) SWIG_fail;
36116 }
36117 resultobj = SWIG_Py_Void();
36118 return resultobj;
36119 fail:
36120 return NULL;
36121 }
36122
36123
36124 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36125 PyObject *resultobj = 0;
36126 wxWindow *arg1 = (wxWindow *) 0 ;
36127 int arg2 ;
36128 bool result;
36129 void *argp1 = 0 ;
36130 int res1 = 0 ;
36131 int val2 ;
36132 int ecode2 = 0 ;
36133 PyObject * obj0 = 0 ;
36134 PyObject * obj1 = 0 ;
36135 char * kwnames[] = {
36136 (char *) "self",(char *) "orient", NULL
36137 };
36138
36139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
36140 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36141 if (!SWIG_IsOK(res1)) {
36142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
36143 }
36144 arg1 = reinterpret_cast< wxWindow * >(argp1);
36145 ecode2 = SWIG_AsVal_int(obj1, &val2);
36146 if (!SWIG_IsOK(ecode2)) {
36147 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
36148 }
36149 arg2 = static_cast< int >(val2);
36150 {
36151 PyThreadState* __tstate = wxPyBeginAllowThreads();
36152 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
36153 wxPyEndAllowThreads(__tstate);
36154 if (PyErr_Occurred()) SWIG_fail;
36155 }
36156 {
36157 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36158 }
36159 return resultobj;
36160 fail:
36161 return NULL;
36162 }
36163
36164
36165 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36166 PyObject *resultobj = 0;
36167 wxWindow *arg1 = (wxWindow *) 0 ;
36168 int arg2 ;
36169 int arg3 ;
36170 int arg4 ;
36171 int arg5 ;
36172 bool arg6 = (bool) true ;
36173 void *argp1 = 0 ;
36174 int res1 = 0 ;
36175 int val2 ;
36176 int ecode2 = 0 ;
36177 int val3 ;
36178 int ecode3 = 0 ;
36179 int val4 ;
36180 int ecode4 = 0 ;
36181 int val5 ;
36182 int ecode5 = 0 ;
36183 bool val6 ;
36184 int ecode6 = 0 ;
36185 PyObject * obj0 = 0 ;
36186 PyObject * obj1 = 0 ;
36187 PyObject * obj2 = 0 ;
36188 PyObject * obj3 = 0 ;
36189 PyObject * obj4 = 0 ;
36190 PyObject * obj5 = 0 ;
36191 char * kwnames[] = {
36192 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
36193 };
36194
36195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
36196 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36197 if (!SWIG_IsOK(res1)) {
36198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
36199 }
36200 arg1 = reinterpret_cast< wxWindow * >(argp1);
36201 ecode2 = SWIG_AsVal_int(obj1, &val2);
36202 if (!SWIG_IsOK(ecode2)) {
36203 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
36204 }
36205 arg2 = static_cast< int >(val2);
36206 ecode3 = SWIG_AsVal_int(obj2, &val3);
36207 if (!SWIG_IsOK(ecode3)) {
36208 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
36209 }
36210 arg3 = static_cast< int >(val3);
36211 ecode4 = SWIG_AsVal_int(obj3, &val4);
36212 if (!SWIG_IsOK(ecode4)) {
36213 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
36214 }
36215 arg4 = static_cast< int >(val4);
36216 ecode5 = SWIG_AsVal_int(obj4, &val5);
36217 if (!SWIG_IsOK(ecode5)) {
36218 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
36219 }
36220 arg5 = static_cast< int >(val5);
36221 if (obj5) {
36222 ecode6 = SWIG_AsVal_bool(obj5, &val6);
36223 if (!SWIG_IsOK(ecode6)) {
36224 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
36225 }
36226 arg6 = static_cast< bool >(val6);
36227 }
36228 {
36229 PyThreadState* __tstate = wxPyBeginAllowThreads();
36230 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
36231 wxPyEndAllowThreads(__tstate);
36232 if (PyErr_Occurred()) SWIG_fail;
36233 }
36234 resultobj = SWIG_Py_Void();
36235 return resultobj;
36236 fail:
36237 return NULL;
36238 }
36239
36240
36241 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36242 PyObject *resultobj = 0;
36243 wxWindow *arg1 = (wxWindow *) 0 ;
36244 int arg2 ;
36245 int arg3 ;
36246 bool arg4 = (bool) true ;
36247 void *argp1 = 0 ;
36248 int res1 = 0 ;
36249 int val2 ;
36250 int ecode2 = 0 ;
36251 int val3 ;
36252 int ecode3 = 0 ;
36253 bool val4 ;
36254 int ecode4 = 0 ;
36255 PyObject * obj0 = 0 ;
36256 PyObject * obj1 = 0 ;
36257 PyObject * obj2 = 0 ;
36258 PyObject * obj3 = 0 ;
36259 char * kwnames[] = {
36260 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
36261 };
36262
36263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36264 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36265 if (!SWIG_IsOK(res1)) {
36266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
36267 }
36268 arg1 = reinterpret_cast< wxWindow * >(argp1);
36269 ecode2 = SWIG_AsVal_int(obj1, &val2);
36270 if (!SWIG_IsOK(ecode2)) {
36271 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
36272 }
36273 arg2 = static_cast< int >(val2);
36274 ecode3 = SWIG_AsVal_int(obj2, &val3);
36275 if (!SWIG_IsOK(ecode3)) {
36276 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
36277 }
36278 arg3 = static_cast< int >(val3);
36279 if (obj3) {
36280 ecode4 = SWIG_AsVal_bool(obj3, &val4);
36281 if (!SWIG_IsOK(ecode4)) {
36282 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
36283 }
36284 arg4 = static_cast< bool >(val4);
36285 }
36286 {
36287 PyThreadState* __tstate = wxPyBeginAllowThreads();
36288 (arg1)->SetScrollPos(arg2,arg3,arg4);
36289 wxPyEndAllowThreads(__tstate);
36290 if (PyErr_Occurred()) SWIG_fail;
36291 }
36292 resultobj = SWIG_Py_Void();
36293 return resultobj;
36294 fail:
36295 return NULL;
36296 }
36297
36298
36299 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36300 PyObject *resultobj = 0;
36301 wxWindow *arg1 = (wxWindow *) 0 ;
36302 int arg2 ;
36303 int result;
36304 void *argp1 = 0 ;
36305 int res1 = 0 ;
36306 int val2 ;
36307 int ecode2 = 0 ;
36308 PyObject * obj0 = 0 ;
36309 PyObject * obj1 = 0 ;
36310 char * kwnames[] = {
36311 (char *) "self",(char *) "orientation", NULL
36312 };
36313
36314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
36315 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36316 if (!SWIG_IsOK(res1)) {
36317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
36318 }
36319 arg1 = reinterpret_cast< wxWindow * >(argp1);
36320 ecode2 = SWIG_AsVal_int(obj1, &val2);
36321 if (!SWIG_IsOK(ecode2)) {
36322 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
36323 }
36324 arg2 = static_cast< int >(val2);
36325 {
36326 PyThreadState* __tstate = wxPyBeginAllowThreads();
36327 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
36328 wxPyEndAllowThreads(__tstate);
36329 if (PyErr_Occurred()) SWIG_fail;
36330 }
36331 resultobj = SWIG_From_int(static_cast< int >(result));
36332 return resultobj;
36333 fail:
36334 return NULL;
36335 }
36336
36337
36338 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36339 PyObject *resultobj = 0;
36340 wxWindow *arg1 = (wxWindow *) 0 ;
36341 int arg2 ;
36342 int result;
36343 void *argp1 = 0 ;
36344 int res1 = 0 ;
36345 int val2 ;
36346 int ecode2 = 0 ;
36347 PyObject * obj0 = 0 ;
36348 PyObject * obj1 = 0 ;
36349 char * kwnames[] = {
36350 (char *) "self",(char *) "orientation", NULL
36351 };
36352
36353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
36354 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36355 if (!SWIG_IsOK(res1)) {
36356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
36357 }
36358 arg1 = reinterpret_cast< wxWindow * >(argp1);
36359 ecode2 = SWIG_AsVal_int(obj1, &val2);
36360 if (!SWIG_IsOK(ecode2)) {
36361 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
36362 }
36363 arg2 = static_cast< int >(val2);
36364 {
36365 PyThreadState* __tstate = wxPyBeginAllowThreads();
36366 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
36367 wxPyEndAllowThreads(__tstate);
36368 if (PyErr_Occurred()) SWIG_fail;
36369 }
36370 resultobj = SWIG_From_int(static_cast< int >(result));
36371 return resultobj;
36372 fail:
36373 return NULL;
36374 }
36375
36376
36377 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36378 PyObject *resultobj = 0;
36379 wxWindow *arg1 = (wxWindow *) 0 ;
36380 int arg2 ;
36381 int result;
36382 void *argp1 = 0 ;
36383 int res1 = 0 ;
36384 int val2 ;
36385 int ecode2 = 0 ;
36386 PyObject * obj0 = 0 ;
36387 PyObject * obj1 = 0 ;
36388 char * kwnames[] = {
36389 (char *) "self",(char *) "orientation", NULL
36390 };
36391
36392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
36393 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36394 if (!SWIG_IsOK(res1)) {
36395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
36396 }
36397 arg1 = reinterpret_cast< wxWindow * >(argp1);
36398 ecode2 = SWIG_AsVal_int(obj1, &val2);
36399 if (!SWIG_IsOK(ecode2)) {
36400 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
36401 }
36402 arg2 = static_cast< int >(val2);
36403 {
36404 PyThreadState* __tstate = wxPyBeginAllowThreads();
36405 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
36406 wxPyEndAllowThreads(__tstate);
36407 if (PyErr_Occurred()) SWIG_fail;
36408 }
36409 resultobj = SWIG_From_int(static_cast< int >(result));
36410 return resultobj;
36411 fail:
36412 return NULL;
36413 }
36414
36415
36416 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36417 PyObject *resultobj = 0;
36418 wxWindow *arg1 = (wxWindow *) 0 ;
36419 int arg2 ;
36420 int arg3 ;
36421 wxRect *arg4 = (wxRect *) NULL ;
36422 void *argp1 = 0 ;
36423 int res1 = 0 ;
36424 int val2 ;
36425 int ecode2 = 0 ;
36426 int val3 ;
36427 int ecode3 = 0 ;
36428 void *argp4 = 0 ;
36429 int res4 = 0 ;
36430 PyObject * obj0 = 0 ;
36431 PyObject * obj1 = 0 ;
36432 PyObject * obj2 = 0 ;
36433 PyObject * obj3 = 0 ;
36434 char * kwnames[] = {
36435 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
36436 };
36437
36438 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36439 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36440 if (!SWIG_IsOK(res1)) {
36441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36442 }
36443 arg1 = reinterpret_cast< wxWindow * >(argp1);
36444 ecode2 = SWIG_AsVal_int(obj1, &val2);
36445 if (!SWIG_IsOK(ecode2)) {
36446 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
36447 }
36448 arg2 = static_cast< int >(val2);
36449 ecode3 = SWIG_AsVal_int(obj2, &val3);
36450 if (!SWIG_IsOK(ecode3)) {
36451 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
36452 }
36453 arg3 = static_cast< int >(val3);
36454 if (obj3) {
36455 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
36456 if (!SWIG_IsOK(res4)) {
36457 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
36458 }
36459 arg4 = reinterpret_cast< wxRect * >(argp4);
36460 }
36461 {
36462 PyThreadState* __tstate = wxPyBeginAllowThreads();
36463 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
36464 wxPyEndAllowThreads(__tstate);
36465 if (PyErr_Occurred()) SWIG_fail;
36466 }
36467 resultobj = SWIG_Py_Void();
36468 return resultobj;
36469 fail:
36470 return NULL;
36471 }
36472
36473
36474 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36475 PyObject *resultobj = 0;
36476 wxWindow *arg1 = (wxWindow *) 0 ;
36477 int arg2 ;
36478 bool result;
36479 void *argp1 = 0 ;
36480 int res1 = 0 ;
36481 int val2 ;
36482 int ecode2 = 0 ;
36483 PyObject * obj0 = 0 ;
36484 PyObject * obj1 = 0 ;
36485 char * kwnames[] = {
36486 (char *) "self",(char *) "lines", NULL
36487 };
36488
36489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
36490 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36491 if (!SWIG_IsOK(res1)) {
36492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
36493 }
36494 arg1 = reinterpret_cast< wxWindow * >(argp1);
36495 ecode2 = SWIG_AsVal_int(obj1, &val2);
36496 if (!SWIG_IsOK(ecode2)) {
36497 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
36498 }
36499 arg2 = static_cast< int >(val2);
36500 {
36501 PyThreadState* __tstate = wxPyBeginAllowThreads();
36502 result = (bool)(arg1)->ScrollLines(arg2);
36503 wxPyEndAllowThreads(__tstate);
36504 if (PyErr_Occurred()) SWIG_fail;
36505 }
36506 {
36507 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36508 }
36509 return resultobj;
36510 fail:
36511 return NULL;
36512 }
36513
36514
36515 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36516 PyObject *resultobj = 0;
36517 wxWindow *arg1 = (wxWindow *) 0 ;
36518 int arg2 ;
36519 bool result;
36520 void *argp1 = 0 ;
36521 int res1 = 0 ;
36522 int val2 ;
36523 int ecode2 = 0 ;
36524 PyObject * obj0 = 0 ;
36525 PyObject * obj1 = 0 ;
36526 char * kwnames[] = {
36527 (char *) "self",(char *) "pages", NULL
36528 };
36529
36530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
36531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36532 if (!SWIG_IsOK(res1)) {
36533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
36534 }
36535 arg1 = reinterpret_cast< wxWindow * >(argp1);
36536 ecode2 = SWIG_AsVal_int(obj1, &val2);
36537 if (!SWIG_IsOK(ecode2)) {
36538 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
36539 }
36540 arg2 = static_cast< int >(val2);
36541 {
36542 PyThreadState* __tstate = wxPyBeginAllowThreads();
36543 result = (bool)(arg1)->ScrollPages(arg2);
36544 wxPyEndAllowThreads(__tstate);
36545 if (PyErr_Occurred()) SWIG_fail;
36546 }
36547 {
36548 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36549 }
36550 return resultobj;
36551 fail:
36552 return NULL;
36553 }
36554
36555
36556 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36557 PyObject *resultobj = 0;
36558 wxWindow *arg1 = (wxWindow *) 0 ;
36559 bool result;
36560 void *argp1 = 0 ;
36561 int res1 = 0 ;
36562 PyObject *swig_obj[1] ;
36563
36564 if (!args) SWIG_fail;
36565 swig_obj[0] = args;
36566 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36567 if (!SWIG_IsOK(res1)) {
36568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36569 }
36570 arg1 = reinterpret_cast< wxWindow * >(argp1);
36571 {
36572 PyThreadState* __tstate = wxPyBeginAllowThreads();
36573 result = (bool)(arg1)->LineUp();
36574 wxPyEndAllowThreads(__tstate);
36575 if (PyErr_Occurred()) SWIG_fail;
36576 }
36577 {
36578 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36579 }
36580 return resultobj;
36581 fail:
36582 return NULL;
36583 }
36584
36585
36586 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36587 PyObject *resultobj = 0;
36588 wxWindow *arg1 = (wxWindow *) 0 ;
36589 bool result;
36590 void *argp1 = 0 ;
36591 int res1 = 0 ;
36592 PyObject *swig_obj[1] ;
36593
36594 if (!args) SWIG_fail;
36595 swig_obj[0] = args;
36596 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36597 if (!SWIG_IsOK(res1)) {
36598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36599 }
36600 arg1 = reinterpret_cast< wxWindow * >(argp1);
36601 {
36602 PyThreadState* __tstate = wxPyBeginAllowThreads();
36603 result = (bool)(arg1)->LineDown();
36604 wxPyEndAllowThreads(__tstate);
36605 if (PyErr_Occurred()) SWIG_fail;
36606 }
36607 {
36608 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36609 }
36610 return resultobj;
36611 fail:
36612 return NULL;
36613 }
36614
36615
36616 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36617 PyObject *resultobj = 0;
36618 wxWindow *arg1 = (wxWindow *) 0 ;
36619 bool result;
36620 void *argp1 = 0 ;
36621 int res1 = 0 ;
36622 PyObject *swig_obj[1] ;
36623
36624 if (!args) SWIG_fail;
36625 swig_obj[0] = args;
36626 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36627 if (!SWIG_IsOK(res1)) {
36628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36629 }
36630 arg1 = reinterpret_cast< wxWindow * >(argp1);
36631 {
36632 PyThreadState* __tstate = wxPyBeginAllowThreads();
36633 result = (bool)(arg1)->PageUp();
36634 wxPyEndAllowThreads(__tstate);
36635 if (PyErr_Occurred()) SWIG_fail;
36636 }
36637 {
36638 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36639 }
36640 return resultobj;
36641 fail:
36642 return NULL;
36643 }
36644
36645
36646 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36647 PyObject *resultobj = 0;
36648 wxWindow *arg1 = (wxWindow *) 0 ;
36649 bool result;
36650 void *argp1 = 0 ;
36651 int res1 = 0 ;
36652 PyObject *swig_obj[1] ;
36653
36654 if (!args) SWIG_fail;
36655 swig_obj[0] = args;
36656 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36657 if (!SWIG_IsOK(res1)) {
36658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36659 }
36660 arg1 = reinterpret_cast< wxWindow * >(argp1);
36661 {
36662 PyThreadState* __tstate = wxPyBeginAllowThreads();
36663 result = (bool)(arg1)->PageDown();
36664 wxPyEndAllowThreads(__tstate);
36665 if (PyErr_Occurred()) SWIG_fail;
36666 }
36667 {
36668 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36669 }
36670 return resultobj;
36671 fail:
36672 return NULL;
36673 }
36674
36675
36676 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36677 PyObject *resultobj = 0;
36678 wxWindow *arg1 = (wxWindow *) 0 ;
36679 wxString *arg2 = 0 ;
36680 void *argp1 = 0 ;
36681 int res1 = 0 ;
36682 bool temp2 = false ;
36683 PyObject * obj0 = 0 ;
36684 PyObject * obj1 = 0 ;
36685 char * kwnames[] = {
36686 (char *) "self",(char *) "text", NULL
36687 };
36688
36689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
36690 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36691 if (!SWIG_IsOK(res1)) {
36692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
36693 }
36694 arg1 = reinterpret_cast< wxWindow * >(argp1);
36695 {
36696 arg2 = wxString_in_helper(obj1);
36697 if (arg2 == NULL) SWIG_fail;
36698 temp2 = true;
36699 }
36700 {
36701 PyThreadState* __tstate = wxPyBeginAllowThreads();
36702 (arg1)->SetHelpText((wxString const &)*arg2);
36703 wxPyEndAllowThreads(__tstate);
36704 if (PyErr_Occurred()) SWIG_fail;
36705 }
36706 resultobj = SWIG_Py_Void();
36707 {
36708 if (temp2)
36709 delete arg2;
36710 }
36711 return resultobj;
36712 fail:
36713 {
36714 if (temp2)
36715 delete arg2;
36716 }
36717 return NULL;
36718 }
36719
36720
36721 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36722 PyObject *resultobj = 0;
36723 wxWindow *arg1 = (wxWindow *) 0 ;
36724 wxString *arg2 = 0 ;
36725 void *argp1 = 0 ;
36726 int res1 = 0 ;
36727 bool temp2 = false ;
36728 PyObject * obj0 = 0 ;
36729 PyObject * obj1 = 0 ;
36730 char * kwnames[] = {
36731 (char *) "self",(char *) "text", NULL
36732 };
36733
36734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
36735 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36736 if (!SWIG_IsOK(res1)) {
36737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
36738 }
36739 arg1 = reinterpret_cast< wxWindow * >(argp1);
36740 {
36741 arg2 = wxString_in_helper(obj1);
36742 if (arg2 == NULL) SWIG_fail;
36743 temp2 = true;
36744 }
36745 {
36746 PyThreadState* __tstate = wxPyBeginAllowThreads();
36747 (arg1)->SetHelpTextForId((wxString const &)*arg2);
36748 wxPyEndAllowThreads(__tstate);
36749 if (PyErr_Occurred()) SWIG_fail;
36750 }
36751 resultobj = SWIG_Py_Void();
36752 {
36753 if (temp2)
36754 delete arg2;
36755 }
36756 return resultobj;
36757 fail:
36758 {
36759 if (temp2)
36760 delete arg2;
36761 }
36762 return NULL;
36763 }
36764
36765
36766 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36767 PyObject *resultobj = 0;
36768 wxWindow *arg1 = (wxWindow *) 0 ;
36769 wxString result;
36770 void *argp1 = 0 ;
36771 int res1 = 0 ;
36772 PyObject *swig_obj[1] ;
36773
36774 if (!args) SWIG_fail;
36775 swig_obj[0] = args;
36776 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36777 if (!SWIG_IsOK(res1)) {
36778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
36779 }
36780 arg1 = reinterpret_cast< wxWindow * >(argp1);
36781 {
36782 PyThreadState* __tstate = wxPyBeginAllowThreads();
36783 result = ((wxWindow const *)arg1)->GetHelpText();
36784 wxPyEndAllowThreads(__tstate);
36785 if (PyErr_Occurred()) SWIG_fail;
36786 }
36787 {
36788 #if wxUSE_UNICODE
36789 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36790 #else
36791 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36792 #endif
36793 }
36794 return resultobj;
36795 fail:
36796 return NULL;
36797 }
36798
36799
36800 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36801 PyObject *resultobj = 0;
36802 wxWindow *arg1 = (wxWindow *) 0 ;
36803 wxString *arg2 = 0 ;
36804 void *argp1 = 0 ;
36805 int res1 = 0 ;
36806 bool temp2 = false ;
36807 PyObject * obj0 = 0 ;
36808 PyObject * obj1 = 0 ;
36809 char * kwnames[] = {
36810 (char *) "self",(char *) "tip", NULL
36811 };
36812
36813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
36814 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36815 if (!SWIG_IsOK(res1)) {
36816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
36817 }
36818 arg1 = reinterpret_cast< wxWindow * >(argp1);
36819 {
36820 arg2 = wxString_in_helper(obj1);
36821 if (arg2 == NULL) SWIG_fail;
36822 temp2 = true;
36823 }
36824 {
36825 PyThreadState* __tstate = wxPyBeginAllowThreads();
36826 (arg1)->SetToolTip((wxString const &)*arg2);
36827 wxPyEndAllowThreads(__tstate);
36828 if (PyErr_Occurred()) SWIG_fail;
36829 }
36830 resultobj = SWIG_Py_Void();
36831 {
36832 if (temp2)
36833 delete arg2;
36834 }
36835 return resultobj;
36836 fail:
36837 {
36838 if (temp2)
36839 delete arg2;
36840 }
36841 return NULL;
36842 }
36843
36844
36845 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36846 PyObject *resultobj = 0;
36847 wxWindow *arg1 = (wxWindow *) 0 ;
36848 wxToolTip *arg2 = (wxToolTip *) 0 ;
36849 void *argp1 = 0 ;
36850 int res1 = 0 ;
36851 int res2 = 0 ;
36852 PyObject * obj0 = 0 ;
36853 PyObject * obj1 = 0 ;
36854 char * kwnames[] = {
36855 (char *) "self",(char *) "tip", NULL
36856 };
36857
36858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
36859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36860 if (!SWIG_IsOK(res1)) {
36861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
36862 }
36863 arg1 = reinterpret_cast< wxWindow * >(argp1);
36864 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
36865 if (!SWIG_IsOK(res2)) {
36866 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
36867 }
36868 {
36869 PyThreadState* __tstate = wxPyBeginAllowThreads();
36870 (arg1)->SetToolTip(arg2);
36871 wxPyEndAllowThreads(__tstate);
36872 if (PyErr_Occurred()) SWIG_fail;
36873 }
36874 resultobj = SWIG_Py_Void();
36875 return resultobj;
36876 fail:
36877 return NULL;
36878 }
36879
36880
36881 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36882 PyObject *resultobj = 0;
36883 wxWindow *arg1 = (wxWindow *) 0 ;
36884 wxToolTip *result = 0 ;
36885 void *argp1 = 0 ;
36886 int res1 = 0 ;
36887 PyObject *swig_obj[1] ;
36888
36889 if (!args) SWIG_fail;
36890 swig_obj[0] = args;
36891 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36892 if (!SWIG_IsOK(res1)) {
36893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
36894 }
36895 arg1 = reinterpret_cast< wxWindow * >(argp1);
36896 {
36897 PyThreadState* __tstate = wxPyBeginAllowThreads();
36898 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
36899 wxPyEndAllowThreads(__tstate);
36900 if (PyErr_Occurred()) SWIG_fail;
36901 }
36902 {
36903 resultobj = wxPyMake_wxObject(result, (bool)0);
36904 }
36905 return resultobj;
36906 fail:
36907 return NULL;
36908 }
36909
36910
36911 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36912 PyObject *resultobj = 0;
36913 wxWindow *arg1 = (wxWindow *) 0 ;
36914 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
36915 void *argp1 = 0 ;
36916 int res1 = 0 ;
36917 int res2 = 0 ;
36918 PyObject * obj0 = 0 ;
36919 PyObject * obj1 = 0 ;
36920 char * kwnames[] = {
36921 (char *) "self",(char *) "dropTarget", NULL
36922 };
36923
36924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
36925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36926 if (!SWIG_IsOK(res1)) {
36927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
36928 }
36929 arg1 = reinterpret_cast< wxWindow * >(argp1);
36930 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
36931 if (!SWIG_IsOK(res2)) {
36932 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
36933 }
36934 {
36935 PyThreadState* __tstate = wxPyBeginAllowThreads();
36936 (arg1)->SetDropTarget(arg2);
36937 wxPyEndAllowThreads(__tstate);
36938 if (PyErr_Occurred()) SWIG_fail;
36939 }
36940 resultobj = SWIG_Py_Void();
36941 return resultobj;
36942 fail:
36943 return NULL;
36944 }
36945
36946
36947 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36948 PyObject *resultobj = 0;
36949 wxWindow *arg1 = (wxWindow *) 0 ;
36950 wxPyDropTarget *result = 0 ;
36951 void *argp1 = 0 ;
36952 int res1 = 0 ;
36953 PyObject *swig_obj[1] ;
36954
36955 if (!args) SWIG_fail;
36956 swig_obj[0] = args;
36957 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36958 if (!SWIG_IsOK(res1)) {
36959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
36960 }
36961 arg1 = reinterpret_cast< wxWindow * >(argp1);
36962 {
36963 PyThreadState* __tstate = wxPyBeginAllowThreads();
36964 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
36965 wxPyEndAllowThreads(__tstate);
36966 if (PyErr_Occurred()) SWIG_fail;
36967 }
36968 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
36969 return resultobj;
36970 fail:
36971 return NULL;
36972 }
36973
36974
36975 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36976 PyObject *resultobj = 0;
36977 wxWindow *arg1 = (wxWindow *) 0 ;
36978 bool arg2 ;
36979 void *argp1 = 0 ;
36980 int res1 = 0 ;
36981 bool val2 ;
36982 int ecode2 = 0 ;
36983 PyObject * obj0 = 0 ;
36984 PyObject * obj1 = 0 ;
36985 char * kwnames[] = {
36986 (char *) "self",(char *) "accept", NULL
36987 };
36988
36989 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
36990 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36991 if (!SWIG_IsOK(res1)) {
36992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
36993 }
36994 arg1 = reinterpret_cast< wxWindow * >(argp1);
36995 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36996 if (!SWIG_IsOK(ecode2)) {
36997 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
36998 }
36999 arg2 = static_cast< bool >(val2);
37000 {
37001 PyThreadState* __tstate = wxPyBeginAllowThreads();
37002 wxWindow_DragAcceptFiles(arg1,arg2);
37003 wxPyEndAllowThreads(__tstate);
37004 if (PyErr_Occurred()) SWIG_fail;
37005 }
37006 resultobj = SWIG_Py_Void();
37007 return resultobj;
37008 fail:
37009 return NULL;
37010 }
37011
37012
37013 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37014 PyObject *resultobj = 0;
37015 wxWindow *arg1 = (wxWindow *) 0 ;
37016 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
37017 void *argp1 = 0 ;
37018 int res1 = 0 ;
37019 int res2 = 0 ;
37020 PyObject * obj0 = 0 ;
37021 PyObject * obj1 = 0 ;
37022 char * kwnames[] = {
37023 (char *) "self",(char *) "constraints", NULL
37024 };
37025
37026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
37027 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37028 if (!SWIG_IsOK(res1)) {
37029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
37030 }
37031 arg1 = reinterpret_cast< wxWindow * >(argp1);
37032 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
37033 if (!SWIG_IsOK(res2)) {
37034 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
37035 }
37036 {
37037 PyThreadState* __tstate = wxPyBeginAllowThreads();
37038 (arg1)->SetConstraints(arg2);
37039 wxPyEndAllowThreads(__tstate);
37040 if (PyErr_Occurred()) SWIG_fail;
37041 }
37042 resultobj = SWIG_Py_Void();
37043 return resultobj;
37044 fail:
37045 return NULL;
37046 }
37047
37048
37049 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37050 PyObject *resultobj = 0;
37051 wxWindow *arg1 = (wxWindow *) 0 ;
37052 wxLayoutConstraints *result = 0 ;
37053 void *argp1 = 0 ;
37054 int res1 = 0 ;
37055 PyObject *swig_obj[1] ;
37056
37057 if (!args) SWIG_fail;
37058 swig_obj[0] = args;
37059 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37060 if (!SWIG_IsOK(res1)) {
37061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
37062 }
37063 arg1 = reinterpret_cast< wxWindow * >(argp1);
37064 {
37065 PyThreadState* __tstate = wxPyBeginAllowThreads();
37066 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
37067 wxPyEndAllowThreads(__tstate);
37068 if (PyErr_Occurred()) SWIG_fail;
37069 }
37070 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
37071 return resultobj;
37072 fail:
37073 return NULL;
37074 }
37075
37076
37077 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37078 PyObject *resultobj = 0;
37079 wxWindow *arg1 = (wxWindow *) 0 ;
37080 bool arg2 ;
37081 void *argp1 = 0 ;
37082 int res1 = 0 ;
37083 bool val2 ;
37084 int ecode2 = 0 ;
37085 PyObject * obj0 = 0 ;
37086 PyObject * obj1 = 0 ;
37087 char * kwnames[] = {
37088 (char *) "self",(char *) "autoLayout", NULL
37089 };
37090
37091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
37092 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37093 if (!SWIG_IsOK(res1)) {
37094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
37095 }
37096 arg1 = reinterpret_cast< wxWindow * >(argp1);
37097 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37098 if (!SWIG_IsOK(ecode2)) {
37099 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
37100 }
37101 arg2 = static_cast< bool >(val2);
37102 {
37103 PyThreadState* __tstate = wxPyBeginAllowThreads();
37104 (arg1)->SetAutoLayout(arg2);
37105 wxPyEndAllowThreads(__tstate);
37106 if (PyErr_Occurred()) SWIG_fail;
37107 }
37108 resultobj = SWIG_Py_Void();
37109 return resultobj;
37110 fail:
37111 return NULL;
37112 }
37113
37114
37115 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37116 PyObject *resultobj = 0;
37117 wxWindow *arg1 = (wxWindow *) 0 ;
37118 bool result;
37119 void *argp1 = 0 ;
37120 int res1 = 0 ;
37121 PyObject *swig_obj[1] ;
37122
37123 if (!args) SWIG_fail;
37124 swig_obj[0] = args;
37125 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37126 if (!SWIG_IsOK(res1)) {
37127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
37128 }
37129 arg1 = reinterpret_cast< wxWindow * >(argp1);
37130 {
37131 PyThreadState* __tstate = wxPyBeginAllowThreads();
37132 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
37133 wxPyEndAllowThreads(__tstate);
37134 if (PyErr_Occurred()) SWIG_fail;
37135 }
37136 {
37137 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37138 }
37139 return resultobj;
37140 fail:
37141 return NULL;
37142 }
37143
37144
37145 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37146 PyObject *resultobj = 0;
37147 wxWindow *arg1 = (wxWindow *) 0 ;
37148 bool result;
37149 void *argp1 = 0 ;
37150 int res1 = 0 ;
37151 PyObject *swig_obj[1] ;
37152
37153 if (!args) SWIG_fail;
37154 swig_obj[0] = args;
37155 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37156 if (!SWIG_IsOK(res1)) {
37157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
37158 }
37159 arg1 = reinterpret_cast< wxWindow * >(argp1);
37160 {
37161 PyThreadState* __tstate = wxPyBeginAllowThreads();
37162 result = (bool)(arg1)->Layout();
37163 wxPyEndAllowThreads(__tstate);
37164 if (PyErr_Occurred()) SWIG_fail;
37165 }
37166 {
37167 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37168 }
37169 return resultobj;
37170 fail:
37171 return NULL;
37172 }
37173
37174
37175 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37176 PyObject *resultobj = 0;
37177 wxWindow *arg1 = (wxWindow *) 0 ;
37178 wxSizer *arg2 = (wxSizer *) 0 ;
37179 bool arg3 = (bool) true ;
37180 void *argp1 = 0 ;
37181 int res1 = 0 ;
37182 int res2 = 0 ;
37183 bool val3 ;
37184 int ecode3 = 0 ;
37185 PyObject * obj0 = 0 ;
37186 PyObject * obj1 = 0 ;
37187 PyObject * obj2 = 0 ;
37188 char * kwnames[] = {
37189 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37190 };
37191
37192 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37193 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37194 if (!SWIG_IsOK(res1)) {
37195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37196 }
37197 arg1 = reinterpret_cast< wxWindow * >(argp1);
37198 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37199 if (!SWIG_IsOK(res2)) {
37200 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37201 }
37202 if (obj2) {
37203 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37204 if (!SWIG_IsOK(ecode3)) {
37205 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
37206 }
37207 arg3 = static_cast< bool >(val3);
37208 }
37209 {
37210 PyThreadState* __tstate = wxPyBeginAllowThreads();
37211 (arg1)->SetSizer(arg2,arg3);
37212 wxPyEndAllowThreads(__tstate);
37213 if (PyErr_Occurred()) SWIG_fail;
37214 }
37215 resultobj = SWIG_Py_Void();
37216 return resultobj;
37217 fail:
37218 return NULL;
37219 }
37220
37221
37222 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37223 PyObject *resultobj = 0;
37224 wxWindow *arg1 = (wxWindow *) 0 ;
37225 wxSizer *arg2 = (wxSizer *) 0 ;
37226 bool arg3 = (bool) true ;
37227 void *argp1 = 0 ;
37228 int res1 = 0 ;
37229 int res2 = 0 ;
37230 bool val3 ;
37231 int ecode3 = 0 ;
37232 PyObject * obj0 = 0 ;
37233 PyObject * obj1 = 0 ;
37234 PyObject * obj2 = 0 ;
37235 char * kwnames[] = {
37236 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37237 };
37238
37239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37240 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37241 if (!SWIG_IsOK(res1)) {
37242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
37243 }
37244 arg1 = reinterpret_cast< wxWindow * >(argp1);
37245 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37246 if (!SWIG_IsOK(res2)) {
37247 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
37248 }
37249 if (obj2) {
37250 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37251 if (!SWIG_IsOK(ecode3)) {
37252 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
37253 }
37254 arg3 = static_cast< bool >(val3);
37255 }
37256 {
37257 PyThreadState* __tstate = wxPyBeginAllowThreads();
37258 (arg1)->SetSizerAndFit(arg2,arg3);
37259 wxPyEndAllowThreads(__tstate);
37260 if (PyErr_Occurred()) SWIG_fail;
37261 }
37262 resultobj = SWIG_Py_Void();
37263 return resultobj;
37264 fail:
37265 return NULL;
37266 }
37267
37268
37269 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37270 PyObject *resultobj = 0;
37271 wxWindow *arg1 = (wxWindow *) 0 ;
37272 wxSizer *result = 0 ;
37273 void *argp1 = 0 ;
37274 int res1 = 0 ;
37275 PyObject *swig_obj[1] ;
37276
37277 if (!args) SWIG_fail;
37278 swig_obj[0] = args;
37279 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37280 if (!SWIG_IsOK(res1)) {
37281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37282 }
37283 arg1 = reinterpret_cast< wxWindow * >(argp1);
37284 {
37285 PyThreadState* __tstate = wxPyBeginAllowThreads();
37286 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
37287 wxPyEndAllowThreads(__tstate);
37288 if (PyErr_Occurred()) SWIG_fail;
37289 }
37290 {
37291 resultobj = wxPyMake_wxObject(result, (bool)0);
37292 }
37293 return resultobj;
37294 fail:
37295 return NULL;
37296 }
37297
37298
37299 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37300 PyObject *resultobj = 0;
37301 wxWindow *arg1 = (wxWindow *) 0 ;
37302 wxSizer *arg2 = (wxSizer *) 0 ;
37303 void *argp1 = 0 ;
37304 int res1 = 0 ;
37305 void *argp2 = 0 ;
37306 int res2 = 0 ;
37307 PyObject * obj0 = 0 ;
37308 PyObject * obj1 = 0 ;
37309 char * kwnames[] = {
37310 (char *) "self",(char *) "sizer", NULL
37311 };
37312
37313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
37314 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37315 if (!SWIG_IsOK(res1)) {
37316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37317 }
37318 arg1 = reinterpret_cast< wxWindow * >(argp1);
37319 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
37320 if (!SWIG_IsOK(res2)) {
37321 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37322 }
37323 arg2 = reinterpret_cast< wxSizer * >(argp2);
37324 {
37325 PyThreadState* __tstate = wxPyBeginAllowThreads();
37326 (arg1)->SetContainingSizer(arg2);
37327 wxPyEndAllowThreads(__tstate);
37328 if (PyErr_Occurred()) SWIG_fail;
37329 }
37330 resultobj = SWIG_Py_Void();
37331 return resultobj;
37332 fail:
37333 return NULL;
37334 }
37335
37336
37337 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37338 PyObject *resultobj = 0;
37339 wxWindow *arg1 = (wxWindow *) 0 ;
37340 wxSizer *result = 0 ;
37341 void *argp1 = 0 ;
37342 int res1 = 0 ;
37343 PyObject *swig_obj[1] ;
37344
37345 if (!args) SWIG_fail;
37346 swig_obj[0] = args;
37347 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37348 if (!SWIG_IsOK(res1)) {
37349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37350 }
37351 arg1 = reinterpret_cast< wxWindow * >(argp1);
37352 {
37353 PyThreadState* __tstate = wxPyBeginAllowThreads();
37354 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
37355 wxPyEndAllowThreads(__tstate);
37356 if (PyErr_Occurred()) SWIG_fail;
37357 }
37358 {
37359 resultobj = wxPyMake_wxObject(result, (bool)0);
37360 }
37361 return resultobj;
37362 fail:
37363 return NULL;
37364 }
37365
37366
37367 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37368 PyObject *resultobj = 0;
37369 wxWindow *arg1 = (wxWindow *) 0 ;
37370 void *argp1 = 0 ;
37371 int res1 = 0 ;
37372 PyObject *swig_obj[1] ;
37373
37374 if (!args) SWIG_fail;
37375 swig_obj[0] = args;
37376 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37377 if (!SWIG_IsOK(res1)) {
37378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
37379 }
37380 arg1 = reinterpret_cast< wxWindow * >(argp1);
37381 {
37382 PyThreadState* __tstate = wxPyBeginAllowThreads();
37383 (arg1)->InheritAttributes();
37384 wxPyEndAllowThreads(__tstate);
37385 if (PyErr_Occurred()) SWIG_fail;
37386 }
37387 resultobj = SWIG_Py_Void();
37388 return resultobj;
37389 fail:
37390 return NULL;
37391 }
37392
37393
37394 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37395 PyObject *resultobj = 0;
37396 wxWindow *arg1 = (wxWindow *) 0 ;
37397 bool result;
37398 void *argp1 = 0 ;
37399 int res1 = 0 ;
37400 PyObject *swig_obj[1] ;
37401
37402 if (!args) SWIG_fail;
37403 swig_obj[0] = args;
37404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37405 if (!SWIG_IsOK(res1)) {
37406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
37407 }
37408 arg1 = reinterpret_cast< wxWindow * >(argp1);
37409 {
37410 PyThreadState* __tstate = wxPyBeginAllowThreads();
37411 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
37412 wxPyEndAllowThreads(__tstate);
37413 if (PyErr_Occurred()) SWIG_fail;
37414 }
37415 {
37416 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37417 }
37418 return resultobj;
37419 fail:
37420 return NULL;
37421 }
37422
37423
37424 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37425 PyObject *obj;
37426 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37427 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
37428 return SWIG_Py_Void();
37429 }
37430
37431 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37432 return SWIG_Python_InitShadowInstance(args);
37433 }
37434
37435 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37436 PyObject *resultobj = 0;
37437 long arg1 ;
37438 wxWindow *arg2 = (wxWindow *) NULL ;
37439 wxWindow *result = 0 ;
37440 long val1 ;
37441 int ecode1 = 0 ;
37442 void *argp2 = 0 ;
37443 int res2 = 0 ;
37444 PyObject * obj0 = 0 ;
37445 PyObject * obj1 = 0 ;
37446 char * kwnames[] = {
37447 (char *) "id",(char *) "parent", NULL
37448 };
37449
37450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
37451 ecode1 = SWIG_AsVal_long(obj0, &val1);
37452 if (!SWIG_IsOK(ecode1)) {
37453 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
37454 }
37455 arg1 = static_cast< long >(val1);
37456 if (obj1) {
37457 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37458 if (!SWIG_IsOK(res2)) {
37459 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
37460 }
37461 arg2 = reinterpret_cast< wxWindow * >(argp2);
37462 }
37463 {
37464 if (!wxPyCheckForApp()) SWIG_fail;
37465 PyThreadState* __tstate = wxPyBeginAllowThreads();
37466 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
37467 wxPyEndAllowThreads(__tstate);
37468 if (PyErr_Occurred()) SWIG_fail;
37469 }
37470 {
37471 resultobj = wxPyMake_wxObject(result, 0);
37472 }
37473 return resultobj;
37474 fail:
37475 return NULL;
37476 }
37477
37478
37479 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37480 PyObject *resultobj = 0;
37481 wxString *arg1 = 0 ;
37482 wxWindow *arg2 = (wxWindow *) NULL ;
37483 wxWindow *result = 0 ;
37484 bool temp1 = false ;
37485 void *argp2 = 0 ;
37486 int res2 = 0 ;
37487 PyObject * obj0 = 0 ;
37488 PyObject * obj1 = 0 ;
37489 char * kwnames[] = {
37490 (char *) "name",(char *) "parent", NULL
37491 };
37492
37493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
37494 {
37495 arg1 = wxString_in_helper(obj0);
37496 if (arg1 == NULL) SWIG_fail;
37497 temp1 = true;
37498 }
37499 if (obj1) {
37500 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37501 if (!SWIG_IsOK(res2)) {
37502 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
37503 }
37504 arg2 = reinterpret_cast< wxWindow * >(argp2);
37505 }
37506 {
37507 if (!wxPyCheckForApp()) SWIG_fail;
37508 PyThreadState* __tstate = wxPyBeginAllowThreads();
37509 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
37510 wxPyEndAllowThreads(__tstate);
37511 if (PyErr_Occurred()) SWIG_fail;
37512 }
37513 {
37514 resultobj = wxPyMake_wxObject(result, 0);
37515 }
37516 {
37517 if (temp1)
37518 delete arg1;
37519 }
37520 return resultobj;
37521 fail:
37522 {
37523 if (temp1)
37524 delete arg1;
37525 }
37526 return NULL;
37527 }
37528
37529
37530 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37531 PyObject *resultobj = 0;
37532 wxString *arg1 = 0 ;
37533 wxWindow *arg2 = (wxWindow *) NULL ;
37534 wxWindow *result = 0 ;
37535 bool temp1 = false ;
37536 void *argp2 = 0 ;
37537 int res2 = 0 ;
37538 PyObject * obj0 = 0 ;
37539 PyObject * obj1 = 0 ;
37540 char * kwnames[] = {
37541 (char *) "label",(char *) "parent", NULL
37542 };
37543
37544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
37545 {
37546 arg1 = wxString_in_helper(obj0);
37547 if (arg1 == NULL) SWIG_fail;
37548 temp1 = true;
37549 }
37550 if (obj1) {
37551 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37552 if (!SWIG_IsOK(res2)) {
37553 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
37554 }
37555 arg2 = reinterpret_cast< wxWindow * >(argp2);
37556 }
37557 {
37558 if (!wxPyCheckForApp()) SWIG_fail;
37559 PyThreadState* __tstate = wxPyBeginAllowThreads();
37560 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
37561 wxPyEndAllowThreads(__tstate);
37562 if (PyErr_Occurred()) SWIG_fail;
37563 }
37564 {
37565 resultobj = wxPyMake_wxObject(result, 0);
37566 }
37567 {
37568 if (temp1)
37569 delete arg1;
37570 }
37571 return resultobj;
37572 fail:
37573 {
37574 if (temp1)
37575 delete arg1;
37576 }
37577 return NULL;
37578 }
37579
37580
37581 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37582 PyObject *resultobj = 0;
37583 wxWindow *arg1 = (wxWindow *) 0 ;
37584 unsigned long arg2 ;
37585 wxWindow *result = 0 ;
37586 void *argp1 = 0 ;
37587 int res1 = 0 ;
37588 unsigned long val2 ;
37589 int ecode2 = 0 ;
37590 PyObject * obj0 = 0 ;
37591 PyObject * obj1 = 0 ;
37592 char * kwnames[] = {
37593 (char *) "parent",(char *) "_hWnd", NULL
37594 };
37595
37596 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
37597 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37598 if (!SWIG_IsOK(res1)) {
37599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
37600 }
37601 arg1 = reinterpret_cast< wxWindow * >(argp1);
37602 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
37603 if (!SWIG_IsOK(ecode2)) {
37604 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
37605 }
37606 arg2 = static_cast< unsigned long >(val2);
37607 {
37608 PyThreadState* __tstate = wxPyBeginAllowThreads();
37609 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
37610 wxPyEndAllowThreads(__tstate);
37611 if (PyErr_Occurred()) SWIG_fail;
37612 }
37613 {
37614 resultobj = wxPyMake_wxObject(result, 0);
37615 }
37616 return resultobj;
37617 fail:
37618 return NULL;
37619 }
37620
37621
37622 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37623 PyObject *resultobj = 0;
37624 PyObject *result = 0 ;
37625
37626 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
37627 {
37628 PyThreadState* __tstate = wxPyBeginAllowThreads();
37629 result = (PyObject *)GetTopLevelWindows();
37630 wxPyEndAllowThreads(__tstate);
37631 if (PyErr_Occurred()) SWIG_fail;
37632 }
37633 resultobj = result;
37634 return resultobj;
37635 fail:
37636 return NULL;
37637 }
37638
37639
37640 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37641 PyObject *resultobj = 0;
37642 wxValidator *result = 0 ;
37643
37644 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
37645 {
37646 PyThreadState* __tstate = wxPyBeginAllowThreads();
37647 result = (wxValidator *)new wxValidator();
37648 wxPyEndAllowThreads(__tstate);
37649 if (PyErr_Occurred()) SWIG_fail;
37650 }
37651 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
37652 return resultobj;
37653 fail:
37654 return NULL;
37655 }
37656
37657
37658 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37659 PyObject *resultobj = 0;
37660 wxValidator *arg1 = (wxValidator *) 0 ;
37661 wxValidator *result = 0 ;
37662 void *argp1 = 0 ;
37663 int res1 = 0 ;
37664 PyObject *swig_obj[1] ;
37665
37666 if (!args) SWIG_fail;
37667 swig_obj[0] = args;
37668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37669 if (!SWIG_IsOK(res1)) {
37670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
37671 }
37672 arg1 = reinterpret_cast< wxValidator * >(argp1);
37673 {
37674 PyThreadState* __tstate = wxPyBeginAllowThreads();
37675 result = (wxValidator *)(arg1)->Clone();
37676 wxPyEndAllowThreads(__tstate);
37677 if (PyErr_Occurred()) SWIG_fail;
37678 }
37679 {
37680 resultobj = wxPyMake_wxObject(result, 0);
37681 }
37682 return resultobj;
37683 fail:
37684 return NULL;
37685 }
37686
37687
37688 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37689 PyObject *resultobj = 0;
37690 wxValidator *arg1 = (wxValidator *) 0 ;
37691 wxWindow *arg2 = (wxWindow *) 0 ;
37692 bool result;
37693 void *argp1 = 0 ;
37694 int res1 = 0 ;
37695 void *argp2 = 0 ;
37696 int res2 = 0 ;
37697 PyObject * obj0 = 0 ;
37698 PyObject * obj1 = 0 ;
37699 char * kwnames[] = {
37700 (char *) "self",(char *) "parent", NULL
37701 };
37702
37703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
37704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37705 if (!SWIG_IsOK(res1)) {
37706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
37707 }
37708 arg1 = reinterpret_cast< wxValidator * >(argp1);
37709 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37710 if (!SWIG_IsOK(res2)) {
37711 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
37712 }
37713 arg2 = reinterpret_cast< wxWindow * >(argp2);
37714 {
37715 PyThreadState* __tstate = wxPyBeginAllowThreads();
37716 result = (bool)(arg1)->Validate(arg2);
37717 wxPyEndAllowThreads(__tstate);
37718 if (PyErr_Occurred()) SWIG_fail;
37719 }
37720 {
37721 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37722 }
37723 return resultobj;
37724 fail:
37725 return NULL;
37726 }
37727
37728
37729 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37730 PyObject *resultobj = 0;
37731 wxValidator *arg1 = (wxValidator *) 0 ;
37732 bool result;
37733 void *argp1 = 0 ;
37734 int res1 = 0 ;
37735 PyObject *swig_obj[1] ;
37736
37737 if (!args) SWIG_fail;
37738 swig_obj[0] = args;
37739 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37740 if (!SWIG_IsOK(res1)) {
37741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37742 }
37743 arg1 = reinterpret_cast< wxValidator * >(argp1);
37744 {
37745 PyThreadState* __tstate = wxPyBeginAllowThreads();
37746 result = (bool)(arg1)->TransferToWindow();
37747 wxPyEndAllowThreads(__tstate);
37748 if (PyErr_Occurred()) SWIG_fail;
37749 }
37750 {
37751 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37752 }
37753 return resultobj;
37754 fail:
37755 return NULL;
37756 }
37757
37758
37759 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37760 PyObject *resultobj = 0;
37761 wxValidator *arg1 = (wxValidator *) 0 ;
37762 bool result;
37763 void *argp1 = 0 ;
37764 int res1 = 0 ;
37765 PyObject *swig_obj[1] ;
37766
37767 if (!args) SWIG_fail;
37768 swig_obj[0] = args;
37769 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37770 if (!SWIG_IsOK(res1)) {
37771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37772 }
37773 arg1 = reinterpret_cast< wxValidator * >(argp1);
37774 {
37775 PyThreadState* __tstate = wxPyBeginAllowThreads();
37776 result = (bool)(arg1)->TransferFromWindow();
37777 wxPyEndAllowThreads(__tstate);
37778 if (PyErr_Occurred()) SWIG_fail;
37779 }
37780 {
37781 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37782 }
37783 return resultobj;
37784 fail:
37785 return NULL;
37786 }
37787
37788
37789 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37790 PyObject *resultobj = 0;
37791 wxValidator *arg1 = (wxValidator *) 0 ;
37792 wxWindow *result = 0 ;
37793 void *argp1 = 0 ;
37794 int res1 = 0 ;
37795 PyObject *swig_obj[1] ;
37796
37797 if (!args) SWIG_fail;
37798 swig_obj[0] = args;
37799 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37800 if (!SWIG_IsOK(res1)) {
37801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37802 }
37803 arg1 = reinterpret_cast< wxValidator * >(argp1);
37804 {
37805 PyThreadState* __tstate = wxPyBeginAllowThreads();
37806 result = (wxWindow *)(arg1)->GetWindow();
37807 wxPyEndAllowThreads(__tstate);
37808 if (PyErr_Occurred()) SWIG_fail;
37809 }
37810 {
37811 resultobj = wxPyMake_wxObject(result, 0);
37812 }
37813 return resultobj;
37814 fail:
37815 return NULL;
37816 }
37817
37818
37819 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37820 PyObject *resultobj = 0;
37821 wxValidator *arg1 = (wxValidator *) 0 ;
37822 wxWindow *arg2 = (wxWindow *) 0 ;
37823 void *argp1 = 0 ;
37824 int res1 = 0 ;
37825 void *argp2 = 0 ;
37826 int res2 = 0 ;
37827 PyObject * obj0 = 0 ;
37828 PyObject * obj1 = 0 ;
37829 char * kwnames[] = {
37830 (char *) "self",(char *) "window", NULL
37831 };
37832
37833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
37834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37835 if (!SWIG_IsOK(res1)) {
37836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37837 }
37838 arg1 = reinterpret_cast< wxValidator * >(argp1);
37839 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37840 if (!SWIG_IsOK(res2)) {
37841 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
37842 }
37843 arg2 = reinterpret_cast< wxWindow * >(argp2);
37844 {
37845 PyThreadState* __tstate = wxPyBeginAllowThreads();
37846 (arg1)->SetWindow(arg2);
37847 wxPyEndAllowThreads(__tstate);
37848 if (PyErr_Occurred()) SWIG_fail;
37849 }
37850 resultobj = SWIG_Py_Void();
37851 return resultobj;
37852 fail:
37853 return NULL;
37854 }
37855
37856
37857 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37858 PyObject *resultobj = 0;
37859 bool result;
37860
37861 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
37862 {
37863 PyThreadState* __tstate = wxPyBeginAllowThreads();
37864 result = (bool)wxValidator::IsSilent();
37865 wxPyEndAllowThreads(__tstate);
37866 if (PyErr_Occurred()) SWIG_fail;
37867 }
37868 {
37869 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37870 }
37871 return resultobj;
37872 fail:
37873 return NULL;
37874 }
37875
37876
37877 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37878 PyObject *resultobj = 0;
37879 int arg1 = (int) true ;
37880 int val1 ;
37881 int ecode1 = 0 ;
37882 PyObject * obj0 = 0 ;
37883 char * kwnames[] = {
37884 (char *) "doIt", NULL
37885 };
37886
37887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
37888 if (obj0) {
37889 ecode1 = SWIG_AsVal_int(obj0, &val1);
37890 if (!SWIG_IsOK(ecode1)) {
37891 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
37892 }
37893 arg1 = static_cast< int >(val1);
37894 }
37895 {
37896 PyThreadState* __tstate = wxPyBeginAllowThreads();
37897 wxValidator::SetBellOnError(arg1);
37898 wxPyEndAllowThreads(__tstate);
37899 if (PyErr_Occurred()) SWIG_fail;
37900 }
37901 resultobj = SWIG_Py_Void();
37902 return resultobj;
37903 fail:
37904 return NULL;
37905 }
37906
37907
37908 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37909 PyObject *obj;
37910 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37911 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
37912 return SWIG_Py_Void();
37913 }
37914
37915 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37916 return SWIG_Python_InitShadowInstance(args);
37917 }
37918
37919 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37920 PyObject *resultobj = 0;
37921 wxPyValidator *result = 0 ;
37922
37923 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
37924 {
37925 PyThreadState* __tstate = wxPyBeginAllowThreads();
37926 result = (wxPyValidator *)new wxPyValidator();
37927 wxPyEndAllowThreads(__tstate);
37928 if (PyErr_Occurred()) SWIG_fail;
37929 }
37930 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
37931 return resultobj;
37932 fail:
37933 return NULL;
37934 }
37935
37936
37937 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37938 PyObject *resultobj = 0;
37939 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
37940 PyObject *arg2 = (PyObject *) 0 ;
37941 PyObject *arg3 = (PyObject *) 0 ;
37942 int arg4 = (int) true ;
37943 void *argp1 = 0 ;
37944 int res1 = 0 ;
37945 int val4 ;
37946 int ecode4 = 0 ;
37947 PyObject * obj0 = 0 ;
37948 PyObject * obj1 = 0 ;
37949 PyObject * obj2 = 0 ;
37950 PyObject * obj3 = 0 ;
37951 char * kwnames[] = {
37952 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
37953 };
37954
37955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
37957 if (!SWIG_IsOK(res1)) {
37958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
37959 }
37960 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
37961 arg2 = obj1;
37962 arg3 = obj2;
37963 if (obj3) {
37964 ecode4 = SWIG_AsVal_int(obj3, &val4);
37965 if (!SWIG_IsOK(ecode4)) {
37966 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
37967 }
37968 arg4 = static_cast< int >(val4);
37969 }
37970 {
37971 PyThreadState* __tstate = wxPyBeginAllowThreads();
37972 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
37973 wxPyEndAllowThreads(__tstate);
37974 if (PyErr_Occurred()) SWIG_fail;
37975 }
37976 resultobj = SWIG_Py_Void();
37977 return resultobj;
37978 fail:
37979 return NULL;
37980 }
37981
37982
37983 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37984 PyObject *obj;
37985 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37986 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
37987 return SWIG_Py_Void();
37988 }
37989
37990 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37991 return SWIG_Python_InitShadowInstance(args);
37992 }
37993
37994 SWIGINTERN int DefaultValidator_set(PyObject *) {
37995 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
37996 return 1;
37997 }
37998
37999
38000 SWIGINTERN PyObject *DefaultValidator_get(void) {
38001 PyObject *pyobj = 0;
38002
38003 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
38004 return pyobj;
38005 }
38006
38007
38008 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38009 PyObject *resultobj = 0;
38010 wxString const &arg1_defvalue = wxPyEmptyString ;
38011 wxString *arg1 = (wxString *) &arg1_defvalue ;
38012 long arg2 = (long) 0 ;
38013 wxMenu *result = 0 ;
38014 bool temp1 = false ;
38015 long val2 ;
38016 int ecode2 = 0 ;
38017 PyObject * obj0 = 0 ;
38018 PyObject * obj1 = 0 ;
38019 char * kwnames[] = {
38020 (char *) "title",(char *) "style", NULL
38021 };
38022
38023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
38024 if (obj0) {
38025 {
38026 arg1 = wxString_in_helper(obj0);
38027 if (arg1 == NULL) SWIG_fail;
38028 temp1 = true;
38029 }
38030 }
38031 if (obj1) {
38032 ecode2 = SWIG_AsVal_long(obj1, &val2);
38033 if (!SWIG_IsOK(ecode2)) {
38034 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
38035 }
38036 arg2 = static_cast< long >(val2);
38037 }
38038 {
38039 if (!wxPyCheckForApp()) SWIG_fail;
38040 PyThreadState* __tstate = wxPyBeginAllowThreads();
38041 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
38042 wxPyEndAllowThreads(__tstate);
38043 if (PyErr_Occurred()) SWIG_fail;
38044 }
38045 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
38046 {
38047 if (temp1)
38048 delete arg1;
38049 }
38050 return resultobj;
38051 fail:
38052 {
38053 if (temp1)
38054 delete arg1;
38055 }
38056 return NULL;
38057 }
38058
38059
38060 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38061 PyObject *resultobj = 0;
38062 wxMenu *arg1 = (wxMenu *) 0 ;
38063 int arg2 ;
38064 wxString *arg3 = 0 ;
38065 wxString const &arg4_defvalue = wxPyEmptyString ;
38066 wxString *arg4 = (wxString *) &arg4_defvalue ;
38067 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
38068 wxMenuItem *result = 0 ;
38069 void *argp1 = 0 ;
38070 int res1 = 0 ;
38071 int val2 ;
38072 int ecode2 = 0 ;
38073 bool temp3 = false ;
38074 bool temp4 = false ;
38075 int val5 ;
38076 int ecode5 = 0 ;
38077 PyObject * obj0 = 0 ;
38078 PyObject * obj1 = 0 ;
38079 PyObject * obj2 = 0 ;
38080 PyObject * obj3 = 0 ;
38081 PyObject * obj4 = 0 ;
38082 char * kwnames[] = {
38083 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38084 };
38085
38086 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38087 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38088 if (!SWIG_IsOK(res1)) {
38089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
38090 }
38091 arg1 = reinterpret_cast< wxMenu * >(argp1);
38092 ecode2 = SWIG_AsVal_int(obj1, &val2);
38093 if (!SWIG_IsOK(ecode2)) {
38094 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
38095 }
38096 arg2 = static_cast< int >(val2);
38097 {
38098 arg3 = wxString_in_helper(obj2);
38099 if (arg3 == NULL) SWIG_fail;
38100 temp3 = true;
38101 }
38102 if (obj3) {
38103 {
38104 arg4 = wxString_in_helper(obj3);
38105 if (arg4 == NULL) SWIG_fail;
38106 temp4 = true;
38107 }
38108 }
38109 if (obj4) {
38110 ecode5 = SWIG_AsVal_int(obj4, &val5);
38111 if (!SWIG_IsOK(ecode5)) {
38112 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
38113 }
38114 arg5 = static_cast< wxItemKind >(val5);
38115 }
38116 {
38117 PyThreadState* __tstate = wxPyBeginAllowThreads();
38118 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
38119 wxPyEndAllowThreads(__tstate);
38120 if (PyErr_Occurred()) SWIG_fail;
38121 }
38122 {
38123 resultobj = wxPyMake_wxObject(result, (bool)0);
38124 }
38125 {
38126 if (temp3)
38127 delete arg3;
38128 }
38129 {
38130 if (temp4)
38131 delete arg4;
38132 }
38133 return resultobj;
38134 fail:
38135 {
38136 if (temp3)
38137 delete arg3;
38138 }
38139 {
38140 if (temp4)
38141 delete arg4;
38142 }
38143 return NULL;
38144 }
38145
38146
38147 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38148 PyObject *resultobj = 0;
38149 wxMenu *arg1 = (wxMenu *) 0 ;
38150 wxMenuItem *result = 0 ;
38151 void *argp1 = 0 ;
38152 int res1 = 0 ;
38153 PyObject *swig_obj[1] ;
38154
38155 if (!args) SWIG_fail;
38156 swig_obj[0] = args;
38157 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38158 if (!SWIG_IsOK(res1)) {
38159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
38160 }
38161 arg1 = reinterpret_cast< wxMenu * >(argp1);
38162 {
38163 PyThreadState* __tstate = wxPyBeginAllowThreads();
38164 result = (wxMenuItem *)(arg1)->AppendSeparator();
38165 wxPyEndAllowThreads(__tstate);
38166 if (PyErr_Occurred()) SWIG_fail;
38167 }
38168 {
38169 resultobj = wxPyMake_wxObject(result, (bool)0);
38170 }
38171 return resultobj;
38172 fail:
38173 return NULL;
38174 }
38175
38176
38177 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38178 PyObject *resultobj = 0;
38179 wxMenu *arg1 = (wxMenu *) 0 ;
38180 int arg2 ;
38181 wxString *arg3 = 0 ;
38182 wxString const &arg4_defvalue = wxPyEmptyString ;
38183 wxString *arg4 = (wxString *) &arg4_defvalue ;
38184 wxMenuItem *result = 0 ;
38185 void *argp1 = 0 ;
38186 int res1 = 0 ;
38187 int val2 ;
38188 int ecode2 = 0 ;
38189 bool temp3 = false ;
38190 bool temp4 = false ;
38191 PyObject * obj0 = 0 ;
38192 PyObject * obj1 = 0 ;
38193 PyObject * obj2 = 0 ;
38194 PyObject * obj3 = 0 ;
38195 char * kwnames[] = {
38196 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38197 };
38198
38199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38200 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38201 if (!SWIG_IsOK(res1)) {
38202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38203 }
38204 arg1 = reinterpret_cast< wxMenu * >(argp1);
38205 ecode2 = SWIG_AsVal_int(obj1, &val2);
38206 if (!SWIG_IsOK(ecode2)) {
38207 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
38208 }
38209 arg2 = static_cast< int >(val2);
38210 {
38211 arg3 = wxString_in_helper(obj2);
38212 if (arg3 == NULL) SWIG_fail;
38213 temp3 = true;
38214 }
38215 if (obj3) {
38216 {
38217 arg4 = wxString_in_helper(obj3);
38218 if (arg4 == NULL) SWIG_fail;
38219 temp4 = true;
38220 }
38221 }
38222 {
38223 PyThreadState* __tstate = wxPyBeginAllowThreads();
38224 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38225 wxPyEndAllowThreads(__tstate);
38226 if (PyErr_Occurred()) SWIG_fail;
38227 }
38228 {
38229 resultobj = wxPyMake_wxObject(result, (bool)0);
38230 }
38231 {
38232 if (temp3)
38233 delete arg3;
38234 }
38235 {
38236 if (temp4)
38237 delete arg4;
38238 }
38239 return resultobj;
38240 fail:
38241 {
38242 if (temp3)
38243 delete arg3;
38244 }
38245 {
38246 if (temp4)
38247 delete arg4;
38248 }
38249 return NULL;
38250 }
38251
38252
38253 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38254 PyObject *resultobj = 0;
38255 wxMenu *arg1 = (wxMenu *) 0 ;
38256 int arg2 ;
38257 wxString *arg3 = 0 ;
38258 wxString const &arg4_defvalue = wxPyEmptyString ;
38259 wxString *arg4 = (wxString *) &arg4_defvalue ;
38260 wxMenuItem *result = 0 ;
38261 void *argp1 = 0 ;
38262 int res1 = 0 ;
38263 int val2 ;
38264 int ecode2 = 0 ;
38265 bool temp3 = false ;
38266 bool temp4 = false ;
38267 PyObject * obj0 = 0 ;
38268 PyObject * obj1 = 0 ;
38269 PyObject * obj2 = 0 ;
38270 PyObject * obj3 = 0 ;
38271 char * kwnames[] = {
38272 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38273 };
38274
38275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38276 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38277 if (!SWIG_IsOK(res1)) {
38278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38279 }
38280 arg1 = reinterpret_cast< wxMenu * >(argp1);
38281 ecode2 = SWIG_AsVal_int(obj1, &val2);
38282 if (!SWIG_IsOK(ecode2)) {
38283 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
38284 }
38285 arg2 = static_cast< int >(val2);
38286 {
38287 arg3 = wxString_in_helper(obj2);
38288 if (arg3 == NULL) SWIG_fail;
38289 temp3 = true;
38290 }
38291 if (obj3) {
38292 {
38293 arg4 = wxString_in_helper(obj3);
38294 if (arg4 == NULL) SWIG_fail;
38295 temp4 = true;
38296 }
38297 }
38298 {
38299 PyThreadState* __tstate = wxPyBeginAllowThreads();
38300 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38301 wxPyEndAllowThreads(__tstate);
38302 if (PyErr_Occurred()) SWIG_fail;
38303 }
38304 {
38305 resultobj = wxPyMake_wxObject(result, (bool)0);
38306 }
38307 {
38308 if (temp3)
38309 delete arg3;
38310 }
38311 {
38312 if (temp4)
38313 delete arg4;
38314 }
38315 return resultobj;
38316 fail:
38317 {
38318 if (temp3)
38319 delete arg3;
38320 }
38321 {
38322 if (temp4)
38323 delete arg4;
38324 }
38325 return NULL;
38326 }
38327
38328
38329 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38330 PyObject *resultobj = 0;
38331 wxMenu *arg1 = (wxMenu *) 0 ;
38332 int arg2 ;
38333 wxString *arg3 = 0 ;
38334 wxMenu *arg4 = (wxMenu *) 0 ;
38335 wxString const &arg5_defvalue = wxPyEmptyString ;
38336 wxString *arg5 = (wxString *) &arg5_defvalue ;
38337 wxMenuItem *result = 0 ;
38338 void *argp1 = 0 ;
38339 int res1 = 0 ;
38340 int val2 ;
38341 int ecode2 = 0 ;
38342 bool temp3 = false ;
38343 void *argp4 = 0 ;
38344 int res4 = 0 ;
38345 bool temp5 = false ;
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 *) "submenu",(char *) "help", NULL
38353 };
38354
38355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",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_AppendMenu" "', 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_AppendMenu" "', 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 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
38372 if (!SWIG_IsOK(res4)) {
38373 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
38374 }
38375 arg4 = reinterpret_cast< wxMenu * >(argp4);
38376 if (obj4) {
38377 {
38378 arg5 = wxString_in_helper(obj4);
38379 if (arg5 == NULL) SWIG_fail;
38380 temp5 = true;
38381 }
38382 }
38383 {
38384 PyThreadState* __tstate = wxPyBeginAllowThreads();
38385 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
38386 wxPyEndAllowThreads(__tstate);
38387 if (PyErr_Occurred()) SWIG_fail;
38388 }
38389 {
38390 resultobj = wxPyMake_wxObject(result, (bool)0);
38391 }
38392 {
38393 if (temp3)
38394 delete arg3;
38395 }
38396 {
38397 if (temp5)
38398 delete arg5;
38399 }
38400 return resultobj;
38401 fail:
38402 {
38403 if (temp3)
38404 delete arg3;
38405 }
38406 {
38407 if (temp5)
38408 delete arg5;
38409 }
38410 return NULL;
38411 }
38412
38413
38414 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38415 PyObject *resultobj = 0;
38416 wxMenu *arg1 = (wxMenu *) 0 ;
38417 wxMenu *arg2 = (wxMenu *) 0 ;
38418 wxString *arg3 = 0 ;
38419 wxString const &arg4_defvalue = wxPyEmptyString ;
38420 wxString *arg4 = (wxString *) &arg4_defvalue ;
38421 wxMenuItem *result = 0 ;
38422 void *argp1 = 0 ;
38423 int res1 = 0 ;
38424 void *argp2 = 0 ;
38425 int res2 = 0 ;
38426 bool temp3 = false ;
38427 bool temp4 = false ;
38428 PyObject * obj0 = 0 ;
38429 PyObject * obj1 = 0 ;
38430 PyObject * obj2 = 0 ;
38431 PyObject * obj3 = 0 ;
38432 char * kwnames[] = {
38433 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
38434 };
38435
38436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38437 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38438 if (!SWIG_IsOK(res1)) {
38439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38440 }
38441 arg1 = reinterpret_cast< wxMenu * >(argp1);
38442 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
38443 if (!SWIG_IsOK(res2)) {
38444 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
38445 }
38446 arg2 = reinterpret_cast< wxMenu * >(argp2);
38447 {
38448 arg3 = wxString_in_helper(obj2);
38449 if (arg3 == NULL) SWIG_fail;
38450 temp3 = true;
38451 }
38452 if (obj3) {
38453 {
38454 arg4 = wxString_in_helper(obj3);
38455 if (arg4 == NULL) SWIG_fail;
38456 temp4 = true;
38457 }
38458 }
38459 {
38460 PyThreadState* __tstate = wxPyBeginAllowThreads();
38461 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38462 wxPyEndAllowThreads(__tstate);
38463 if (PyErr_Occurred()) SWIG_fail;
38464 }
38465 {
38466 resultobj = wxPyMake_wxObject(result, (bool)0);
38467 }
38468 {
38469 if (temp3)
38470 delete arg3;
38471 }
38472 {
38473 if (temp4)
38474 delete arg4;
38475 }
38476 return resultobj;
38477 fail:
38478 {
38479 if (temp3)
38480 delete arg3;
38481 }
38482 {
38483 if (temp4)
38484 delete arg4;
38485 }
38486 return NULL;
38487 }
38488
38489
38490 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38491 PyObject *resultobj = 0;
38492 wxMenu *arg1 = (wxMenu *) 0 ;
38493 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38494 wxMenuItem *result = 0 ;
38495 void *argp1 = 0 ;
38496 int res1 = 0 ;
38497 int res2 = 0 ;
38498 PyObject * obj0 = 0 ;
38499 PyObject * obj1 = 0 ;
38500 char * kwnames[] = {
38501 (char *) "self",(char *) "item", NULL
38502 };
38503
38504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
38505 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38506 if (!SWIG_IsOK(res1)) {
38507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38508 }
38509 arg1 = reinterpret_cast< wxMenu * >(argp1);
38510 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38511 if (!SWIG_IsOK(res2)) {
38512 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
38513 }
38514 {
38515 PyThreadState* __tstate = wxPyBeginAllowThreads();
38516 result = (wxMenuItem *)(arg1)->Append(arg2);
38517 wxPyEndAllowThreads(__tstate);
38518 if (PyErr_Occurred()) SWIG_fail;
38519 }
38520 {
38521 resultobj = wxPyMake_wxObject(result, (bool)0);
38522 }
38523 return resultobj;
38524 fail:
38525 return NULL;
38526 }
38527
38528
38529 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38530 PyObject *resultobj = 0;
38531 wxMenu *arg1 = (wxMenu *) 0 ;
38532 size_t arg2 ;
38533 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
38534 wxMenuItem *result = 0 ;
38535 void *argp1 = 0 ;
38536 int res1 = 0 ;
38537 size_t val2 ;
38538 int ecode2 = 0 ;
38539 int res3 = 0 ;
38540 PyObject * obj0 = 0 ;
38541 PyObject * obj1 = 0 ;
38542 PyObject * obj2 = 0 ;
38543 char * kwnames[] = {
38544 (char *) "self",(char *) "pos",(char *) "item", NULL
38545 };
38546
38547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38548 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38549 if (!SWIG_IsOK(res1)) {
38550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38551 }
38552 arg1 = reinterpret_cast< wxMenu * >(argp1);
38553 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38554 if (!SWIG_IsOK(ecode2)) {
38555 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
38556 }
38557 arg2 = static_cast< size_t >(val2);
38558 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38559 if (!SWIG_IsOK(res3)) {
38560 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
38561 }
38562 {
38563 PyThreadState* __tstate = wxPyBeginAllowThreads();
38564 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
38565 wxPyEndAllowThreads(__tstate);
38566 if (PyErr_Occurred()) SWIG_fail;
38567 }
38568 {
38569 resultobj = wxPyMake_wxObject(result, (bool)0);
38570 }
38571 return resultobj;
38572 fail:
38573 return NULL;
38574 }
38575
38576
38577 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38578 PyObject *resultobj = 0;
38579 wxMenu *arg1 = (wxMenu *) 0 ;
38580 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38581 wxMenuItem *result = 0 ;
38582 void *argp1 = 0 ;
38583 int res1 = 0 ;
38584 int res2 = 0 ;
38585 PyObject * obj0 = 0 ;
38586 PyObject * obj1 = 0 ;
38587 char * kwnames[] = {
38588 (char *) "self",(char *) "item", NULL
38589 };
38590
38591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
38592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38593 if (!SWIG_IsOK(res1)) {
38594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38595 }
38596 arg1 = reinterpret_cast< wxMenu * >(argp1);
38597 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38598 if (!SWIG_IsOK(res2)) {
38599 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
38600 }
38601 {
38602 PyThreadState* __tstate = wxPyBeginAllowThreads();
38603 result = (wxMenuItem *)(arg1)->Prepend(arg2);
38604 wxPyEndAllowThreads(__tstate);
38605 if (PyErr_Occurred()) SWIG_fail;
38606 }
38607 {
38608 resultobj = wxPyMake_wxObject(result, (bool)0);
38609 }
38610 return resultobj;
38611 fail:
38612 return NULL;
38613 }
38614
38615
38616 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38617 PyObject *resultobj = 0;
38618 wxMenu *arg1 = (wxMenu *) 0 ;
38619 void *argp1 = 0 ;
38620 int res1 = 0 ;
38621 PyObject *swig_obj[1] ;
38622
38623 if (!args) SWIG_fail;
38624 swig_obj[0] = args;
38625 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38626 if (!SWIG_IsOK(res1)) {
38627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
38628 }
38629 arg1 = reinterpret_cast< wxMenu * >(argp1);
38630 {
38631 PyThreadState* __tstate = wxPyBeginAllowThreads();
38632 (arg1)->Break();
38633 wxPyEndAllowThreads(__tstate);
38634 if (PyErr_Occurred()) SWIG_fail;
38635 }
38636 resultobj = SWIG_Py_Void();
38637 return resultobj;
38638 fail:
38639 return NULL;
38640 }
38641
38642
38643 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38644 PyObject *resultobj = 0;
38645 wxMenu *arg1 = (wxMenu *) 0 ;
38646 size_t arg2 ;
38647 int arg3 ;
38648 wxString *arg4 = 0 ;
38649 wxString const &arg5_defvalue = wxPyEmptyString ;
38650 wxString *arg5 = (wxString *) &arg5_defvalue ;
38651 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
38652 wxMenuItem *result = 0 ;
38653 void *argp1 = 0 ;
38654 int res1 = 0 ;
38655 size_t val2 ;
38656 int ecode2 = 0 ;
38657 int val3 ;
38658 int ecode3 = 0 ;
38659 bool temp4 = false ;
38660 bool temp5 = false ;
38661 int val6 ;
38662 int ecode6 = 0 ;
38663 PyObject * obj0 = 0 ;
38664 PyObject * obj1 = 0 ;
38665 PyObject * obj2 = 0 ;
38666 PyObject * obj3 = 0 ;
38667 PyObject * obj4 = 0 ;
38668 PyObject * obj5 = 0 ;
38669 char * kwnames[] = {
38670 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38671 };
38672
38673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
38674 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38675 if (!SWIG_IsOK(res1)) {
38676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
38677 }
38678 arg1 = reinterpret_cast< wxMenu * >(argp1);
38679 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38680 if (!SWIG_IsOK(ecode2)) {
38681 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
38682 }
38683 arg2 = static_cast< size_t >(val2);
38684 ecode3 = SWIG_AsVal_int(obj2, &val3);
38685 if (!SWIG_IsOK(ecode3)) {
38686 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
38687 }
38688 arg3 = static_cast< int >(val3);
38689 {
38690 arg4 = wxString_in_helper(obj3);
38691 if (arg4 == NULL) SWIG_fail;
38692 temp4 = true;
38693 }
38694 if (obj4) {
38695 {
38696 arg5 = wxString_in_helper(obj4);
38697 if (arg5 == NULL) SWIG_fail;
38698 temp5 = true;
38699 }
38700 }
38701 if (obj5) {
38702 ecode6 = SWIG_AsVal_int(obj5, &val6);
38703 if (!SWIG_IsOK(ecode6)) {
38704 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
38705 }
38706 arg6 = static_cast< wxItemKind >(val6);
38707 }
38708 {
38709 PyThreadState* __tstate = wxPyBeginAllowThreads();
38710 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
38711 wxPyEndAllowThreads(__tstate);
38712 if (PyErr_Occurred()) SWIG_fail;
38713 }
38714 {
38715 resultobj = wxPyMake_wxObject(result, (bool)0);
38716 }
38717 {
38718 if (temp4)
38719 delete arg4;
38720 }
38721 {
38722 if (temp5)
38723 delete arg5;
38724 }
38725 return resultobj;
38726 fail:
38727 {
38728 if (temp4)
38729 delete arg4;
38730 }
38731 {
38732 if (temp5)
38733 delete arg5;
38734 }
38735 return NULL;
38736 }
38737
38738
38739 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38740 PyObject *resultobj = 0;
38741 wxMenu *arg1 = (wxMenu *) 0 ;
38742 size_t arg2 ;
38743 wxMenuItem *result = 0 ;
38744 void *argp1 = 0 ;
38745 int res1 = 0 ;
38746 size_t val2 ;
38747 int ecode2 = 0 ;
38748 PyObject * obj0 = 0 ;
38749 PyObject * obj1 = 0 ;
38750 char * kwnames[] = {
38751 (char *) "self",(char *) "pos", NULL
38752 };
38753
38754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
38755 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38756 if (!SWIG_IsOK(res1)) {
38757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
38758 }
38759 arg1 = reinterpret_cast< wxMenu * >(argp1);
38760 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38761 if (!SWIG_IsOK(ecode2)) {
38762 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
38763 }
38764 arg2 = static_cast< size_t >(val2);
38765 {
38766 PyThreadState* __tstate = wxPyBeginAllowThreads();
38767 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
38768 wxPyEndAllowThreads(__tstate);
38769 if (PyErr_Occurred()) SWIG_fail;
38770 }
38771 {
38772 resultobj = wxPyMake_wxObject(result, (bool)0);
38773 }
38774 return resultobj;
38775 fail:
38776 return NULL;
38777 }
38778
38779
38780 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38781 PyObject *resultobj = 0;
38782 wxMenu *arg1 = (wxMenu *) 0 ;
38783 size_t arg2 ;
38784 int arg3 ;
38785 wxString *arg4 = 0 ;
38786 wxString const &arg5_defvalue = wxPyEmptyString ;
38787 wxString *arg5 = (wxString *) &arg5_defvalue ;
38788 wxMenuItem *result = 0 ;
38789 void *argp1 = 0 ;
38790 int res1 = 0 ;
38791 size_t val2 ;
38792 int ecode2 = 0 ;
38793 int val3 ;
38794 int ecode3 = 0 ;
38795 bool temp4 = false ;
38796 bool temp5 = false ;
38797 PyObject * obj0 = 0 ;
38798 PyObject * obj1 = 0 ;
38799 PyObject * obj2 = 0 ;
38800 PyObject * obj3 = 0 ;
38801 PyObject * obj4 = 0 ;
38802 char * kwnames[] = {
38803 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
38804 };
38805
38806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38808 if (!SWIG_IsOK(res1)) {
38809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38810 }
38811 arg1 = reinterpret_cast< wxMenu * >(argp1);
38812 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38813 if (!SWIG_IsOK(ecode2)) {
38814 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
38815 }
38816 arg2 = static_cast< size_t >(val2);
38817 ecode3 = SWIG_AsVal_int(obj2, &val3);
38818 if (!SWIG_IsOK(ecode3)) {
38819 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
38820 }
38821 arg3 = static_cast< int >(val3);
38822 {
38823 arg4 = wxString_in_helper(obj3);
38824 if (arg4 == NULL) SWIG_fail;
38825 temp4 = true;
38826 }
38827 if (obj4) {
38828 {
38829 arg5 = wxString_in_helper(obj4);
38830 if (arg5 == NULL) SWIG_fail;
38831 temp5 = true;
38832 }
38833 }
38834 {
38835 PyThreadState* __tstate = wxPyBeginAllowThreads();
38836 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
38837 wxPyEndAllowThreads(__tstate);
38838 if (PyErr_Occurred()) SWIG_fail;
38839 }
38840 {
38841 resultobj = wxPyMake_wxObject(result, (bool)0);
38842 }
38843 {
38844 if (temp4)
38845 delete arg4;
38846 }
38847 {
38848 if (temp5)
38849 delete arg5;
38850 }
38851 return resultobj;
38852 fail:
38853 {
38854 if (temp4)
38855 delete arg4;
38856 }
38857 {
38858 if (temp5)
38859 delete arg5;
38860 }
38861 return NULL;
38862 }
38863
38864
38865 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38866 PyObject *resultobj = 0;
38867 wxMenu *arg1 = (wxMenu *) 0 ;
38868 size_t arg2 ;
38869 int arg3 ;
38870 wxString *arg4 = 0 ;
38871 wxString const &arg5_defvalue = wxPyEmptyString ;
38872 wxString *arg5 = (wxString *) &arg5_defvalue ;
38873 wxMenuItem *result = 0 ;
38874 void *argp1 = 0 ;
38875 int res1 = 0 ;
38876 size_t val2 ;
38877 int ecode2 = 0 ;
38878 int val3 ;
38879 int ecode3 = 0 ;
38880 bool temp4 = false ;
38881 bool temp5 = false ;
38882 PyObject * obj0 = 0 ;
38883 PyObject * obj1 = 0 ;
38884 PyObject * obj2 = 0 ;
38885 PyObject * obj3 = 0 ;
38886 PyObject * obj4 = 0 ;
38887 char * kwnames[] = {
38888 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
38889 };
38890
38891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38892 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38893 if (!SWIG_IsOK(res1)) {
38894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38895 }
38896 arg1 = reinterpret_cast< wxMenu * >(argp1);
38897 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38898 if (!SWIG_IsOK(ecode2)) {
38899 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
38900 }
38901 arg2 = static_cast< size_t >(val2);
38902 ecode3 = SWIG_AsVal_int(obj2, &val3);
38903 if (!SWIG_IsOK(ecode3)) {
38904 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
38905 }
38906 arg3 = static_cast< int >(val3);
38907 {
38908 arg4 = wxString_in_helper(obj3);
38909 if (arg4 == NULL) SWIG_fail;
38910 temp4 = true;
38911 }
38912 if (obj4) {
38913 {
38914 arg5 = wxString_in_helper(obj4);
38915 if (arg5 == NULL) SWIG_fail;
38916 temp5 = true;
38917 }
38918 }
38919 {
38920 PyThreadState* __tstate = wxPyBeginAllowThreads();
38921 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
38922 wxPyEndAllowThreads(__tstate);
38923 if (PyErr_Occurred()) SWIG_fail;
38924 }
38925 {
38926 resultobj = wxPyMake_wxObject(result, (bool)0);
38927 }
38928 {
38929 if (temp4)
38930 delete arg4;
38931 }
38932 {
38933 if (temp5)
38934 delete arg5;
38935 }
38936 return resultobj;
38937 fail:
38938 {
38939 if (temp4)
38940 delete arg4;
38941 }
38942 {
38943 if (temp5)
38944 delete arg5;
38945 }
38946 return NULL;
38947 }
38948
38949
38950 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38951 PyObject *resultobj = 0;
38952 wxMenu *arg1 = (wxMenu *) 0 ;
38953 size_t arg2 ;
38954 int arg3 ;
38955 wxString *arg4 = 0 ;
38956 wxMenu *arg5 = (wxMenu *) 0 ;
38957 wxString const &arg6_defvalue = wxPyEmptyString ;
38958 wxString *arg6 = (wxString *) &arg6_defvalue ;
38959 wxMenuItem *result = 0 ;
38960 void *argp1 = 0 ;
38961 int res1 = 0 ;
38962 size_t val2 ;
38963 int ecode2 = 0 ;
38964 int val3 ;
38965 int ecode3 = 0 ;
38966 bool temp4 = false ;
38967 void *argp5 = 0 ;
38968 int res5 = 0 ;
38969 bool temp6 = false ;
38970 PyObject * obj0 = 0 ;
38971 PyObject * obj1 = 0 ;
38972 PyObject * obj2 = 0 ;
38973 PyObject * obj3 = 0 ;
38974 PyObject * obj4 = 0 ;
38975 PyObject * obj5 = 0 ;
38976 char * kwnames[] = {
38977 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
38978 };
38979
38980 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
38981 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38982 if (!SWIG_IsOK(res1)) {
38983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38984 }
38985 arg1 = reinterpret_cast< wxMenu * >(argp1);
38986 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38987 if (!SWIG_IsOK(ecode2)) {
38988 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
38989 }
38990 arg2 = static_cast< size_t >(val2);
38991 ecode3 = SWIG_AsVal_int(obj2, &val3);
38992 if (!SWIG_IsOK(ecode3)) {
38993 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
38994 }
38995 arg3 = static_cast< int >(val3);
38996 {
38997 arg4 = wxString_in_helper(obj3);
38998 if (arg4 == NULL) SWIG_fail;
38999 temp4 = true;
39000 }
39001 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
39002 if (!SWIG_IsOK(res5)) {
39003 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
39004 }
39005 arg5 = reinterpret_cast< wxMenu * >(argp5);
39006 if (obj5) {
39007 {
39008 arg6 = wxString_in_helper(obj5);
39009 if (arg6 == NULL) SWIG_fail;
39010 temp6 = true;
39011 }
39012 }
39013 {
39014 PyThreadState* __tstate = wxPyBeginAllowThreads();
39015 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
39016 wxPyEndAllowThreads(__tstate);
39017 if (PyErr_Occurred()) SWIG_fail;
39018 }
39019 {
39020 resultobj = wxPyMake_wxObject(result, (bool)0);
39021 }
39022 {
39023 if (temp4)
39024 delete arg4;
39025 }
39026 {
39027 if (temp6)
39028 delete arg6;
39029 }
39030 return resultobj;
39031 fail:
39032 {
39033 if (temp4)
39034 delete arg4;
39035 }
39036 {
39037 if (temp6)
39038 delete arg6;
39039 }
39040 return NULL;
39041 }
39042
39043
39044 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39045 PyObject *resultobj = 0;
39046 wxMenu *arg1 = (wxMenu *) 0 ;
39047 int arg2 ;
39048 wxString *arg3 = 0 ;
39049 wxString const &arg4_defvalue = wxPyEmptyString ;
39050 wxString *arg4 = (wxString *) &arg4_defvalue ;
39051 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
39052 wxMenuItem *result = 0 ;
39053 void *argp1 = 0 ;
39054 int res1 = 0 ;
39055 int val2 ;
39056 int ecode2 = 0 ;
39057 bool temp3 = false ;
39058 bool temp4 = false ;
39059 int val5 ;
39060 int ecode5 = 0 ;
39061 PyObject * obj0 = 0 ;
39062 PyObject * obj1 = 0 ;
39063 PyObject * obj2 = 0 ;
39064 PyObject * obj3 = 0 ;
39065 PyObject * obj4 = 0 ;
39066 char * kwnames[] = {
39067 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
39068 };
39069
39070 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39071 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39072 if (!SWIG_IsOK(res1)) {
39073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
39074 }
39075 arg1 = reinterpret_cast< wxMenu * >(argp1);
39076 ecode2 = SWIG_AsVal_int(obj1, &val2);
39077 if (!SWIG_IsOK(ecode2)) {
39078 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
39079 }
39080 arg2 = static_cast< int >(val2);
39081 {
39082 arg3 = wxString_in_helper(obj2);
39083 if (arg3 == NULL) SWIG_fail;
39084 temp3 = true;
39085 }
39086 if (obj3) {
39087 {
39088 arg4 = wxString_in_helper(obj3);
39089 if (arg4 == NULL) SWIG_fail;
39090 temp4 = true;
39091 }
39092 }
39093 if (obj4) {
39094 ecode5 = SWIG_AsVal_int(obj4, &val5);
39095 if (!SWIG_IsOK(ecode5)) {
39096 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
39097 }
39098 arg5 = static_cast< wxItemKind >(val5);
39099 }
39100 {
39101 PyThreadState* __tstate = wxPyBeginAllowThreads();
39102 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
39103 wxPyEndAllowThreads(__tstate);
39104 if (PyErr_Occurred()) SWIG_fail;
39105 }
39106 {
39107 resultobj = wxPyMake_wxObject(result, (bool)0);
39108 }
39109 {
39110 if (temp3)
39111 delete arg3;
39112 }
39113 {
39114 if (temp4)
39115 delete arg4;
39116 }
39117 return resultobj;
39118 fail:
39119 {
39120 if (temp3)
39121 delete arg3;
39122 }
39123 {
39124 if (temp4)
39125 delete arg4;
39126 }
39127 return NULL;
39128 }
39129
39130
39131 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39132 PyObject *resultobj = 0;
39133 wxMenu *arg1 = (wxMenu *) 0 ;
39134 wxMenuItem *result = 0 ;
39135 void *argp1 = 0 ;
39136 int res1 = 0 ;
39137 PyObject *swig_obj[1] ;
39138
39139 if (!args) SWIG_fail;
39140 swig_obj[0] = args;
39141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39142 if (!SWIG_IsOK(res1)) {
39143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39144 }
39145 arg1 = reinterpret_cast< wxMenu * >(argp1);
39146 {
39147 PyThreadState* __tstate = wxPyBeginAllowThreads();
39148 result = (wxMenuItem *)(arg1)->PrependSeparator();
39149 wxPyEndAllowThreads(__tstate);
39150 if (PyErr_Occurred()) SWIG_fail;
39151 }
39152 {
39153 resultobj = wxPyMake_wxObject(result, (bool)0);
39154 }
39155 return resultobj;
39156 fail:
39157 return NULL;
39158 }
39159
39160
39161 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39162 PyObject *resultobj = 0;
39163 wxMenu *arg1 = (wxMenu *) 0 ;
39164 int arg2 ;
39165 wxString *arg3 = 0 ;
39166 wxString const &arg4_defvalue = wxPyEmptyString ;
39167 wxString *arg4 = (wxString *) &arg4_defvalue ;
39168 wxMenuItem *result = 0 ;
39169 void *argp1 = 0 ;
39170 int res1 = 0 ;
39171 int val2 ;
39172 int ecode2 = 0 ;
39173 bool temp3 = false ;
39174 bool temp4 = false ;
39175 PyObject * obj0 = 0 ;
39176 PyObject * obj1 = 0 ;
39177 PyObject * obj2 = 0 ;
39178 PyObject * obj3 = 0 ;
39179 char * kwnames[] = {
39180 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39181 };
39182
39183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39184 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39185 if (!SWIG_IsOK(res1)) {
39186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39187 }
39188 arg1 = reinterpret_cast< wxMenu * >(argp1);
39189 ecode2 = SWIG_AsVal_int(obj1, &val2);
39190 if (!SWIG_IsOK(ecode2)) {
39191 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
39192 }
39193 arg2 = static_cast< int >(val2);
39194 {
39195 arg3 = wxString_in_helper(obj2);
39196 if (arg3 == NULL) SWIG_fail;
39197 temp3 = true;
39198 }
39199 if (obj3) {
39200 {
39201 arg4 = wxString_in_helper(obj3);
39202 if (arg4 == NULL) SWIG_fail;
39203 temp4 = true;
39204 }
39205 }
39206 {
39207 PyThreadState* __tstate = wxPyBeginAllowThreads();
39208 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39209 wxPyEndAllowThreads(__tstate);
39210 if (PyErr_Occurred()) SWIG_fail;
39211 }
39212 {
39213 resultobj = wxPyMake_wxObject(result, (bool)0);
39214 }
39215 {
39216 if (temp3)
39217 delete arg3;
39218 }
39219 {
39220 if (temp4)
39221 delete arg4;
39222 }
39223 return resultobj;
39224 fail:
39225 {
39226 if (temp3)
39227 delete arg3;
39228 }
39229 {
39230 if (temp4)
39231 delete arg4;
39232 }
39233 return NULL;
39234 }
39235
39236
39237 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39238 PyObject *resultobj = 0;
39239 wxMenu *arg1 = (wxMenu *) 0 ;
39240 int arg2 ;
39241 wxString *arg3 = 0 ;
39242 wxString const &arg4_defvalue = wxPyEmptyString ;
39243 wxString *arg4 = (wxString *) &arg4_defvalue ;
39244 wxMenuItem *result = 0 ;
39245 void *argp1 = 0 ;
39246 int res1 = 0 ;
39247 int val2 ;
39248 int ecode2 = 0 ;
39249 bool temp3 = false ;
39250 bool temp4 = false ;
39251 PyObject * obj0 = 0 ;
39252 PyObject * obj1 = 0 ;
39253 PyObject * obj2 = 0 ;
39254 PyObject * obj3 = 0 ;
39255 char * kwnames[] = {
39256 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39257 };
39258
39259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39260 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39261 if (!SWIG_IsOK(res1)) {
39262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39263 }
39264 arg1 = reinterpret_cast< wxMenu * >(argp1);
39265 ecode2 = SWIG_AsVal_int(obj1, &val2);
39266 if (!SWIG_IsOK(ecode2)) {
39267 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
39268 }
39269 arg2 = static_cast< int >(val2);
39270 {
39271 arg3 = wxString_in_helper(obj2);
39272 if (arg3 == NULL) SWIG_fail;
39273 temp3 = true;
39274 }
39275 if (obj3) {
39276 {
39277 arg4 = wxString_in_helper(obj3);
39278 if (arg4 == NULL) SWIG_fail;
39279 temp4 = true;
39280 }
39281 }
39282 {
39283 PyThreadState* __tstate = wxPyBeginAllowThreads();
39284 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39285 wxPyEndAllowThreads(__tstate);
39286 if (PyErr_Occurred()) SWIG_fail;
39287 }
39288 {
39289 resultobj = wxPyMake_wxObject(result, (bool)0);
39290 }
39291 {
39292 if (temp3)
39293 delete arg3;
39294 }
39295 {
39296 if (temp4)
39297 delete arg4;
39298 }
39299 return resultobj;
39300 fail:
39301 {
39302 if (temp3)
39303 delete arg3;
39304 }
39305 {
39306 if (temp4)
39307 delete arg4;
39308 }
39309 return NULL;
39310 }
39311
39312
39313 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39314 PyObject *resultobj = 0;
39315 wxMenu *arg1 = (wxMenu *) 0 ;
39316 int arg2 ;
39317 wxString *arg3 = 0 ;
39318 wxMenu *arg4 = (wxMenu *) 0 ;
39319 wxString const &arg5_defvalue = wxPyEmptyString ;
39320 wxString *arg5 = (wxString *) &arg5_defvalue ;
39321 wxMenuItem *result = 0 ;
39322 void *argp1 = 0 ;
39323 int res1 = 0 ;
39324 int val2 ;
39325 int ecode2 = 0 ;
39326 bool temp3 = false ;
39327 void *argp4 = 0 ;
39328 int res4 = 0 ;
39329 bool temp5 = false ;
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 *) "submenu",(char *) "help", NULL
39337 };
39338
39339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",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_PrependMenu" "', 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_PrependMenu" "', 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 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
39356 if (!SWIG_IsOK(res4)) {
39357 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
39358 }
39359 arg4 = reinterpret_cast< wxMenu * >(argp4);
39360 if (obj4) {
39361 {
39362 arg5 = wxString_in_helper(obj4);
39363 if (arg5 == NULL) SWIG_fail;
39364 temp5 = true;
39365 }
39366 }
39367 {
39368 PyThreadState* __tstate = wxPyBeginAllowThreads();
39369 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
39370 wxPyEndAllowThreads(__tstate);
39371 if (PyErr_Occurred()) SWIG_fail;
39372 }
39373 {
39374 resultobj = wxPyMake_wxObject(result, (bool)0);
39375 }
39376 {
39377 if (temp3)
39378 delete arg3;
39379 }
39380 {
39381 if (temp5)
39382 delete arg5;
39383 }
39384 return resultobj;
39385 fail:
39386 {
39387 if (temp3)
39388 delete arg3;
39389 }
39390 {
39391 if (temp5)
39392 delete arg5;
39393 }
39394 return NULL;
39395 }
39396
39397
39398 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39399 PyObject *resultobj = 0;
39400 wxMenu *arg1 = (wxMenu *) 0 ;
39401 int arg2 ;
39402 wxMenuItem *result = 0 ;
39403 void *argp1 = 0 ;
39404 int res1 = 0 ;
39405 int val2 ;
39406 int ecode2 = 0 ;
39407 PyObject * obj0 = 0 ;
39408 PyObject * obj1 = 0 ;
39409 char * kwnames[] = {
39410 (char *) "self",(char *) "id", NULL
39411 };
39412
39413 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
39414 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39415 if (!SWIG_IsOK(res1)) {
39416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
39417 }
39418 arg1 = reinterpret_cast< wxMenu * >(argp1);
39419 ecode2 = SWIG_AsVal_int(obj1, &val2);
39420 if (!SWIG_IsOK(ecode2)) {
39421 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
39422 }
39423 arg2 = static_cast< int >(val2);
39424 {
39425 PyThreadState* __tstate = wxPyBeginAllowThreads();
39426 result = (wxMenuItem *)(arg1)->Remove(arg2);
39427 wxPyEndAllowThreads(__tstate);
39428 if (PyErr_Occurred()) SWIG_fail;
39429 }
39430 {
39431 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39432 }
39433 return resultobj;
39434 fail:
39435 return NULL;
39436 }
39437
39438
39439 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39440 PyObject *resultobj = 0;
39441 wxMenu *arg1 = (wxMenu *) 0 ;
39442 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39443 wxMenuItem *result = 0 ;
39444 void *argp1 = 0 ;
39445 int res1 = 0 ;
39446 void *argp2 = 0 ;
39447 int res2 = 0 ;
39448 PyObject * obj0 = 0 ;
39449 PyObject * obj1 = 0 ;
39450 char * kwnames[] = {
39451 (char *) "self",(char *) "item", NULL
39452 };
39453
39454 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
39455 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39456 if (!SWIG_IsOK(res1)) {
39457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39458 }
39459 arg1 = reinterpret_cast< wxMenu * >(argp1);
39460 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39461 if (!SWIG_IsOK(res2)) {
39462 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39463 }
39464 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39465 {
39466 PyThreadState* __tstate = wxPyBeginAllowThreads();
39467 result = (wxMenuItem *)(arg1)->Remove(arg2);
39468 wxPyEndAllowThreads(__tstate);
39469 if (PyErr_Occurred()) SWIG_fail;
39470 }
39471 {
39472 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39473 }
39474 return resultobj;
39475 fail:
39476 return NULL;
39477 }
39478
39479
39480 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39481 PyObject *resultobj = 0;
39482 wxMenu *arg1 = (wxMenu *) 0 ;
39483 int arg2 ;
39484 bool result;
39485 void *argp1 = 0 ;
39486 int res1 = 0 ;
39487 int val2 ;
39488 int ecode2 = 0 ;
39489 PyObject * obj0 = 0 ;
39490 PyObject * obj1 = 0 ;
39491 char * kwnames[] = {
39492 (char *) "self",(char *) "id", NULL
39493 };
39494
39495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
39496 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39497 if (!SWIG_IsOK(res1)) {
39498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
39499 }
39500 arg1 = reinterpret_cast< wxMenu * >(argp1);
39501 ecode2 = SWIG_AsVal_int(obj1, &val2);
39502 if (!SWIG_IsOK(ecode2)) {
39503 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
39504 }
39505 arg2 = static_cast< int >(val2);
39506 {
39507 PyThreadState* __tstate = wxPyBeginAllowThreads();
39508 result = (bool)(arg1)->Delete(arg2);
39509 wxPyEndAllowThreads(__tstate);
39510 if (PyErr_Occurred()) SWIG_fail;
39511 }
39512 {
39513 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39514 }
39515 return resultobj;
39516 fail:
39517 return NULL;
39518 }
39519
39520
39521 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39522 PyObject *resultobj = 0;
39523 wxMenu *arg1 = (wxMenu *) 0 ;
39524 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39525 bool result;
39526 void *argp1 = 0 ;
39527 int res1 = 0 ;
39528 void *argp2 = 0 ;
39529 int res2 = 0 ;
39530 PyObject * obj0 = 0 ;
39531 PyObject * obj1 = 0 ;
39532 char * kwnames[] = {
39533 (char *) "self",(char *) "item", NULL
39534 };
39535
39536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
39537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39538 if (!SWIG_IsOK(res1)) {
39539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39540 }
39541 arg1 = reinterpret_cast< wxMenu * >(argp1);
39542 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39543 if (!SWIG_IsOK(res2)) {
39544 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39545 }
39546 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39547 {
39548 PyThreadState* __tstate = wxPyBeginAllowThreads();
39549 result = (bool)(arg1)->Delete(arg2);
39550 wxPyEndAllowThreads(__tstate);
39551 if (PyErr_Occurred()) SWIG_fail;
39552 }
39553 {
39554 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39555 }
39556 return resultobj;
39557 fail:
39558 return NULL;
39559 }
39560
39561
39562 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39563 PyObject *resultobj = 0;
39564 wxMenu *arg1 = (wxMenu *) 0 ;
39565 void *argp1 = 0 ;
39566 int res1 = 0 ;
39567 PyObject *swig_obj[1] ;
39568
39569 if (!args) SWIG_fail;
39570 swig_obj[0] = args;
39571 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39572 if (!SWIG_IsOK(res1)) {
39573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
39574 }
39575 arg1 = reinterpret_cast< wxMenu * >(argp1);
39576 {
39577 PyThreadState* __tstate = wxPyBeginAllowThreads();
39578 wxMenu_Destroy(arg1);
39579 wxPyEndAllowThreads(__tstate);
39580 if (PyErr_Occurred()) SWIG_fail;
39581 }
39582 resultobj = SWIG_Py_Void();
39583 return resultobj;
39584 fail:
39585 return NULL;
39586 }
39587
39588
39589 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39590 PyObject *resultobj = 0;
39591 wxMenu *arg1 = (wxMenu *) 0 ;
39592 int arg2 ;
39593 bool result;
39594 void *argp1 = 0 ;
39595 int res1 = 0 ;
39596 int val2 ;
39597 int ecode2 = 0 ;
39598 PyObject * obj0 = 0 ;
39599 PyObject * obj1 = 0 ;
39600 char * kwnames[] = {
39601 (char *) "self",(char *) "id", NULL
39602 };
39603
39604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
39605 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39606 if (!SWIG_IsOK(res1)) {
39607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
39608 }
39609 arg1 = reinterpret_cast< wxMenu * >(argp1);
39610 ecode2 = SWIG_AsVal_int(obj1, &val2);
39611 if (!SWIG_IsOK(ecode2)) {
39612 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
39613 }
39614 arg2 = static_cast< int >(val2);
39615 {
39616 PyThreadState* __tstate = wxPyBeginAllowThreads();
39617 result = (bool)(arg1)->Destroy(arg2);
39618 wxPyEndAllowThreads(__tstate);
39619 if (PyErr_Occurred()) SWIG_fail;
39620 }
39621 {
39622 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39623 }
39624 return resultobj;
39625 fail:
39626 return NULL;
39627 }
39628
39629
39630 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39631 PyObject *resultobj = 0;
39632 wxMenu *arg1 = (wxMenu *) 0 ;
39633 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39634 bool result;
39635 void *argp1 = 0 ;
39636 int res1 = 0 ;
39637 void *argp2 = 0 ;
39638 int res2 = 0 ;
39639 PyObject * obj0 = 0 ;
39640 PyObject * obj1 = 0 ;
39641 char * kwnames[] = {
39642 (char *) "self",(char *) "item", NULL
39643 };
39644
39645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
39646 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39647 if (!SWIG_IsOK(res1)) {
39648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39649 }
39650 arg1 = reinterpret_cast< wxMenu * >(argp1);
39651 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39652 if (!SWIG_IsOK(res2)) {
39653 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39654 }
39655 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39656 {
39657 PyThreadState* __tstate = wxPyBeginAllowThreads();
39658 result = (bool)(arg1)->Destroy(arg2);
39659 wxPyEndAllowThreads(__tstate);
39660 if (PyErr_Occurred()) SWIG_fail;
39661 }
39662 {
39663 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39664 }
39665 return resultobj;
39666 fail:
39667 return NULL;
39668 }
39669
39670
39671 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39672 PyObject *resultobj = 0;
39673 wxMenu *arg1 = (wxMenu *) 0 ;
39674 size_t result;
39675 void *argp1 = 0 ;
39676 int res1 = 0 ;
39677 PyObject *swig_obj[1] ;
39678
39679 if (!args) SWIG_fail;
39680 swig_obj[0] = args;
39681 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39682 if (!SWIG_IsOK(res1)) {
39683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
39684 }
39685 arg1 = reinterpret_cast< wxMenu * >(argp1);
39686 {
39687 PyThreadState* __tstate = wxPyBeginAllowThreads();
39688 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
39689 wxPyEndAllowThreads(__tstate);
39690 if (PyErr_Occurred()) SWIG_fail;
39691 }
39692 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
39693 return resultobj;
39694 fail:
39695 return NULL;
39696 }
39697
39698
39699 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39700 PyObject *resultobj = 0;
39701 wxMenu *arg1 = (wxMenu *) 0 ;
39702 PyObject *result = 0 ;
39703 void *argp1 = 0 ;
39704 int res1 = 0 ;
39705 PyObject *swig_obj[1] ;
39706
39707 if (!args) SWIG_fail;
39708 swig_obj[0] = args;
39709 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39710 if (!SWIG_IsOK(res1)) {
39711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
39712 }
39713 arg1 = reinterpret_cast< wxMenu * >(argp1);
39714 {
39715 PyThreadState* __tstate = wxPyBeginAllowThreads();
39716 result = (PyObject *)wxMenu_GetMenuItems(arg1);
39717 wxPyEndAllowThreads(__tstate);
39718 if (PyErr_Occurred()) SWIG_fail;
39719 }
39720 resultobj = result;
39721 return resultobj;
39722 fail:
39723 return NULL;
39724 }
39725
39726
39727 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39728 PyObject *resultobj = 0;
39729 wxMenu *arg1 = (wxMenu *) 0 ;
39730 wxString *arg2 = 0 ;
39731 int result;
39732 void *argp1 = 0 ;
39733 int res1 = 0 ;
39734 bool temp2 = false ;
39735 PyObject * obj0 = 0 ;
39736 PyObject * obj1 = 0 ;
39737 char * kwnames[] = {
39738 (char *) "self",(char *) "item", NULL
39739 };
39740
39741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
39742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39743 if (!SWIG_IsOK(res1)) {
39744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
39745 }
39746 arg1 = reinterpret_cast< wxMenu * >(argp1);
39747 {
39748 arg2 = wxString_in_helper(obj1);
39749 if (arg2 == NULL) SWIG_fail;
39750 temp2 = true;
39751 }
39752 {
39753 PyThreadState* __tstate = wxPyBeginAllowThreads();
39754 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
39755 wxPyEndAllowThreads(__tstate);
39756 if (PyErr_Occurred()) SWIG_fail;
39757 }
39758 resultobj = SWIG_From_int(static_cast< int >(result));
39759 {
39760 if (temp2)
39761 delete arg2;
39762 }
39763 return resultobj;
39764 fail:
39765 {
39766 if (temp2)
39767 delete arg2;
39768 }
39769 return NULL;
39770 }
39771
39772
39773 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39774 PyObject *resultobj = 0;
39775 wxMenu *arg1 = (wxMenu *) 0 ;
39776 int arg2 ;
39777 wxMenuItem *result = 0 ;
39778 void *argp1 = 0 ;
39779 int res1 = 0 ;
39780 int val2 ;
39781 int ecode2 = 0 ;
39782 PyObject * obj0 = 0 ;
39783 PyObject * obj1 = 0 ;
39784 char * kwnames[] = {
39785 (char *) "self",(char *) "id", NULL
39786 };
39787
39788 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
39789 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39790 if (!SWIG_IsOK(res1)) {
39791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
39792 }
39793 arg1 = reinterpret_cast< wxMenu * >(argp1);
39794 ecode2 = SWIG_AsVal_int(obj1, &val2);
39795 if (!SWIG_IsOK(ecode2)) {
39796 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
39797 }
39798 arg2 = static_cast< int >(val2);
39799 {
39800 PyThreadState* __tstate = wxPyBeginAllowThreads();
39801 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
39802 wxPyEndAllowThreads(__tstate);
39803 if (PyErr_Occurred()) SWIG_fail;
39804 }
39805 {
39806 resultobj = wxPyMake_wxObject(result, (bool)0);
39807 }
39808 return resultobj;
39809 fail:
39810 return NULL;
39811 }
39812
39813
39814 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39815 PyObject *resultobj = 0;
39816 wxMenu *arg1 = (wxMenu *) 0 ;
39817 size_t arg2 ;
39818 wxMenuItem *result = 0 ;
39819 void *argp1 = 0 ;
39820 int res1 = 0 ;
39821 size_t val2 ;
39822 int ecode2 = 0 ;
39823 PyObject * obj0 = 0 ;
39824 PyObject * obj1 = 0 ;
39825 char * kwnames[] = {
39826 (char *) "self",(char *) "position", NULL
39827 };
39828
39829 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
39830 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39831 if (!SWIG_IsOK(res1)) {
39832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
39833 }
39834 arg1 = reinterpret_cast< wxMenu * >(argp1);
39835 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39836 if (!SWIG_IsOK(ecode2)) {
39837 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
39838 }
39839 arg2 = static_cast< size_t >(val2);
39840 {
39841 PyThreadState* __tstate = wxPyBeginAllowThreads();
39842 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
39843 wxPyEndAllowThreads(__tstate);
39844 if (PyErr_Occurred()) SWIG_fail;
39845 }
39846 {
39847 resultobj = wxPyMake_wxObject(result, (bool)0);
39848 }
39849 return resultobj;
39850 fail:
39851 return NULL;
39852 }
39853
39854
39855 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39856 PyObject *resultobj = 0;
39857 wxMenu *arg1 = (wxMenu *) 0 ;
39858 int arg2 ;
39859 bool arg3 ;
39860 void *argp1 = 0 ;
39861 int res1 = 0 ;
39862 int val2 ;
39863 int ecode2 = 0 ;
39864 bool val3 ;
39865 int ecode3 = 0 ;
39866 PyObject * obj0 = 0 ;
39867 PyObject * obj1 = 0 ;
39868 PyObject * obj2 = 0 ;
39869 char * kwnames[] = {
39870 (char *) "self",(char *) "id",(char *) "enable", NULL
39871 };
39872
39873 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) 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_Enable" "', 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_Enable" "', expected argument " "2"" of type '" "int""'");
39882 }
39883 arg2 = static_cast< int >(val2);
39884 ecode3 = SWIG_AsVal_bool(obj2, &val3);
39885 if (!SWIG_IsOK(ecode3)) {
39886 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
39887 }
39888 arg3 = static_cast< bool >(val3);
39889 {
39890 PyThreadState* __tstate = wxPyBeginAllowThreads();
39891 (arg1)->Enable(arg2,arg3);
39892 wxPyEndAllowThreads(__tstate);
39893 if (PyErr_Occurred()) SWIG_fail;
39894 }
39895 resultobj = SWIG_Py_Void();
39896 return resultobj;
39897 fail:
39898 return NULL;
39899 }
39900
39901
39902 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39903 PyObject *resultobj = 0;
39904 wxMenu *arg1 = (wxMenu *) 0 ;
39905 int arg2 ;
39906 bool result;
39907 void *argp1 = 0 ;
39908 int res1 = 0 ;
39909 int val2 ;
39910 int ecode2 = 0 ;
39911 PyObject * obj0 = 0 ;
39912 PyObject * obj1 = 0 ;
39913 char * kwnames[] = {
39914 (char *) "self",(char *) "id", NULL
39915 };
39916
39917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
39918 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39919 if (!SWIG_IsOK(res1)) {
39920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
39921 }
39922 arg1 = reinterpret_cast< wxMenu * >(argp1);
39923 ecode2 = SWIG_AsVal_int(obj1, &val2);
39924 if (!SWIG_IsOK(ecode2)) {
39925 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
39926 }
39927 arg2 = static_cast< int >(val2);
39928 {
39929 PyThreadState* __tstate = wxPyBeginAllowThreads();
39930 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
39931 wxPyEndAllowThreads(__tstate);
39932 if (PyErr_Occurred()) SWIG_fail;
39933 }
39934 {
39935 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39936 }
39937 return resultobj;
39938 fail:
39939 return NULL;
39940 }
39941
39942
39943 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39944 PyObject *resultobj = 0;
39945 wxMenu *arg1 = (wxMenu *) 0 ;
39946 int arg2 ;
39947 bool arg3 ;
39948 void *argp1 = 0 ;
39949 int res1 = 0 ;
39950 int val2 ;
39951 int ecode2 = 0 ;
39952 bool val3 ;
39953 int ecode3 = 0 ;
39954 PyObject * obj0 = 0 ;
39955 PyObject * obj1 = 0 ;
39956 PyObject * obj2 = 0 ;
39957 char * kwnames[] = {
39958 (char *) "self",(char *) "id",(char *) "check", NULL
39959 };
39960
39961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39962 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39963 if (!SWIG_IsOK(res1)) {
39964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
39965 }
39966 arg1 = reinterpret_cast< wxMenu * >(argp1);
39967 ecode2 = SWIG_AsVal_int(obj1, &val2);
39968 if (!SWIG_IsOK(ecode2)) {
39969 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
39970 }
39971 arg2 = static_cast< int >(val2);
39972 ecode3 = SWIG_AsVal_bool(obj2, &val3);
39973 if (!SWIG_IsOK(ecode3)) {
39974 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
39975 }
39976 arg3 = static_cast< bool >(val3);
39977 {
39978 PyThreadState* __tstate = wxPyBeginAllowThreads();
39979 (arg1)->Check(arg2,arg3);
39980 wxPyEndAllowThreads(__tstate);
39981 if (PyErr_Occurred()) SWIG_fail;
39982 }
39983 resultobj = SWIG_Py_Void();
39984 return resultobj;
39985 fail:
39986 return NULL;
39987 }
39988
39989
39990 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39991 PyObject *resultobj = 0;
39992 wxMenu *arg1 = (wxMenu *) 0 ;
39993 int arg2 ;
39994 bool result;
39995 void *argp1 = 0 ;
39996 int res1 = 0 ;
39997 int val2 ;
39998 int ecode2 = 0 ;
39999 PyObject * obj0 = 0 ;
40000 PyObject * obj1 = 0 ;
40001 char * kwnames[] = {
40002 (char *) "self",(char *) "id", NULL
40003 };
40004
40005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
40006 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40007 if (!SWIG_IsOK(res1)) {
40008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
40009 }
40010 arg1 = reinterpret_cast< wxMenu * >(argp1);
40011 ecode2 = SWIG_AsVal_int(obj1, &val2);
40012 if (!SWIG_IsOK(ecode2)) {
40013 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
40014 }
40015 arg2 = static_cast< int >(val2);
40016 {
40017 PyThreadState* __tstate = wxPyBeginAllowThreads();
40018 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
40019 wxPyEndAllowThreads(__tstate);
40020 if (PyErr_Occurred()) SWIG_fail;
40021 }
40022 {
40023 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40024 }
40025 return resultobj;
40026 fail:
40027 return NULL;
40028 }
40029
40030
40031 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40032 PyObject *resultobj = 0;
40033 wxMenu *arg1 = (wxMenu *) 0 ;
40034 int arg2 ;
40035 wxString *arg3 = 0 ;
40036 void *argp1 = 0 ;
40037 int res1 = 0 ;
40038 int val2 ;
40039 int ecode2 = 0 ;
40040 bool temp3 = false ;
40041 PyObject * obj0 = 0 ;
40042 PyObject * obj1 = 0 ;
40043 PyObject * obj2 = 0 ;
40044 char * kwnames[] = {
40045 (char *) "self",(char *) "id",(char *) "label", NULL
40046 };
40047
40048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40049 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40050 if (!SWIG_IsOK(res1)) {
40051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
40052 }
40053 arg1 = reinterpret_cast< wxMenu * >(argp1);
40054 ecode2 = SWIG_AsVal_int(obj1, &val2);
40055 if (!SWIG_IsOK(ecode2)) {
40056 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
40057 }
40058 arg2 = static_cast< int >(val2);
40059 {
40060 arg3 = wxString_in_helper(obj2);
40061 if (arg3 == NULL) SWIG_fail;
40062 temp3 = true;
40063 }
40064 {
40065 PyThreadState* __tstate = wxPyBeginAllowThreads();
40066 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
40067 wxPyEndAllowThreads(__tstate);
40068 if (PyErr_Occurred()) SWIG_fail;
40069 }
40070 resultobj = SWIG_Py_Void();
40071 {
40072 if (temp3)
40073 delete arg3;
40074 }
40075 return resultobj;
40076 fail:
40077 {
40078 if (temp3)
40079 delete arg3;
40080 }
40081 return NULL;
40082 }
40083
40084
40085 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40086 PyObject *resultobj = 0;
40087 wxMenu *arg1 = (wxMenu *) 0 ;
40088 int arg2 ;
40089 wxString result;
40090 void *argp1 = 0 ;
40091 int res1 = 0 ;
40092 int val2 ;
40093 int ecode2 = 0 ;
40094 PyObject * obj0 = 0 ;
40095 PyObject * obj1 = 0 ;
40096 char * kwnames[] = {
40097 (char *) "self",(char *) "id", NULL
40098 };
40099
40100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
40101 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40102 if (!SWIG_IsOK(res1)) {
40103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
40104 }
40105 arg1 = reinterpret_cast< wxMenu * >(argp1);
40106 ecode2 = SWIG_AsVal_int(obj1, &val2);
40107 if (!SWIG_IsOK(ecode2)) {
40108 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
40109 }
40110 arg2 = static_cast< int >(val2);
40111 {
40112 PyThreadState* __tstate = wxPyBeginAllowThreads();
40113 result = ((wxMenu const *)arg1)->GetLabel(arg2);
40114 wxPyEndAllowThreads(__tstate);
40115 if (PyErr_Occurred()) SWIG_fail;
40116 }
40117 {
40118 #if wxUSE_UNICODE
40119 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40120 #else
40121 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40122 #endif
40123 }
40124 return resultobj;
40125 fail:
40126 return NULL;
40127 }
40128
40129
40130 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40131 PyObject *resultobj = 0;
40132 wxMenu *arg1 = (wxMenu *) 0 ;
40133 int arg2 ;
40134 wxString *arg3 = 0 ;
40135 void *argp1 = 0 ;
40136 int res1 = 0 ;
40137 int val2 ;
40138 int ecode2 = 0 ;
40139 bool temp3 = false ;
40140 PyObject * obj0 = 0 ;
40141 PyObject * obj1 = 0 ;
40142 PyObject * obj2 = 0 ;
40143 char * kwnames[] = {
40144 (char *) "self",(char *) "id",(char *) "helpString", NULL
40145 };
40146
40147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40149 if (!SWIG_IsOK(res1)) {
40150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
40151 }
40152 arg1 = reinterpret_cast< wxMenu * >(argp1);
40153 ecode2 = SWIG_AsVal_int(obj1, &val2);
40154 if (!SWIG_IsOK(ecode2)) {
40155 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
40156 }
40157 arg2 = static_cast< int >(val2);
40158 {
40159 arg3 = wxString_in_helper(obj2);
40160 if (arg3 == NULL) SWIG_fail;
40161 temp3 = true;
40162 }
40163 {
40164 PyThreadState* __tstate = wxPyBeginAllowThreads();
40165 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
40166 wxPyEndAllowThreads(__tstate);
40167 if (PyErr_Occurred()) SWIG_fail;
40168 }
40169 resultobj = SWIG_Py_Void();
40170 {
40171 if (temp3)
40172 delete arg3;
40173 }
40174 return resultobj;
40175 fail:
40176 {
40177 if (temp3)
40178 delete arg3;
40179 }
40180 return NULL;
40181 }
40182
40183
40184 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40185 PyObject *resultobj = 0;
40186 wxMenu *arg1 = (wxMenu *) 0 ;
40187 int arg2 ;
40188 wxString result;
40189 void *argp1 = 0 ;
40190 int res1 = 0 ;
40191 int val2 ;
40192 int ecode2 = 0 ;
40193 PyObject * obj0 = 0 ;
40194 PyObject * obj1 = 0 ;
40195 char * kwnames[] = {
40196 (char *) "self",(char *) "id", NULL
40197 };
40198
40199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
40200 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40201 if (!SWIG_IsOK(res1)) {
40202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
40203 }
40204 arg1 = reinterpret_cast< wxMenu * >(argp1);
40205 ecode2 = SWIG_AsVal_int(obj1, &val2);
40206 if (!SWIG_IsOK(ecode2)) {
40207 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
40208 }
40209 arg2 = static_cast< int >(val2);
40210 {
40211 PyThreadState* __tstate = wxPyBeginAllowThreads();
40212 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
40213 wxPyEndAllowThreads(__tstate);
40214 if (PyErr_Occurred()) SWIG_fail;
40215 }
40216 {
40217 #if wxUSE_UNICODE
40218 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40219 #else
40220 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40221 #endif
40222 }
40223 return resultobj;
40224 fail:
40225 return NULL;
40226 }
40227
40228
40229 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40230 PyObject *resultobj = 0;
40231 wxMenu *arg1 = (wxMenu *) 0 ;
40232 wxString *arg2 = 0 ;
40233 void *argp1 = 0 ;
40234 int res1 = 0 ;
40235 bool temp2 = false ;
40236 PyObject * obj0 = 0 ;
40237 PyObject * obj1 = 0 ;
40238 char * kwnames[] = {
40239 (char *) "self",(char *) "title", NULL
40240 };
40241
40242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
40243 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40244 if (!SWIG_IsOK(res1)) {
40245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
40246 }
40247 arg1 = reinterpret_cast< wxMenu * >(argp1);
40248 {
40249 arg2 = wxString_in_helper(obj1);
40250 if (arg2 == NULL) SWIG_fail;
40251 temp2 = true;
40252 }
40253 {
40254 PyThreadState* __tstate = wxPyBeginAllowThreads();
40255 (arg1)->SetTitle((wxString const &)*arg2);
40256 wxPyEndAllowThreads(__tstate);
40257 if (PyErr_Occurred()) SWIG_fail;
40258 }
40259 resultobj = SWIG_Py_Void();
40260 {
40261 if (temp2)
40262 delete arg2;
40263 }
40264 return resultobj;
40265 fail:
40266 {
40267 if (temp2)
40268 delete arg2;
40269 }
40270 return NULL;
40271 }
40272
40273
40274 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40275 PyObject *resultobj = 0;
40276 wxMenu *arg1 = (wxMenu *) 0 ;
40277 wxString result;
40278 void *argp1 = 0 ;
40279 int res1 = 0 ;
40280 PyObject *swig_obj[1] ;
40281
40282 if (!args) SWIG_fail;
40283 swig_obj[0] = args;
40284 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40285 if (!SWIG_IsOK(res1)) {
40286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40287 }
40288 arg1 = reinterpret_cast< wxMenu * >(argp1);
40289 {
40290 PyThreadState* __tstate = wxPyBeginAllowThreads();
40291 result = ((wxMenu const *)arg1)->GetTitle();
40292 wxPyEndAllowThreads(__tstate);
40293 if (PyErr_Occurred()) SWIG_fail;
40294 }
40295 {
40296 #if wxUSE_UNICODE
40297 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40298 #else
40299 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40300 #endif
40301 }
40302 return resultobj;
40303 fail:
40304 return NULL;
40305 }
40306
40307
40308 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40309 PyObject *resultobj = 0;
40310 wxMenu *arg1 = (wxMenu *) 0 ;
40311 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
40312 void *argp1 = 0 ;
40313 int res1 = 0 ;
40314 void *argp2 = 0 ;
40315 int res2 = 0 ;
40316 PyObject * obj0 = 0 ;
40317 PyObject * obj1 = 0 ;
40318 char * kwnames[] = {
40319 (char *) "self",(char *) "handler", NULL
40320 };
40321
40322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
40323 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40324 if (!SWIG_IsOK(res1)) {
40325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
40326 }
40327 arg1 = reinterpret_cast< wxMenu * >(argp1);
40328 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40329 if (!SWIG_IsOK(res2)) {
40330 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40331 }
40332 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40333 {
40334 PyThreadState* __tstate = wxPyBeginAllowThreads();
40335 (arg1)->SetEventHandler(arg2);
40336 wxPyEndAllowThreads(__tstate);
40337 if (PyErr_Occurred()) SWIG_fail;
40338 }
40339 resultobj = SWIG_Py_Void();
40340 return resultobj;
40341 fail:
40342 return NULL;
40343 }
40344
40345
40346 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40347 PyObject *resultobj = 0;
40348 wxMenu *arg1 = (wxMenu *) 0 ;
40349 wxEvtHandler *result = 0 ;
40350 void *argp1 = 0 ;
40351 int res1 = 0 ;
40352 PyObject *swig_obj[1] ;
40353
40354 if (!args) SWIG_fail;
40355 swig_obj[0] = args;
40356 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40357 if (!SWIG_IsOK(res1)) {
40358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
40359 }
40360 arg1 = reinterpret_cast< wxMenu * >(argp1);
40361 {
40362 PyThreadState* __tstate = wxPyBeginAllowThreads();
40363 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
40364 wxPyEndAllowThreads(__tstate);
40365 if (PyErr_Occurred()) SWIG_fail;
40366 }
40367 {
40368 resultobj = wxPyMake_wxObject(result, 0);
40369 }
40370 return resultobj;
40371 fail:
40372 return NULL;
40373 }
40374
40375
40376 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40377 PyObject *resultobj = 0;
40378 wxMenu *arg1 = (wxMenu *) 0 ;
40379 wxWindow *arg2 = (wxWindow *) 0 ;
40380 void *argp1 = 0 ;
40381 int res1 = 0 ;
40382 void *argp2 = 0 ;
40383 int res2 = 0 ;
40384 PyObject * obj0 = 0 ;
40385 PyObject * obj1 = 0 ;
40386 char * kwnames[] = {
40387 (char *) "self",(char *) "win", NULL
40388 };
40389
40390 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
40391 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40392 if (!SWIG_IsOK(res1)) {
40393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
40394 }
40395 arg1 = reinterpret_cast< wxMenu * >(argp1);
40396 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
40397 if (!SWIG_IsOK(res2)) {
40398 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
40399 }
40400 arg2 = reinterpret_cast< wxWindow * >(argp2);
40401 {
40402 PyThreadState* __tstate = wxPyBeginAllowThreads();
40403 (arg1)->SetInvokingWindow(arg2);
40404 wxPyEndAllowThreads(__tstate);
40405 if (PyErr_Occurred()) SWIG_fail;
40406 }
40407 resultobj = SWIG_Py_Void();
40408 return resultobj;
40409 fail:
40410 return NULL;
40411 }
40412
40413
40414 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40415 PyObject *resultobj = 0;
40416 wxMenu *arg1 = (wxMenu *) 0 ;
40417 wxWindow *result = 0 ;
40418 void *argp1 = 0 ;
40419 int res1 = 0 ;
40420 PyObject *swig_obj[1] ;
40421
40422 if (!args) SWIG_fail;
40423 swig_obj[0] = args;
40424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40425 if (!SWIG_IsOK(res1)) {
40426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
40427 }
40428 arg1 = reinterpret_cast< wxMenu * >(argp1);
40429 {
40430 PyThreadState* __tstate = wxPyBeginAllowThreads();
40431 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
40432 wxPyEndAllowThreads(__tstate);
40433 if (PyErr_Occurred()) SWIG_fail;
40434 }
40435 {
40436 resultobj = wxPyMake_wxObject(result, 0);
40437 }
40438 return resultobj;
40439 fail:
40440 return NULL;
40441 }
40442
40443
40444 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40445 PyObject *resultobj = 0;
40446 wxMenu *arg1 = (wxMenu *) 0 ;
40447 long result;
40448 void *argp1 = 0 ;
40449 int res1 = 0 ;
40450 PyObject *swig_obj[1] ;
40451
40452 if (!args) SWIG_fail;
40453 swig_obj[0] = args;
40454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40455 if (!SWIG_IsOK(res1)) {
40456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40457 }
40458 arg1 = reinterpret_cast< wxMenu * >(argp1);
40459 {
40460 PyThreadState* __tstate = wxPyBeginAllowThreads();
40461 result = (long)((wxMenu const *)arg1)->GetStyle();
40462 wxPyEndAllowThreads(__tstate);
40463 if (PyErr_Occurred()) SWIG_fail;
40464 }
40465 resultobj = SWIG_From_long(static_cast< long >(result));
40466 return resultobj;
40467 fail:
40468 return NULL;
40469 }
40470
40471
40472 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40473 PyObject *resultobj = 0;
40474 wxMenu *arg1 = (wxMenu *) 0 ;
40475 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
40476 void *argp1 = 0 ;
40477 int res1 = 0 ;
40478 void *argp2 = 0 ;
40479 int res2 = 0 ;
40480 PyObject * obj0 = 0 ;
40481 PyObject * obj1 = 0 ;
40482 char * kwnames[] = {
40483 (char *) "self",(char *) "source", NULL
40484 };
40485
40486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
40487 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40488 if (!SWIG_IsOK(res1)) {
40489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
40490 }
40491 arg1 = reinterpret_cast< wxMenu * >(argp1);
40492 if (obj1) {
40493 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40494 if (!SWIG_IsOK(res2)) {
40495 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40496 }
40497 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40498 }
40499 {
40500 PyThreadState* __tstate = wxPyBeginAllowThreads();
40501 (arg1)->UpdateUI(arg2);
40502 wxPyEndAllowThreads(__tstate);
40503 if (PyErr_Occurred()) SWIG_fail;
40504 }
40505 resultobj = SWIG_Py_Void();
40506 return resultobj;
40507 fail:
40508 return NULL;
40509 }
40510
40511
40512 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40513 PyObject *resultobj = 0;
40514 wxMenu *arg1 = (wxMenu *) 0 ;
40515 wxMenuBar *result = 0 ;
40516 void *argp1 = 0 ;
40517 int res1 = 0 ;
40518 PyObject *swig_obj[1] ;
40519
40520 if (!args) SWIG_fail;
40521 swig_obj[0] = args;
40522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40523 if (!SWIG_IsOK(res1)) {
40524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
40525 }
40526 arg1 = reinterpret_cast< wxMenu * >(argp1);
40527 {
40528 PyThreadState* __tstate = wxPyBeginAllowThreads();
40529 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
40530 wxPyEndAllowThreads(__tstate);
40531 if (PyErr_Occurred()) SWIG_fail;
40532 }
40533 {
40534 resultobj = wxPyMake_wxObject(result, (bool)0);
40535 }
40536 return resultobj;
40537 fail:
40538 return NULL;
40539 }
40540
40541
40542 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40543 PyObject *resultobj = 0;
40544 wxMenu *arg1 = (wxMenu *) 0 ;
40545 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
40546 void *argp1 = 0 ;
40547 int res1 = 0 ;
40548 void *argp2 = 0 ;
40549 int res2 = 0 ;
40550 PyObject * obj0 = 0 ;
40551 PyObject * obj1 = 0 ;
40552 char * kwnames[] = {
40553 (char *) "self",(char *) "menubar", NULL
40554 };
40555
40556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
40557 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40558 if (!SWIG_IsOK(res1)) {
40559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
40560 }
40561 arg1 = reinterpret_cast< wxMenu * >(argp1);
40562 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
40563 if (!SWIG_IsOK(res2)) {
40564 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
40565 }
40566 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
40567 {
40568 PyThreadState* __tstate = wxPyBeginAllowThreads();
40569 (arg1)->Attach(arg2);
40570 wxPyEndAllowThreads(__tstate);
40571 if (PyErr_Occurred()) SWIG_fail;
40572 }
40573 resultobj = SWIG_Py_Void();
40574 return resultobj;
40575 fail:
40576 return NULL;
40577 }
40578
40579
40580 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40581 PyObject *resultobj = 0;
40582 wxMenu *arg1 = (wxMenu *) 0 ;
40583 void *argp1 = 0 ;
40584 int res1 = 0 ;
40585 PyObject *swig_obj[1] ;
40586
40587 if (!args) SWIG_fail;
40588 swig_obj[0] = args;
40589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40590 if (!SWIG_IsOK(res1)) {
40591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
40592 }
40593 arg1 = reinterpret_cast< wxMenu * >(argp1);
40594 {
40595 PyThreadState* __tstate = wxPyBeginAllowThreads();
40596 (arg1)->Detach();
40597 wxPyEndAllowThreads(__tstate);
40598 if (PyErr_Occurred()) SWIG_fail;
40599 }
40600 resultobj = SWIG_Py_Void();
40601 return resultobj;
40602 fail:
40603 return NULL;
40604 }
40605
40606
40607 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40608 PyObject *resultobj = 0;
40609 wxMenu *arg1 = (wxMenu *) 0 ;
40610 bool result;
40611 void *argp1 = 0 ;
40612 int res1 = 0 ;
40613 PyObject *swig_obj[1] ;
40614
40615 if (!args) SWIG_fail;
40616 swig_obj[0] = args;
40617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40618 if (!SWIG_IsOK(res1)) {
40619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
40620 }
40621 arg1 = reinterpret_cast< wxMenu * >(argp1);
40622 {
40623 PyThreadState* __tstate = wxPyBeginAllowThreads();
40624 result = (bool)((wxMenu const *)arg1)->IsAttached();
40625 wxPyEndAllowThreads(__tstate);
40626 if (PyErr_Occurred()) SWIG_fail;
40627 }
40628 {
40629 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40630 }
40631 return resultobj;
40632 fail:
40633 return NULL;
40634 }
40635
40636
40637 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40638 PyObject *resultobj = 0;
40639 wxMenu *arg1 = (wxMenu *) 0 ;
40640 wxMenu *arg2 = (wxMenu *) 0 ;
40641 void *argp1 = 0 ;
40642 int res1 = 0 ;
40643 void *argp2 = 0 ;
40644 int res2 = 0 ;
40645 PyObject * obj0 = 0 ;
40646 PyObject * obj1 = 0 ;
40647 char * kwnames[] = {
40648 (char *) "self",(char *) "parent", NULL
40649 };
40650
40651 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
40652 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40653 if (!SWIG_IsOK(res1)) {
40654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
40655 }
40656 arg1 = reinterpret_cast< wxMenu * >(argp1);
40657 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
40658 if (!SWIG_IsOK(res2)) {
40659 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
40660 }
40661 arg2 = reinterpret_cast< wxMenu * >(argp2);
40662 {
40663 PyThreadState* __tstate = wxPyBeginAllowThreads();
40664 (arg1)->SetParent(arg2);
40665 wxPyEndAllowThreads(__tstate);
40666 if (PyErr_Occurred()) SWIG_fail;
40667 }
40668 resultobj = SWIG_Py_Void();
40669 return resultobj;
40670 fail:
40671 return NULL;
40672 }
40673
40674
40675 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40676 PyObject *resultobj = 0;
40677 wxMenu *arg1 = (wxMenu *) 0 ;
40678 wxMenu *result = 0 ;
40679 void *argp1 = 0 ;
40680 int res1 = 0 ;
40681 PyObject *swig_obj[1] ;
40682
40683 if (!args) SWIG_fail;
40684 swig_obj[0] = args;
40685 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40686 if (!SWIG_IsOK(res1)) {
40687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
40688 }
40689 arg1 = reinterpret_cast< wxMenu * >(argp1);
40690 {
40691 PyThreadState* __tstate = wxPyBeginAllowThreads();
40692 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
40693 wxPyEndAllowThreads(__tstate);
40694 if (PyErr_Occurred()) SWIG_fail;
40695 }
40696 {
40697 resultobj = wxPyMake_wxObject(result, 0);
40698 }
40699 return resultobj;
40700 fail:
40701 return NULL;
40702 }
40703
40704
40705 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40706 PyObject *obj;
40707 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
40708 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
40709 return SWIG_Py_Void();
40710 }
40711
40712 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40713 return SWIG_Python_InitShadowInstance(args);
40714 }
40715
40716 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40717 PyObject *resultobj = 0;
40718 long arg1 = (long) 0 ;
40719 wxMenuBar *result = 0 ;
40720 long val1 ;
40721 int ecode1 = 0 ;
40722 PyObject * obj0 = 0 ;
40723 char * kwnames[] = {
40724 (char *) "style", NULL
40725 };
40726
40727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
40728 if (obj0) {
40729 ecode1 = SWIG_AsVal_long(obj0, &val1);
40730 if (!SWIG_IsOK(ecode1)) {
40731 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
40732 }
40733 arg1 = static_cast< long >(val1);
40734 }
40735 {
40736 if (!wxPyCheckForApp()) SWIG_fail;
40737 PyThreadState* __tstate = wxPyBeginAllowThreads();
40738 result = (wxMenuBar *)new wxMenuBar(arg1);
40739 wxPyEndAllowThreads(__tstate);
40740 if (PyErr_Occurred()) SWIG_fail;
40741 }
40742 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
40743 return resultobj;
40744 fail:
40745 return NULL;
40746 }
40747
40748
40749 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40750 PyObject *resultobj = 0;
40751 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40752 wxMenu *arg2 = (wxMenu *) 0 ;
40753 wxString *arg3 = 0 ;
40754 bool result;
40755 void *argp1 = 0 ;
40756 int res1 = 0 ;
40757 void *argp2 = 0 ;
40758 int res2 = 0 ;
40759 bool temp3 = false ;
40760 PyObject * obj0 = 0 ;
40761 PyObject * obj1 = 0 ;
40762 PyObject * obj2 = 0 ;
40763 char * kwnames[] = {
40764 (char *) "self",(char *) "menu",(char *) "title", NULL
40765 };
40766
40767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40768 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40769 if (!SWIG_IsOK(res1)) {
40770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40771 }
40772 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40773 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
40774 if (!SWIG_IsOK(res2)) {
40775 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
40776 }
40777 arg2 = reinterpret_cast< wxMenu * >(argp2);
40778 {
40779 arg3 = wxString_in_helper(obj2);
40780 if (arg3 == NULL) SWIG_fail;
40781 temp3 = true;
40782 }
40783 {
40784 PyThreadState* __tstate = wxPyBeginAllowThreads();
40785 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
40786 wxPyEndAllowThreads(__tstate);
40787 if (PyErr_Occurred()) SWIG_fail;
40788 }
40789 {
40790 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40791 }
40792 {
40793 if (temp3)
40794 delete arg3;
40795 }
40796 return resultobj;
40797 fail:
40798 {
40799 if (temp3)
40800 delete arg3;
40801 }
40802 return NULL;
40803 }
40804
40805
40806 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40807 PyObject *resultobj = 0;
40808 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40809 size_t arg2 ;
40810 wxMenu *arg3 = (wxMenu *) 0 ;
40811 wxString *arg4 = 0 ;
40812 bool result;
40813 void *argp1 = 0 ;
40814 int res1 = 0 ;
40815 size_t val2 ;
40816 int ecode2 = 0 ;
40817 void *argp3 = 0 ;
40818 int res3 = 0 ;
40819 bool temp4 = false ;
40820 PyObject * obj0 = 0 ;
40821 PyObject * obj1 = 0 ;
40822 PyObject * obj2 = 0 ;
40823 PyObject * obj3 = 0 ;
40824 char * kwnames[] = {
40825 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
40826 };
40827
40828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40829 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40830 if (!SWIG_IsOK(res1)) {
40831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40832 }
40833 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40834 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40835 if (!SWIG_IsOK(ecode2)) {
40836 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
40837 }
40838 arg2 = static_cast< size_t >(val2);
40839 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
40840 if (!SWIG_IsOK(res3)) {
40841 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
40842 }
40843 arg3 = reinterpret_cast< wxMenu * >(argp3);
40844 {
40845 arg4 = wxString_in_helper(obj3);
40846 if (arg4 == NULL) SWIG_fail;
40847 temp4 = true;
40848 }
40849 {
40850 PyThreadState* __tstate = wxPyBeginAllowThreads();
40851 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
40852 wxPyEndAllowThreads(__tstate);
40853 if (PyErr_Occurred()) SWIG_fail;
40854 }
40855 {
40856 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40857 }
40858 {
40859 if (temp4)
40860 delete arg4;
40861 }
40862 return resultobj;
40863 fail:
40864 {
40865 if (temp4)
40866 delete arg4;
40867 }
40868 return NULL;
40869 }
40870
40871
40872 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40873 PyObject *resultobj = 0;
40874 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40875 size_t result;
40876 void *argp1 = 0 ;
40877 int res1 = 0 ;
40878 PyObject *swig_obj[1] ;
40879
40880 if (!args) SWIG_fail;
40881 swig_obj[0] = args;
40882 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40883 if (!SWIG_IsOK(res1)) {
40884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
40885 }
40886 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40887 {
40888 PyThreadState* __tstate = wxPyBeginAllowThreads();
40889 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
40890 wxPyEndAllowThreads(__tstate);
40891 if (PyErr_Occurred()) SWIG_fail;
40892 }
40893 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
40894 return resultobj;
40895 fail:
40896 return NULL;
40897 }
40898
40899
40900 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40901 PyObject *resultobj = 0;
40902 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40903 size_t arg2 ;
40904 wxMenu *result = 0 ;
40905 void *argp1 = 0 ;
40906 int res1 = 0 ;
40907 size_t val2 ;
40908 int ecode2 = 0 ;
40909 PyObject * obj0 = 0 ;
40910 PyObject * obj1 = 0 ;
40911 char * kwnames[] = {
40912 (char *) "self",(char *) "pos", NULL
40913 };
40914
40915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
40916 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40917 if (!SWIG_IsOK(res1)) {
40918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
40919 }
40920 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40921 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40922 if (!SWIG_IsOK(ecode2)) {
40923 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
40924 }
40925 arg2 = static_cast< size_t >(val2);
40926 {
40927 PyThreadState* __tstate = wxPyBeginAllowThreads();
40928 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
40929 wxPyEndAllowThreads(__tstate);
40930 if (PyErr_Occurred()) SWIG_fail;
40931 }
40932 {
40933 resultobj = wxPyMake_wxObject(result, 0);
40934 }
40935 return resultobj;
40936 fail:
40937 return NULL;
40938 }
40939
40940
40941 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40942 PyObject *resultobj = 0;
40943 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40944 size_t arg2 ;
40945 wxMenu *arg3 = (wxMenu *) 0 ;
40946 wxString *arg4 = 0 ;
40947 wxMenu *result = 0 ;
40948 void *argp1 = 0 ;
40949 int res1 = 0 ;
40950 size_t val2 ;
40951 int ecode2 = 0 ;
40952 void *argp3 = 0 ;
40953 int res3 = 0 ;
40954 bool temp4 = false ;
40955 PyObject * obj0 = 0 ;
40956 PyObject * obj1 = 0 ;
40957 PyObject * obj2 = 0 ;
40958 PyObject * obj3 = 0 ;
40959 char * kwnames[] = {
40960 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
40961 };
40962
40963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40964 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40965 if (!SWIG_IsOK(res1)) {
40966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40967 }
40968 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40969 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40970 if (!SWIG_IsOK(ecode2)) {
40971 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
40972 }
40973 arg2 = static_cast< size_t >(val2);
40974 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
40975 if (!SWIG_IsOK(res3)) {
40976 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
40977 }
40978 arg3 = reinterpret_cast< wxMenu * >(argp3);
40979 {
40980 arg4 = wxString_in_helper(obj3);
40981 if (arg4 == NULL) SWIG_fail;
40982 temp4 = true;
40983 }
40984 {
40985 PyThreadState* __tstate = wxPyBeginAllowThreads();
40986 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
40987 wxPyEndAllowThreads(__tstate);
40988 if (PyErr_Occurred()) SWIG_fail;
40989 }
40990 {
40991 resultobj = wxPyMake_wxObject(result, 0);
40992 }
40993 {
40994 if (temp4)
40995 delete arg4;
40996 }
40997 return resultobj;
40998 fail:
40999 {
41000 if (temp4)
41001 delete arg4;
41002 }
41003 return NULL;
41004 }
41005
41006
41007 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41008 PyObject *resultobj = 0;
41009 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41010 size_t arg2 ;
41011 wxMenu *result = 0 ;
41012 void *argp1 = 0 ;
41013 int res1 = 0 ;
41014 size_t val2 ;
41015 int ecode2 = 0 ;
41016 PyObject * obj0 = 0 ;
41017 PyObject * obj1 = 0 ;
41018 char * kwnames[] = {
41019 (char *) "self",(char *) "pos", NULL
41020 };
41021
41022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
41023 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41024 if (!SWIG_IsOK(res1)) {
41025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41026 }
41027 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41028 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41029 if (!SWIG_IsOK(ecode2)) {
41030 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
41031 }
41032 arg2 = static_cast< size_t >(val2);
41033 {
41034 PyThreadState* __tstate = wxPyBeginAllowThreads();
41035 result = (wxMenu *)(arg1)->Remove(arg2);
41036 wxPyEndAllowThreads(__tstate);
41037 if (PyErr_Occurred()) SWIG_fail;
41038 }
41039 {
41040 resultobj = wxPyMake_wxObject(result, 0);
41041 }
41042 return resultobj;
41043 fail:
41044 return NULL;
41045 }
41046
41047
41048 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41049 PyObject *resultobj = 0;
41050 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41051 size_t arg2 ;
41052 bool arg3 ;
41053 void *argp1 = 0 ;
41054 int res1 = 0 ;
41055 size_t val2 ;
41056 int ecode2 = 0 ;
41057 bool val3 ;
41058 int ecode3 = 0 ;
41059 PyObject * obj0 = 0 ;
41060 PyObject * obj1 = 0 ;
41061 PyObject * obj2 = 0 ;
41062 char * kwnames[] = {
41063 (char *) "self",(char *) "pos",(char *) "enable", NULL
41064 };
41065
41066 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41067 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41068 if (!SWIG_IsOK(res1)) {
41069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41070 }
41071 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41072 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41073 if (!SWIG_IsOK(ecode2)) {
41074 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
41075 }
41076 arg2 = static_cast< size_t >(val2);
41077 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41078 if (!SWIG_IsOK(ecode3)) {
41079 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
41080 }
41081 arg3 = static_cast< bool >(val3);
41082 {
41083 PyThreadState* __tstate = wxPyBeginAllowThreads();
41084 (arg1)->EnableTop(arg2,arg3);
41085 wxPyEndAllowThreads(__tstate);
41086 if (PyErr_Occurred()) SWIG_fail;
41087 }
41088 resultobj = SWIG_Py_Void();
41089 return resultobj;
41090 fail:
41091 return NULL;
41092 }
41093
41094
41095 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41096 PyObject *resultobj = 0;
41097 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41098 size_t arg2 ;
41099 bool result;
41100 void *argp1 = 0 ;
41101 int res1 = 0 ;
41102 size_t val2 ;
41103 int ecode2 = 0 ;
41104 PyObject * obj0 = 0 ;
41105 PyObject * obj1 = 0 ;
41106 char * kwnames[] = {
41107 (char *) "self",(char *) "pos", NULL
41108 };
41109
41110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
41111 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41112 if (!SWIG_IsOK(res1)) {
41113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41114 }
41115 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41116 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41117 if (!SWIG_IsOK(ecode2)) {
41118 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
41119 }
41120 arg2 = static_cast< size_t >(val2);
41121 {
41122 PyThreadState* __tstate = wxPyBeginAllowThreads();
41123 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
41124 wxPyEndAllowThreads(__tstate);
41125 if (PyErr_Occurred()) SWIG_fail;
41126 }
41127 {
41128 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41129 }
41130 return resultobj;
41131 fail:
41132 return NULL;
41133 }
41134
41135
41136 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41137 PyObject *resultobj = 0;
41138 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41139 size_t arg2 ;
41140 wxString *arg3 = 0 ;
41141 void *argp1 = 0 ;
41142 int res1 = 0 ;
41143 size_t val2 ;
41144 int ecode2 = 0 ;
41145 bool temp3 = false ;
41146 PyObject * obj0 = 0 ;
41147 PyObject * obj1 = 0 ;
41148 PyObject * obj2 = 0 ;
41149 char * kwnames[] = {
41150 (char *) "self",(char *) "pos",(char *) "label", NULL
41151 };
41152
41153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41154 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41155 if (!SWIG_IsOK(res1)) {
41156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41157 }
41158 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41159 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41160 if (!SWIG_IsOK(ecode2)) {
41161 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41162 }
41163 arg2 = static_cast< size_t >(val2);
41164 {
41165 arg3 = wxString_in_helper(obj2);
41166 if (arg3 == NULL) SWIG_fail;
41167 temp3 = true;
41168 }
41169 {
41170 PyThreadState* __tstate = wxPyBeginAllowThreads();
41171 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
41172 wxPyEndAllowThreads(__tstate);
41173 if (PyErr_Occurred()) SWIG_fail;
41174 }
41175 resultobj = SWIG_Py_Void();
41176 {
41177 if (temp3)
41178 delete arg3;
41179 }
41180 return resultobj;
41181 fail:
41182 {
41183 if (temp3)
41184 delete arg3;
41185 }
41186 return NULL;
41187 }
41188
41189
41190 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41191 PyObject *resultobj = 0;
41192 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41193 size_t arg2 ;
41194 wxString result;
41195 void *argp1 = 0 ;
41196 int res1 = 0 ;
41197 size_t val2 ;
41198 int ecode2 = 0 ;
41199 PyObject * obj0 = 0 ;
41200 PyObject * obj1 = 0 ;
41201 char * kwnames[] = {
41202 (char *) "self",(char *) "pos", NULL
41203 };
41204
41205 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
41206 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41207 if (!SWIG_IsOK(res1)) {
41208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41209 }
41210 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41211 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41212 if (!SWIG_IsOK(ecode2)) {
41213 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41214 }
41215 arg2 = static_cast< size_t >(val2);
41216 {
41217 PyThreadState* __tstate = wxPyBeginAllowThreads();
41218 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
41219 wxPyEndAllowThreads(__tstate);
41220 if (PyErr_Occurred()) SWIG_fail;
41221 }
41222 {
41223 #if wxUSE_UNICODE
41224 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41225 #else
41226 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41227 #endif
41228 }
41229 return resultobj;
41230 fail:
41231 return NULL;
41232 }
41233
41234
41235 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41236 PyObject *resultobj = 0;
41237 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41238 wxString *arg2 = 0 ;
41239 wxString *arg3 = 0 ;
41240 int result;
41241 void *argp1 = 0 ;
41242 int res1 = 0 ;
41243 bool temp2 = false ;
41244 bool temp3 = false ;
41245 PyObject * obj0 = 0 ;
41246 PyObject * obj1 = 0 ;
41247 PyObject * obj2 = 0 ;
41248 char * kwnames[] = {
41249 (char *) "self",(char *) "menu",(char *) "item", NULL
41250 };
41251
41252 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41253 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41254 if (!SWIG_IsOK(res1)) {
41255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41256 }
41257 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41258 {
41259 arg2 = wxString_in_helper(obj1);
41260 if (arg2 == NULL) SWIG_fail;
41261 temp2 = true;
41262 }
41263 {
41264 arg3 = wxString_in_helper(obj2);
41265 if (arg3 == NULL) SWIG_fail;
41266 temp3 = true;
41267 }
41268 {
41269 PyThreadState* __tstate = wxPyBeginAllowThreads();
41270 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
41271 wxPyEndAllowThreads(__tstate);
41272 if (PyErr_Occurred()) SWIG_fail;
41273 }
41274 resultobj = SWIG_From_int(static_cast< int >(result));
41275 {
41276 if (temp2)
41277 delete arg2;
41278 }
41279 {
41280 if (temp3)
41281 delete arg3;
41282 }
41283 return resultobj;
41284 fail:
41285 {
41286 if (temp2)
41287 delete arg2;
41288 }
41289 {
41290 if (temp3)
41291 delete arg3;
41292 }
41293 return NULL;
41294 }
41295
41296
41297 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41298 PyObject *resultobj = 0;
41299 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41300 int arg2 ;
41301 wxMenuItem *result = 0 ;
41302 void *argp1 = 0 ;
41303 int res1 = 0 ;
41304 int val2 ;
41305 int ecode2 = 0 ;
41306 PyObject * obj0 = 0 ;
41307 PyObject * obj1 = 0 ;
41308 char * kwnames[] = {
41309 (char *) "self",(char *) "id", NULL
41310 };
41311
41312 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
41313 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41314 if (!SWIG_IsOK(res1)) {
41315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41316 }
41317 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41318 ecode2 = SWIG_AsVal_int(obj1, &val2);
41319 if (!SWIG_IsOK(ecode2)) {
41320 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
41321 }
41322 arg2 = static_cast< int >(val2);
41323 {
41324 PyThreadState* __tstate = wxPyBeginAllowThreads();
41325 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
41326 wxPyEndAllowThreads(__tstate);
41327 if (PyErr_Occurred()) SWIG_fail;
41328 }
41329 {
41330 resultobj = wxPyMake_wxObject(result, (bool)0);
41331 }
41332 return resultobj;
41333 fail:
41334 return NULL;
41335 }
41336
41337
41338 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41339 PyObject *resultobj = 0;
41340 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41341 wxString *arg2 = 0 ;
41342 int result;
41343 void *argp1 = 0 ;
41344 int res1 = 0 ;
41345 bool temp2 = false ;
41346 PyObject * obj0 = 0 ;
41347 PyObject * obj1 = 0 ;
41348 char * kwnames[] = {
41349 (char *) "self",(char *) "title", NULL
41350 };
41351
41352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41353 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41354 if (!SWIG_IsOK(res1)) {
41355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41356 }
41357 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41358 {
41359 arg2 = wxString_in_helper(obj1);
41360 if (arg2 == NULL) SWIG_fail;
41361 temp2 = true;
41362 }
41363 {
41364 PyThreadState* __tstate = wxPyBeginAllowThreads();
41365 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
41366 wxPyEndAllowThreads(__tstate);
41367 if (PyErr_Occurred()) SWIG_fail;
41368 }
41369 resultobj = SWIG_From_int(static_cast< int >(result));
41370 {
41371 if (temp2)
41372 delete arg2;
41373 }
41374 return resultobj;
41375 fail:
41376 {
41377 if (temp2)
41378 delete arg2;
41379 }
41380 return NULL;
41381 }
41382
41383
41384 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41385 PyObject *resultobj = 0;
41386 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41387 int arg2 ;
41388 bool arg3 ;
41389 void *argp1 = 0 ;
41390 int res1 = 0 ;
41391 int val2 ;
41392 int ecode2 = 0 ;
41393 bool val3 ;
41394 int ecode3 = 0 ;
41395 PyObject * obj0 = 0 ;
41396 PyObject * obj1 = 0 ;
41397 PyObject * obj2 = 0 ;
41398 char * kwnames[] = {
41399 (char *) "self",(char *) "id",(char *) "enable", NULL
41400 };
41401
41402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41403 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41404 if (!SWIG_IsOK(res1)) {
41405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41406 }
41407 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41408 ecode2 = SWIG_AsVal_int(obj1, &val2);
41409 if (!SWIG_IsOK(ecode2)) {
41410 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
41411 }
41412 arg2 = static_cast< int >(val2);
41413 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41414 if (!SWIG_IsOK(ecode3)) {
41415 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
41416 }
41417 arg3 = static_cast< bool >(val3);
41418 {
41419 PyThreadState* __tstate = wxPyBeginAllowThreads();
41420 (arg1)->Enable(arg2,arg3);
41421 wxPyEndAllowThreads(__tstate);
41422 if (PyErr_Occurred()) SWIG_fail;
41423 }
41424 resultobj = SWIG_Py_Void();
41425 return resultobj;
41426 fail:
41427 return NULL;
41428 }
41429
41430
41431 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41432 PyObject *resultobj = 0;
41433 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41434 int arg2 ;
41435 bool arg3 ;
41436 void *argp1 = 0 ;
41437 int res1 = 0 ;
41438 int val2 ;
41439 int ecode2 = 0 ;
41440 bool val3 ;
41441 int ecode3 = 0 ;
41442 PyObject * obj0 = 0 ;
41443 PyObject * obj1 = 0 ;
41444 PyObject * obj2 = 0 ;
41445 char * kwnames[] = {
41446 (char *) "self",(char *) "id",(char *) "check", NULL
41447 };
41448
41449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41450 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41451 if (!SWIG_IsOK(res1)) {
41452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41453 }
41454 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41455 ecode2 = SWIG_AsVal_int(obj1, &val2);
41456 if (!SWIG_IsOK(ecode2)) {
41457 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
41458 }
41459 arg2 = static_cast< int >(val2);
41460 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41461 if (!SWIG_IsOK(ecode3)) {
41462 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
41463 }
41464 arg3 = static_cast< bool >(val3);
41465 {
41466 PyThreadState* __tstate = wxPyBeginAllowThreads();
41467 (arg1)->Check(arg2,arg3);
41468 wxPyEndAllowThreads(__tstate);
41469 if (PyErr_Occurred()) SWIG_fail;
41470 }
41471 resultobj = SWIG_Py_Void();
41472 return resultobj;
41473 fail:
41474 return NULL;
41475 }
41476
41477
41478 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41479 PyObject *resultobj = 0;
41480 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41481 int arg2 ;
41482 bool result;
41483 void *argp1 = 0 ;
41484 int res1 = 0 ;
41485 int val2 ;
41486 int ecode2 = 0 ;
41487 PyObject * obj0 = 0 ;
41488 PyObject * obj1 = 0 ;
41489 char * kwnames[] = {
41490 (char *) "self",(char *) "id", NULL
41491 };
41492
41493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
41494 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41495 if (!SWIG_IsOK(res1)) {
41496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41497 }
41498 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41499 ecode2 = SWIG_AsVal_int(obj1, &val2);
41500 if (!SWIG_IsOK(ecode2)) {
41501 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
41502 }
41503 arg2 = static_cast< int >(val2);
41504 {
41505 PyThreadState* __tstate = wxPyBeginAllowThreads();
41506 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
41507 wxPyEndAllowThreads(__tstate);
41508 if (PyErr_Occurred()) SWIG_fail;
41509 }
41510 {
41511 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41512 }
41513 return resultobj;
41514 fail:
41515 return NULL;
41516 }
41517
41518
41519 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41520 PyObject *resultobj = 0;
41521 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41522 int arg2 ;
41523 bool result;
41524 void *argp1 = 0 ;
41525 int res1 = 0 ;
41526 int val2 ;
41527 int ecode2 = 0 ;
41528 PyObject * obj0 = 0 ;
41529 PyObject * obj1 = 0 ;
41530 char * kwnames[] = {
41531 (char *) "self",(char *) "id", NULL
41532 };
41533
41534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
41535 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41536 if (!SWIG_IsOK(res1)) {
41537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41538 }
41539 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41540 ecode2 = SWIG_AsVal_int(obj1, &val2);
41541 if (!SWIG_IsOK(ecode2)) {
41542 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
41543 }
41544 arg2 = static_cast< int >(val2);
41545 {
41546 PyThreadState* __tstate = wxPyBeginAllowThreads();
41547 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
41548 wxPyEndAllowThreads(__tstate);
41549 if (PyErr_Occurred()) SWIG_fail;
41550 }
41551 {
41552 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41553 }
41554 return resultobj;
41555 fail:
41556 return NULL;
41557 }
41558
41559
41560 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41561 PyObject *resultobj = 0;
41562 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41563 int arg2 ;
41564 wxString *arg3 = 0 ;
41565 void *argp1 = 0 ;
41566 int res1 = 0 ;
41567 int val2 ;
41568 int ecode2 = 0 ;
41569 bool temp3 = false ;
41570 PyObject * obj0 = 0 ;
41571 PyObject * obj1 = 0 ;
41572 PyObject * obj2 = 0 ;
41573 char * kwnames[] = {
41574 (char *) "self",(char *) "id",(char *) "label", NULL
41575 };
41576
41577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41578 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41579 if (!SWIG_IsOK(res1)) {
41580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41581 }
41582 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41583 ecode2 = SWIG_AsVal_int(obj1, &val2);
41584 if (!SWIG_IsOK(ecode2)) {
41585 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
41586 }
41587 arg2 = static_cast< int >(val2);
41588 {
41589 arg3 = wxString_in_helper(obj2);
41590 if (arg3 == NULL) SWIG_fail;
41591 temp3 = true;
41592 }
41593 {
41594 PyThreadState* __tstate = wxPyBeginAllowThreads();
41595 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
41596 wxPyEndAllowThreads(__tstate);
41597 if (PyErr_Occurred()) SWIG_fail;
41598 }
41599 resultobj = SWIG_Py_Void();
41600 {
41601 if (temp3)
41602 delete arg3;
41603 }
41604 return resultobj;
41605 fail:
41606 {
41607 if (temp3)
41608 delete arg3;
41609 }
41610 return NULL;
41611 }
41612
41613
41614 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41615 PyObject *resultobj = 0;
41616 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41617 int arg2 ;
41618 wxString result;
41619 void *argp1 = 0 ;
41620 int res1 = 0 ;
41621 int val2 ;
41622 int ecode2 = 0 ;
41623 PyObject * obj0 = 0 ;
41624 PyObject * obj1 = 0 ;
41625 char * kwnames[] = {
41626 (char *) "self",(char *) "id", NULL
41627 };
41628
41629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41630 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41631 if (!SWIG_IsOK(res1)) {
41632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41633 }
41634 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41635 ecode2 = SWIG_AsVal_int(obj1, &val2);
41636 if (!SWIG_IsOK(ecode2)) {
41637 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
41638 }
41639 arg2 = static_cast< int >(val2);
41640 {
41641 PyThreadState* __tstate = wxPyBeginAllowThreads();
41642 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
41643 wxPyEndAllowThreads(__tstate);
41644 if (PyErr_Occurred()) SWIG_fail;
41645 }
41646 {
41647 #if wxUSE_UNICODE
41648 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41649 #else
41650 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41651 #endif
41652 }
41653 return resultobj;
41654 fail:
41655 return NULL;
41656 }
41657
41658
41659 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41660 PyObject *resultobj = 0;
41661 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41662 int arg2 ;
41663 wxString *arg3 = 0 ;
41664 void *argp1 = 0 ;
41665 int res1 = 0 ;
41666 int val2 ;
41667 int ecode2 = 0 ;
41668 bool temp3 = false ;
41669 PyObject * obj0 = 0 ;
41670 PyObject * obj1 = 0 ;
41671 PyObject * obj2 = 0 ;
41672 char * kwnames[] = {
41673 (char *) "self",(char *) "id",(char *) "helpString", NULL
41674 };
41675
41676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41677 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41678 if (!SWIG_IsOK(res1)) {
41679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41680 }
41681 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41682 ecode2 = SWIG_AsVal_int(obj1, &val2);
41683 if (!SWIG_IsOK(ecode2)) {
41684 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
41685 }
41686 arg2 = static_cast< int >(val2);
41687 {
41688 arg3 = wxString_in_helper(obj2);
41689 if (arg3 == NULL) SWIG_fail;
41690 temp3 = true;
41691 }
41692 {
41693 PyThreadState* __tstate = wxPyBeginAllowThreads();
41694 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
41695 wxPyEndAllowThreads(__tstate);
41696 if (PyErr_Occurred()) SWIG_fail;
41697 }
41698 resultobj = SWIG_Py_Void();
41699 {
41700 if (temp3)
41701 delete arg3;
41702 }
41703 return resultobj;
41704 fail:
41705 {
41706 if (temp3)
41707 delete arg3;
41708 }
41709 return NULL;
41710 }
41711
41712
41713 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41714 PyObject *resultobj = 0;
41715 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41716 int arg2 ;
41717 wxString result;
41718 void *argp1 = 0 ;
41719 int res1 = 0 ;
41720 int val2 ;
41721 int ecode2 = 0 ;
41722 PyObject * obj0 = 0 ;
41723 PyObject * obj1 = 0 ;
41724 char * kwnames[] = {
41725 (char *) "self",(char *) "id", NULL
41726 };
41727
41728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
41729 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41730 if (!SWIG_IsOK(res1)) {
41731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41732 }
41733 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41734 ecode2 = SWIG_AsVal_int(obj1, &val2);
41735 if (!SWIG_IsOK(ecode2)) {
41736 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
41737 }
41738 arg2 = static_cast< int >(val2);
41739 {
41740 PyThreadState* __tstate = wxPyBeginAllowThreads();
41741 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
41742 wxPyEndAllowThreads(__tstate);
41743 if (PyErr_Occurred()) SWIG_fail;
41744 }
41745 {
41746 #if wxUSE_UNICODE
41747 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41748 #else
41749 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41750 #endif
41751 }
41752 return resultobj;
41753 fail:
41754 return NULL;
41755 }
41756
41757
41758 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41759 PyObject *resultobj = 0;
41760 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41761 wxFrame *result = 0 ;
41762 void *argp1 = 0 ;
41763 int res1 = 0 ;
41764 PyObject *swig_obj[1] ;
41765
41766 if (!args) SWIG_fail;
41767 swig_obj[0] = args;
41768 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41769 if (!SWIG_IsOK(res1)) {
41770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41771 }
41772 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41773 {
41774 PyThreadState* __tstate = wxPyBeginAllowThreads();
41775 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
41776 wxPyEndAllowThreads(__tstate);
41777 if (PyErr_Occurred()) SWIG_fail;
41778 }
41779 {
41780 resultobj = wxPyMake_wxObject(result, (bool)0);
41781 }
41782 return resultobj;
41783 fail:
41784 return NULL;
41785 }
41786
41787
41788 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41789 PyObject *resultobj = 0;
41790 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41791 bool result;
41792 void *argp1 = 0 ;
41793 int res1 = 0 ;
41794 PyObject *swig_obj[1] ;
41795
41796 if (!args) SWIG_fail;
41797 swig_obj[0] = args;
41798 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41799 if (!SWIG_IsOK(res1)) {
41800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41801 }
41802 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41803 {
41804 PyThreadState* __tstate = wxPyBeginAllowThreads();
41805 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
41806 wxPyEndAllowThreads(__tstate);
41807 if (PyErr_Occurred()) SWIG_fail;
41808 }
41809 {
41810 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41811 }
41812 return resultobj;
41813 fail:
41814 return NULL;
41815 }
41816
41817
41818 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41819 PyObject *resultobj = 0;
41820 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41821 wxFrame *arg2 = (wxFrame *) 0 ;
41822 void *argp1 = 0 ;
41823 int res1 = 0 ;
41824 void *argp2 = 0 ;
41825 int res2 = 0 ;
41826 PyObject * obj0 = 0 ;
41827 PyObject * obj1 = 0 ;
41828 char * kwnames[] = {
41829 (char *) "self",(char *) "frame", NULL
41830 };
41831
41832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
41833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41834 if (!SWIG_IsOK(res1)) {
41835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41836 }
41837 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41838 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
41839 if (!SWIG_IsOK(res2)) {
41840 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
41841 }
41842 arg2 = reinterpret_cast< wxFrame * >(argp2);
41843 {
41844 PyThreadState* __tstate = wxPyBeginAllowThreads();
41845 (arg1)->Attach(arg2);
41846 wxPyEndAllowThreads(__tstate);
41847 if (PyErr_Occurred()) SWIG_fail;
41848 }
41849 resultobj = SWIG_Py_Void();
41850 return resultobj;
41851 fail:
41852 return NULL;
41853 }
41854
41855
41856 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41857 PyObject *resultobj = 0;
41858 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41859 void *argp1 = 0 ;
41860 int res1 = 0 ;
41861 PyObject *swig_obj[1] ;
41862
41863 if (!args) SWIG_fail;
41864 swig_obj[0] = args;
41865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41866 if (!SWIG_IsOK(res1)) {
41867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41868 }
41869 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41870 {
41871 PyThreadState* __tstate = wxPyBeginAllowThreads();
41872 (arg1)->Detach();
41873 wxPyEndAllowThreads(__tstate);
41874 if (PyErr_Occurred()) SWIG_fail;
41875 }
41876 resultobj = SWIG_Py_Void();
41877 return resultobj;
41878 fail:
41879 return NULL;
41880 }
41881
41882
41883 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41884 PyObject *resultobj = 0;
41885 bool arg1 ;
41886 bool val1 ;
41887 int ecode1 = 0 ;
41888 PyObject * obj0 = 0 ;
41889 char * kwnames[] = {
41890 (char *) "enable", NULL
41891 };
41892
41893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
41894 ecode1 = SWIG_AsVal_bool(obj0, &val1);
41895 if (!SWIG_IsOK(ecode1)) {
41896 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
41897 }
41898 arg1 = static_cast< bool >(val1);
41899 {
41900 PyThreadState* __tstate = wxPyBeginAllowThreads();
41901 wxMenuBar::SetAutoWindowMenu(arg1);
41902 wxPyEndAllowThreads(__tstate);
41903 if (PyErr_Occurred()) SWIG_fail;
41904 }
41905 resultobj = SWIG_Py_Void();
41906 return resultobj;
41907 fail:
41908 return NULL;
41909 }
41910
41911
41912 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41913 PyObject *resultobj = 0;
41914 bool result;
41915
41916 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
41917 {
41918 PyThreadState* __tstate = wxPyBeginAllowThreads();
41919 result = (bool)wxMenuBar::GetAutoWindowMenu();
41920 wxPyEndAllowThreads(__tstate);
41921 if (PyErr_Occurred()) SWIG_fail;
41922 }
41923 {
41924 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41925 }
41926 return resultobj;
41927 fail:
41928 return NULL;
41929 }
41930
41931
41932 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41933 PyObject *obj;
41934 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41935 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
41936 return SWIG_Py_Void();
41937 }
41938
41939 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41940 return SWIG_Python_InitShadowInstance(args);
41941 }
41942
41943 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41944 PyObject *resultobj = 0;
41945 wxMenu *arg1 = (wxMenu *) NULL ;
41946 int arg2 = (int) wxID_ANY ;
41947 wxString const &arg3_defvalue = wxPyEmptyString ;
41948 wxString *arg3 = (wxString *) &arg3_defvalue ;
41949 wxString const &arg4_defvalue = wxPyEmptyString ;
41950 wxString *arg4 = (wxString *) &arg4_defvalue ;
41951 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
41952 wxMenu *arg6 = (wxMenu *) NULL ;
41953 wxMenuItem *result = 0 ;
41954 void *argp1 = 0 ;
41955 int res1 = 0 ;
41956 int val2 ;
41957 int ecode2 = 0 ;
41958 bool temp3 = false ;
41959 bool temp4 = false ;
41960 int val5 ;
41961 int ecode5 = 0 ;
41962 void *argp6 = 0 ;
41963 int res6 = 0 ;
41964 PyObject * obj0 = 0 ;
41965 PyObject * obj1 = 0 ;
41966 PyObject * obj2 = 0 ;
41967 PyObject * obj3 = 0 ;
41968 PyObject * obj4 = 0 ;
41969 PyObject * obj5 = 0 ;
41970 char * kwnames[] = {
41971 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
41972 };
41973
41974 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
41975 if (obj0) {
41976 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41977 if (!SWIG_IsOK(res1)) {
41978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
41979 }
41980 arg1 = reinterpret_cast< wxMenu * >(argp1);
41981 }
41982 if (obj1) {
41983 ecode2 = SWIG_AsVal_int(obj1, &val2);
41984 if (!SWIG_IsOK(ecode2)) {
41985 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
41986 }
41987 arg2 = static_cast< int >(val2);
41988 }
41989 if (obj2) {
41990 {
41991 arg3 = wxString_in_helper(obj2);
41992 if (arg3 == NULL) SWIG_fail;
41993 temp3 = true;
41994 }
41995 }
41996 if (obj3) {
41997 {
41998 arg4 = wxString_in_helper(obj3);
41999 if (arg4 == NULL) SWIG_fail;
42000 temp4 = true;
42001 }
42002 }
42003 if (obj4) {
42004 ecode5 = SWIG_AsVal_int(obj4, &val5);
42005 if (!SWIG_IsOK(ecode5)) {
42006 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
42007 }
42008 arg5 = static_cast< wxItemKind >(val5);
42009 }
42010 if (obj5) {
42011 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
42012 if (!SWIG_IsOK(res6)) {
42013 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
42014 }
42015 arg6 = reinterpret_cast< wxMenu * >(argp6);
42016 }
42017 {
42018 PyThreadState* __tstate = wxPyBeginAllowThreads();
42019 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
42020 wxPyEndAllowThreads(__tstate);
42021 if (PyErr_Occurred()) SWIG_fail;
42022 }
42023 {
42024 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
42025 }
42026 {
42027 if (temp3)
42028 delete arg3;
42029 }
42030 {
42031 if (temp4)
42032 delete arg4;
42033 }
42034 return resultobj;
42035 fail:
42036 {
42037 if (temp3)
42038 delete arg3;
42039 }
42040 {
42041 if (temp4)
42042 delete arg4;
42043 }
42044 return NULL;
42045 }
42046
42047
42048 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42049 PyObject *resultobj = 0;
42050 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42051 void *argp1 = 0 ;
42052 int res1 = 0 ;
42053 PyObject *swig_obj[1] ;
42054
42055 if (!args) SWIG_fail;
42056 swig_obj[0] = args;
42057 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42058 if (!SWIG_IsOK(res1)) {
42059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42060 }
42061 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42062 {
42063 PyThreadState* __tstate = wxPyBeginAllowThreads();
42064 delete arg1;
42065
42066 wxPyEndAllowThreads(__tstate);
42067 if (PyErr_Occurred()) SWIG_fail;
42068 }
42069 resultobj = SWIG_Py_Void();
42070 return resultobj;
42071 fail:
42072 return NULL;
42073 }
42074
42075
42076 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42077 PyObject *resultobj = 0;
42078 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42079 wxMenu *result = 0 ;
42080 void *argp1 = 0 ;
42081 int res1 = 0 ;
42082 PyObject *swig_obj[1] ;
42083
42084 if (!args) SWIG_fail;
42085 swig_obj[0] = args;
42086 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42087 if (!SWIG_IsOK(res1)) {
42088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42089 }
42090 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42091 {
42092 PyThreadState* __tstate = wxPyBeginAllowThreads();
42093 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
42094 wxPyEndAllowThreads(__tstate);
42095 if (PyErr_Occurred()) SWIG_fail;
42096 }
42097 {
42098 resultobj = wxPyMake_wxObject(result, 0);
42099 }
42100 return resultobj;
42101 fail:
42102 return NULL;
42103 }
42104
42105
42106 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42107 PyObject *resultobj = 0;
42108 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42109 wxMenu *arg2 = (wxMenu *) 0 ;
42110 void *argp1 = 0 ;
42111 int res1 = 0 ;
42112 void *argp2 = 0 ;
42113 int res2 = 0 ;
42114 PyObject * obj0 = 0 ;
42115 PyObject * obj1 = 0 ;
42116 char * kwnames[] = {
42117 (char *) "self",(char *) "menu", NULL
42118 };
42119
42120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42121 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42122 if (!SWIG_IsOK(res1)) {
42123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42124 }
42125 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42126 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42127 if (!SWIG_IsOK(res2)) {
42128 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42129 }
42130 arg2 = reinterpret_cast< wxMenu * >(argp2);
42131 {
42132 PyThreadState* __tstate = wxPyBeginAllowThreads();
42133 (arg1)->SetMenu(arg2);
42134 wxPyEndAllowThreads(__tstate);
42135 if (PyErr_Occurred()) SWIG_fail;
42136 }
42137 resultobj = SWIG_Py_Void();
42138 return resultobj;
42139 fail:
42140 return NULL;
42141 }
42142
42143
42144 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42145 PyObject *resultobj = 0;
42146 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42147 int arg2 ;
42148 void *argp1 = 0 ;
42149 int res1 = 0 ;
42150 int val2 ;
42151 int ecode2 = 0 ;
42152 PyObject * obj0 = 0 ;
42153 PyObject * obj1 = 0 ;
42154 char * kwnames[] = {
42155 (char *) "self",(char *) "id", NULL
42156 };
42157
42158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
42159 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42160 if (!SWIG_IsOK(res1)) {
42161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42162 }
42163 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42164 ecode2 = SWIG_AsVal_int(obj1, &val2);
42165 if (!SWIG_IsOK(ecode2)) {
42166 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
42167 }
42168 arg2 = static_cast< int >(val2);
42169 {
42170 PyThreadState* __tstate = wxPyBeginAllowThreads();
42171 (arg1)->SetId(arg2);
42172 wxPyEndAllowThreads(__tstate);
42173 if (PyErr_Occurred()) SWIG_fail;
42174 }
42175 resultobj = SWIG_Py_Void();
42176 return resultobj;
42177 fail:
42178 return NULL;
42179 }
42180
42181
42182 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42183 PyObject *resultobj = 0;
42184 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42185 int result;
42186 void *argp1 = 0 ;
42187 int res1 = 0 ;
42188 PyObject *swig_obj[1] ;
42189
42190 if (!args) SWIG_fail;
42191 swig_obj[0] = args;
42192 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42193 if (!SWIG_IsOK(res1)) {
42194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42195 }
42196 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42197 {
42198 PyThreadState* __tstate = wxPyBeginAllowThreads();
42199 result = (int)((wxMenuItem const *)arg1)->GetId();
42200 wxPyEndAllowThreads(__tstate);
42201 if (PyErr_Occurred()) SWIG_fail;
42202 }
42203 resultobj = SWIG_From_int(static_cast< int >(result));
42204 return resultobj;
42205 fail:
42206 return NULL;
42207 }
42208
42209
42210 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42211 PyObject *resultobj = 0;
42212 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42213 bool result;
42214 void *argp1 = 0 ;
42215 int res1 = 0 ;
42216 PyObject *swig_obj[1] ;
42217
42218 if (!args) SWIG_fail;
42219 swig_obj[0] = args;
42220 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42221 if (!SWIG_IsOK(res1)) {
42222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42223 }
42224 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42225 {
42226 PyThreadState* __tstate = wxPyBeginAllowThreads();
42227 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
42228 wxPyEndAllowThreads(__tstate);
42229 if (PyErr_Occurred()) SWIG_fail;
42230 }
42231 {
42232 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42233 }
42234 return resultobj;
42235 fail:
42236 return NULL;
42237 }
42238
42239
42240 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42241 PyObject *resultobj = 0;
42242 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42243 wxString *arg2 = 0 ;
42244 void *argp1 = 0 ;
42245 int res1 = 0 ;
42246 bool temp2 = false ;
42247 PyObject * obj0 = 0 ;
42248 PyObject * obj1 = 0 ;
42249 char * kwnames[] = {
42250 (char *) "self",(char *) "str", NULL
42251 };
42252
42253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
42254 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42255 if (!SWIG_IsOK(res1)) {
42256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42257 }
42258 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42259 {
42260 arg2 = wxString_in_helper(obj1);
42261 if (arg2 == NULL) SWIG_fail;
42262 temp2 = true;
42263 }
42264 {
42265 PyThreadState* __tstate = wxPyBeginAllowThreads();
42266 (arg1)->SetText((wxString const &)*arg2);
42267 wxPyEndAllowThreads(__tstate);
42268 if (PyErr_Occurred()) SWIG_fail;
42269 }
42270 resultobj = SWIG_Py_Void();
42271 {
42272 if (temp2)
42273 delete arg2;
42274 }
42275 return resultobj;
42276 fail:
42277 {
42278 if (temp2)
42279 delete arg2;
42280 }
42281 return NULL;
42282 }
42283
42284
42285 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42286 PyObject *resultobj = 0;
42287 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42288 wxString result;
42289 void *argp1 = 0 ;
42290 int res1 = 0 ;
42291 PyObject *swig_obj[1] ;
42292
42293 if (!args) SWIG_fail;
42294 swig_obj[0] = args;
42295 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42296 if (!SWIG_IsOK(res1)) {
42297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42298 }
42299 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42300 {
42301 PyThreadState* __tstate = wxPyBeginAllowThreads();
42302 result = ((wxMenuItem const *)arg1)->GetLabel();
42303 wxPyEndAllowThreads(__tstate);
42304 if (PyErr_Occurred()) SWIG_fail;
42305 }
42306 {
42307 #if wxUSE_UNICODE
42308 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42309 #else
42310 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42311 #endif
42312 }
42313 return resultobj;
42314 fail:
42315 return NULL;
42316 }
42317
42318
42319 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42320 PyObject *resultobj = 0;
42321 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42322 wxString *result = 0 ;
42323 void *argp1 = 0 ;
42324 int res1 = 0 ;
42325 PyObject *swig_obj[1] ;
42326
42327 if (!args) SWIG_fail;
42328 swig_obj[0] = args;
42329 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42330 if (!SWIG_IsOK(res1)) {
42331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42332 }
42333 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42334 {
42335 PyThreadState* __tstate = wxPyBeginAllowThreads();
42336 {
42337 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
42338 result = (wxString *) &_result_ref;
42339 }
42340 wxPyEndAllowThreads(__tstate);
42341 if (PyErr_Occurred()) SWIG_fail;
42342 }
42343 {
42344 #if wxUSE_UNICODE
42345 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
42346 #else
42347 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
42348 #endif
42349 }
42350 return resultobj;
42351 fail:
42352 return NULL;
42353 }
42354
42355
42356 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42357 PyObject *resultobj = 0;
42358 wxString *arg1 = 0 ;
42359 wxString result;
42360 bool temp1 = false ;
42361 PyObject * obj0 = 0 ;
42362 char * kwnames[] = {
42363 (char *) "text", NULL
42364 };
42365
42366 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
42367 {
42368 arg1 = wxString_in_helper(obj0);
42369 if (arg1 == NULL) SWIG_fail;
42370 temp1 = true;
42371 }
42372 {
42373 PyThreadState* __tstate = wxPyBeginAllowThreads();
42374 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
42375 wxPyEndAllowThreads(__tstate);
42376 if (PyErr_Occurred()) SWIG_fail;
42377 }
42378 {
42379 #if wxUSE_UNICODE
42380 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42381 #else
42382 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42383 #endif
42384 }
42385 {
42386 if (temp1)
42387 delete arg1;
42388 }
42389 return resultobj;
42390 fail:
42391 {
42392 if (temp1)
42393 delete arg1;
42394 }
42395 return NULL;
42396 }
42397
42398
42399 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42400 PyObject *resultobj = 0;
42401 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42402 wxItemKind result;
42403 void *argp1 = 0 ;
42404 int res1 = 0 ;
42405 PyObject *swig_obj[1] ;
42406
42407 if (!args) SWIG_fail;
42408 swig_obj[0] = args;
42409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42410 if (!SWIG_IsOK(res1)) {
42411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42412 }
42413 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42414 {
42415 PyThreadState* __tstate = wxPyBeginAllowThreads();
42416 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
42417 wxPyEndAllowThreads(__tstate);
42418 if (PyErr_Occurred()) SWIG_fail;
42419 }
42420 resultobj = SWIG_From_int(static_cast< int >(result));
42421 return resultobj;
42422 fail:
42423 return NULL;
42424 }
42425
42426
42427 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42428 PyObject *resultobj = 0;
42429 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42430 wxItemKind arg2 ;
42431 void *argp1 = 0 ;
42432 int res1 = 0 ;
42433 int val2 ;
42434 int ecode2 = 0 ;
42435 PyObject * obj0 = 0 ;
42436 PyObject * obj1 = 0 ;
42437 char * kwnames[] = {
42438 (char *) "self",(char *) "kind", NULL
42439 };
42440
42441 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
42442 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42443 if (!SWIG_IsOK(res1)) {
42444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42445 }
42446 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42447 ecode2 = SWIG_AsVal_int(obj1, &val2);
42448 if (!SWIG_IsOK(ecode2)) {
42449 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
42450 }
42451 arg2 = static_cast< wxItemKind >(val2);
42452 {
42453 PyThreadState* __tstate = wxPyBeginAllowThreads();
42454 (arg1)->SetKind(arg2);
42455 wxPyEndAllowThreads(__tstate);
42456 if (PyErr_Occurred()) SWIG_fail;
42457 }
42458 resultobj = SWIG_Py_Void();
42459 return resultobj;
42460 fail:
42461 return NULL;
42462 }
42463
42464
42465 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42466 PyObject *resultobj = 0;
42467 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42468 bool arg2 ;
42469 void *argp1 = 0 ;
42470 int res1 = 0 ;
42471 bool val2 ;
42472 int ecode2 = 0 ;
42473 PyObject * obj0 = 0 ;
42474 PyObject * obj1 = 0 ;
42475 char * kwnames[] = {
42476 (char *) "self",(char *) "checkable", NULL
42477 };
42478
42479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
42480 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42481 if (!SWIG_IsOK(res1)) {
42482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42483 }
42484 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42485 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42486 if (!SWIG_IsOK(ecode2)) {
42487 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
42488 }
42489 arg2 = static_cast< bool >(val2);
42490 {
42491 PyThreadState* __tstate = wxPyBeginAllowThreads();
42492 (arg1)->SetCheckable(arg2);
42493 wxPyEndAllowThreads(__tstate);
42494 if (PyErr_Occurred()) SWIG_fail;
42495 }
42496 resultobj = SWIG_Py_Void();
42497 return resultobj;
42498 fail:
42499 return NULL;
42500 }
42501
42502
42503 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42504 PyObject *resultobj = 0;
42505 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42506 bool result;
42507 void *argp1 = 0 ;
42508 int res1 = 0 ;
42509 PyObject *swig_obj[1] ;
42510
42511 if (!args) SWIG_fail;
42512 swig_obj[0] = args;
42513 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42514 if (!SWIG_IsOK(res1)) {
42515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42516 }
42517 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42518 {
42519 PyThreadState* __tstate = wxPyBeginAllowThreads();
42520 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
42521 wxPyEndAllowThreads(__tstate);
42522 if (PyErr_Occurred()) SWIG_fail;
42523 }
42524 {
42525 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42526 }
42527 return resultobj;
42528 fail:
42529 return NULL;
42530 }
42531
42532
42533 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42534 PyObject *resultobj = 0;
42535 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42536 bool result;
42537 void *argp1 = 0 ;
42538 int res1 = 0 ;
42539 PyObject *swig_obj[1] ;
42540
42541 if (!args) SWIG_fail;
42542 swig_obj[0] = args;
42543 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42544 if (!SWIG_IsOK(res1)) {
42545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42546 }
42547 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42548 {
42549 PyThreadState* __tstate = wxPyBeginAllowThreads();
42550 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
42551 wxPyEndAllowThreads(__tstate);
42552 if (PyErr_Occurred()) SWIG_fail;
42553 }
42554 {
42555 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42556 }
42557 return resultobj;
42558 fail:
42559 return NULL;
42560 }
42561
42562
42563 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42564 PyObject *resultobj = 0;
42565 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42566 wxMenu *arg2 = (wxMenu *) 0 ;
42567 void *argp1 = 0 ;
42568 int res1 = 0 ;
42569 void *argp2 = 0 ;
42570 int res2 = 0 ;
42571 PyObject * obj0 = 0 ;
42572 PyObject * obj1 = 0 ;
42573 char * kwnames[] = {
42574 (char *) "self",(char *) "menu", NULL
42575 };
42576
42577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42578 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42579 if (!SWIG_IsOK(res1)) {
42580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42581 }
42582 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42583 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42584 if (!SWIG_IsOK(res2)) {
42585 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42586 }
42587 arg2 = reinterpret_cast< wxMenu * >(argp2);
42588 {
42589 PyThreadState* __tstate = wxPyBeginAllowThreads();
42590 (arg1)->SetSubMenu(arg2);
42591 wxPyEndAllowThreads(__tstate);
42592 if (PyErr_Occurred()) SWIG_fail;
42593 }
42594 resultobj = SWIG_Py_Void();
42595 return resultobj;
42596 fail:
42597 return NULL;
42598 }
42599
42600
42601 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42602 PyObject *resultobj = 0;
42603 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42604 wxMenu *result = 0 ;
42605 void *argp1 = 0 ;
42606 int res1 = 0 ;
42607 PyObject *swig_obj[1] ;
42608
42609 if (!args) SWIG_fail;
42610 swig_obj[0] = args;
42611 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42612 if (!SWIG_IsOK(res1)) {
42613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42614 }
42615 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42616 {
42617 PyThreadState* __tstate = wxPyBeginAllowThreads();
42618 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
42619 wxPyEndAllowThreads(__tstate);
42620 if (PyErr_Occurred()) SWIG_fail;
42621 }
42622 {
42623 resultobj = wxPyMake_wxObject(result, 0);
42624 }
42625 return resultobj;
42626 fail:
42627 return NULL;
42628 }
42629
42630
42631 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42632 PyObject *resultobj = 0;
42633 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42634 bool arg2 = (bool) true ;
42635 void *argp1 = 0 ;
42636 int res1 = 0 ;
42637 bool val2 ;
42638 int ecode2 = 0 ;
42639 PyObject * obj0 = 0 ;
42640 PyObject * obj1 = 0 ;
42641 char * kwnames[] = {
42642 (char *) "self",(char *) "enable", NULL
42643 };
42644
42645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
42646 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42647 if (!SWIG_IsOK(res1)) {
42648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42649 }
42650 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42651 if (obj1) {
42652 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42653 if (!SWIG_IsOK(ecode2)) {
42654 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
42655 }
42656 arg2 = static_cast< bool >(val2);
42657 }
42658 {
42659 PyThreadState* __tstate = wxPyBeginAllowThreads();
42660 (arg1)->Enable(arg2);
42661 wxPyEndAllowThreads(__tstate);
42662 if (PyErr_Occurred()) SWIG_fail;
42663 }
42664 resultobj = SWIG_Py_Void();
42665 return resultobj;
42666 fail:
42667 return NULL;
42668 }
42669
42670
42671 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42672 PyObject *resultobj = 0;
42673 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42674 bool result;
42675 void *argp1 = 0 ;
42676 int res1 = 0 ;
42677 PyObject *swig_obj[1] ;
42678
42679 if (!args) SWIG_fail;
42680 swig_obj[0] = args;
42681 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42682 if (!SWIG_IsOK(res1)) {
42683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42684 }
42685 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42686 {
42687 PyThreadState* __tstate = wxPyBeginAllowThreads();
42688 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
42689 wxPyEndAllowThreads(__tstate);
42690 if (PyErr_Occurred()) SWIG_fail;
42691 }
42692 {
42693 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42694 }
42695 return resultobj;
42696 fail:
42697 return NULL;
42698 }
42699
42700
42701 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42702 PyObject *resultobj = 0;
42703 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42704 bool arg2 = (bool) true ;
42705 void *argp1 = 0 ;
42706 int res1 = 0 ;
42707 bool val2 ;
42708 int ecode2 = 0 ;
42709 PyObject * obj0 = 0 ;
42710 PyObject * obj1 = 0 ;
42711 char * kwnames[] = {
42712 (char *) "self",(char *) "check", NULL
42713 };
42714
42715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
42716 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42717 if (!SWIG_IsOK(res1)) {
42718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42719 }
42720 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42721 if (obj1) {
42722 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42723 if (!SWIG_IsOK(ecode2)) {
42724 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
42725 }
42726 arg2 = static_cast< bool >(val2);
42727 }
42728 {
42729 PyThreadState* __tstate = wxPyBeginAllowThreads();
42730 (arg1)->Check(arg2);
42731 wxPyEndAllowThreads(__tstate);
42732 if (PyErr_Occurred()) SWIG_fail;
42733 }
42734 resultobj = SWIG_Py_Void();
42735 return resultobj;
42736 fail:
42737 return NULL;
42738 }
42739
42740
42741 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42742 PyObject *resultobj = 0;
42743 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42744 bool result;
42745 void *argp1 = 0 ;
42746 int res1 = 0 ;
42747 PyObject *swig_obj[1] ;
42748
42749 if (!args) SWIG_fail;
42750 swig_obj[0] = args;
42751 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42752 if (!SWIG_IsOK(res1)) {
42753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42754 }
42755 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42756 {
42757 PyThreadState* __tstate = wxPyBeginAllowThreads();
42758 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
42759 wxPyEndAllowThreads(__tstate);
42760 if (PyErr_Occurred()) SWIG_fail;
42761 }
42762 {
42763 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42764 }
42765 return resultobj;
42766 fail:
42767 return NULL;
42768 }
42769
42770
42771 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42772 PyObject *resultobj = 0;
42773 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42774 void *argp1 = 0 ;
42775 int res1 = 0 ;
42776 PyObject *swig_obj[1] ;
42777
42778 if (!args) SWIG_fail;
42779 swig_obj[0] = args;
42780 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42781 if (!SWIG_IsOK(res1)) {
42782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42783 }
42784 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42785 {
42786 PyThreadState* __tstate = wxPyBeginAllowThreads();
42787 (arg1)->Toggle();
42788 wxPyEndAllowThreads(__tstate);
42789 if (PyErr_Occurred()) SWIG_fail;
42790 }
42791 resultobj = SWIG_Py_Void();
42792 return resultobj;
42793 fail:
42794 return NULL;
42795 }
42796
42797
42798 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42799 PyObject *resultobj = 0;
42800 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42801 wxString *arg2 = 0 ;
42802 void *argp1 = 0 ;
42803 int res1 = 0 ;
42804 bool temp2 = false ;
42805 PyObject * obj0 = 0 ;
42806 PyObject * obj1 = 0 ;
42807 char * kwnames[] = {
42808 (char *) "self",(char *) "str", NULL
42809 };
42810
42811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
42812 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42813 if (!SWIG_IsOK(res1)) {
42814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42815 }
42816 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42817 {
42818 arg2 = wxString_in_helper(obj1);
42819 if (arg2 == NULL) SWIG_fail;
42820 temp2 = true;
42821 }
42822 {
42823 PyThreadState* __tstate = wxPyBeginAllowThreads();
42824 (arg1)->SetHelp((wxString const &)*arg2);
42825 wxPyEndAllowThreads(__tstate);
42826 if (PyErr_Occurred()) SWIG_fail;
42827 }
42828 resultobj = SWIG_Py_Void();
42829 {
42830 if (temp2)
42831 delete arg2;
42832 }
42833 return resultobj;
42834 fail:
42835 {
42836 if (temp2)
42837 delete arg2;
42838 }
42839 return NULL;
42840 }
42841
42842
42843 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42844 PyObject *resultobj = 0;
42845 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42846 wxString *result = 0 ;
42847 void *argp1 = 0 ;
42848 int res1 = 0 ;
42849 PyObject *swig_obj[1] ;
42850
42851 if (!args) SWIG_fail;
42852 swig_obj[0] = args;
42853 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42854 if (!SWIG_IsOK(res1)) {
42855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42856 }
42857 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42858 {
42859 PyThreadState* __tstate = wxPyBeginAllowThreads();
42860 {
42861 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
42862 result = (wxString *) &_result_ref;
42863 }
42864 wxPyEndAllowThreads(__tstate);
42865 if (PyErr_Occurred()) SWIG_fail;
42866 }
42867 {
42868 #if wxUSE_UNICODE
42869 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
42870 #else
42871 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
42872 #endif
42873 }
42874 return resultobj;
42875 fail:
42876 return NULL;
42877 }
42878
42879
42880 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42881 PyObject *resultobj = 0;
42882 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42883 wxAcceleratorEntry *result = 0 ;
42884 void *argp1 = 0 ;
42885 int res1 = 0 ;
42886 PyObject *swig_obj[1] ;
42887
42888 if (!args) SWIG_fail;
42889 swig_obj[0] = args;
42890 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42891 if (!SWIG_IsOK(res1)) {
42892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42893 }
42894 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42895 {
42896 PyThreadState* __tstate = wxPyBeginAllowThreads();
42897 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
42898 wxPyEndAllowThreads(__tstate);
42899 if (PyErr_Occurred()) SWIG_fail;
42900 }
42901 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
42902 return resultobj;
42903 fail:
42904 return NULL;
42905 }
42906
42907
42908 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42909 PyObject *resultobj = 0;
42910 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42911 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
42912 void *argp1 = 0 ;
42913 int res1 = 0 ;
42914 void *argp2 = 0 ;
42915 int res2 = 0 ;
42916 PyObject * obj0 = 0 ;
42917 PyObject * obj1 = 0 ;
42918 char * kwnames[] = {
42919 (char *) "self",(char *) "accel", NULL
42920 };
42921
42922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
42923 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42924 if (!SWIG_IsOK(res1)) {
42925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42926 }
42927 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42928 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
42929 if (!SWIG_IsOK(res2)) {
42930 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
42931 }
42932 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
42933 {
42934 PyThreadState* __tstate = wxPyBeginAllowThreads();
42935 (arg1)->SetAccel(arg2);
42936 wxPyEndAllowThreads(__tstate);
42937 if (PyErr_Occurred()) SWIG_fail;
42938 }
42939 resultobj = SWIG_Py_Void();
42940 return resultobj;
42941 fail:
42942 return NULL;
42943 }
42944
42945
42946 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42947 PyObject *resultobj = 0;
42948 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42949 wxBitmap *arg2 = 0 ;
42950 void *argp1 = 0 ;
42951 int res1 = 0 ;
42952 void *argp2 = 0 ;
42953 int res2 = 0 ;
42954 PyObject * obj0 = 0 ;
42955 PyObject * obj1 = 0 ;
42956 char * kwnames[] = {
42957 (char *) "self",(char *) "bitmap", NULL
42958 };
42959
42960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
42961 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42962 if (!SWIG_IsOK(res1)) {
42963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42964 }
42965 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42966 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
42967 if (!SWIG_IsOK(res2)) {
42968 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
42969 }
42970 if (!argp2) {
42971 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
42972 }
42973 arg2 = reinterpret_cast< wxBitmap * >(argp2);
42974 {
42975 PyThreadState* __tstate = wxPyBeginAllowThreads();
42976 (arg1)->SetBitmap((wxBitmap const &)*arg2);
42977 wxPyEndAllowThreads(__tstate);
42978 if (PyErr_Occurred()) SWIG_fail;
42979 }
42980 resultobj = SWIG_Py_Void();
42981 return resultobj;
42982 fail:
42983 return NULL;
42984 }
42985
42986
42987 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42988 PyObject *resultobj = 0;
42989 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42990 wxBitmap *result = 0 ;
42991 void *argp1 = 0 ;
42992 int res1 = 0 ;
42993 PyObject *swig_obj[1] ;
42994
42995 if (!args) SWIG_fail;
42996 swig_obj[0] = args;
42997 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42998 if (!SWIG_IsOK(res1)) {
42999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43000 }
43001 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43002 {
43003 PyThreadState* __tstate = wxPyBeginAllowThreads();
43004 {
43005 wxBitmap const &_result_ref = (arg1)->GetBitmap();
43006 result = (wxBitmap *) &_result_ref;
43007 }
43008 wxPyEndAllowThreads(__tstate);
43009 if (PyErr_Occurred()) SWIG_fail;
43010 }
43011 {
43012 wxBitmap* resultptr = new wxBitmap(*result);
43013 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43014 }
43015 return resultobj;
43016 fail:
43017 return NULL;
43018 }
43019
43020
43021 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43022 PyObject *resultobj = 0;
43023 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43024 wxFont *arg2 = 0 ;
43025 void *argp1 = 0 ;
43026 int res1 = 0 ;
43027 void *argp2 = 0 ;
43028 int res2 = 0 ;
43029 PyObject * obj0 = 0 ;
43030 PyObject * obj1 = 0 ;
43031 char * kwnames[] = {
43032 (char *) "self",(char *) "font", NULL
43033 };
43034
43035 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
43036 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43037 if (!SWIG_IsOK(res1)) {
43038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43039 }
43040 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43041 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
43042 if (!SWIG_IsOK(res2)) {
43043 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
43044 }
43045 if (!argp2) {
43046 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
43047 }
43048 arg2 = reinterpret_cast< wxFont * >(argp2);
43049 {
43050 PyThreadState* __tstate = wxPyBeginAllowThreads();
43051 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
43052 wxPyEndAllowThreads(__tstate);
43053 if (PyErr_Occurred()) SWIG_fail;
43054 }
43055 resultobj = SWIG_Py_Void();
43056 return resultobj;
43057 fail:
43058 return NULL;
43059 }
43060
43061
43062 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43063 PyObject *resultobj = 0;
43064 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43065 wxFont result;
43066 void *argp1 = 0 ;
43067 int res1 = 0 ;
43068 PyObject *swig_obj[1] ;
43069
43070 if (!args) SWIG_fail;
43071 swig_obj[0] = args;
43072 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43073 if (!SWIG_IsOK(res1)) {
43074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43075 }
43076 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43077 {
43078 PyThreadState* __tstate = wxPyBeginAllowThreads();
43079 result = wxMenuItem_GetFont(arg1);
43080 wxPyEndAllowThreads(__tstate);
43081 if (PyErr_Occurred()) SWIG_fail;
43082 }
43083 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
43084 return resultobj;
43085 fail:
43086 return NULL;
43087 }
43088
43089
43090 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43091 PyObject *resultobj = 0;
43092 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43093 wxColour *arg2 = 0 ;
43094 void *argp1 = 0 ;
43095 int res1 = 0 ;
43096 wxColour temp2 ;
43097 PyObject * obj0 = 0 ;
43098 PyObject * obj1 = 0 ;
43099 char * kwnames[] = {
43100 (char *) "self",(char *) "colText", NULL
43101 };
43102
43103 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
43104 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43105 if (!SWIG_IsOK(res1)) {
43106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43107 }
43108 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43109 {
43110 arg2 = &temp2;
43111 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43112 }
43113 {
43114 PyThreadState* __tstate = wxPyBeginAllowThreads();
43115 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
43116 wxPyEndAllowThreads(__tstate);
43117 if (PyErr_Occurred()) SWIG_fail;
43118 }
43119 resultobj = SWIG_Py_Void();
43120 return resultobj;
43121 fail:
43122 return NULL;
43123 }
43124
43125
43126 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43127 PyObject *resultobj = 0;
43128 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43129 wxColour result;
43130 void *argp1 = 0 ;
43131 int res1 = 0 ;
43132 PyObject *swig_obj[1] ;
43133
43134 if (!args) SWIG_fail;
43135 swig_obj[0] = args;
43136 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43137 if (!SWIG_IsOK(res1)) {
43138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43139 }
43140 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43141 {
43142 PyThreadState* __tstate = wxPyBeginAllowThreads();
43143 result = wxMenuItem_GetTextColour(arg1);
43144 wxPyEndAllowThreads(__tstate);
43145 if (PyErr_Occurred()) SWIG_fail;
43146 }
43147 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43148 return resultobj;
43149 fail:
43150 return NULL;
43151 }
43152
43153
43154 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43155 PyObject *resultobj = 0;
43156 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43157 wxColour *arg2 = 0 ;
43158 void *argp1 = 0 ;
43159 int res1 = 0 ;
43160 wxColour temp2 ;
43161 PyObject * obj0 = 0 ;
43162 PyObject * obj1 = 0 ;
43163 char * kwnames[] = {
43164 (char *) "self",(char *) "colBack", NULL
43165 };
43166
43167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
43168 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43169 if (!SWIG_IsOK(res1)) {
43170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43171 }
43172 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43173 {
43174 arg2 = &temp2;
43175 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43176 }
43177 {
43178 PyThreadState* __tstate = wxPyBeginAllowThreads();
43179 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
43180 wxPyEndAllowThreads(__tstate);
43181 if (PyErr_Occurred()) SWIG_fail;
43182 }
43183 resultobj = SWIG_Py_Void();
43184 return resultobj;
43185 fail:
43186 return NULL;
43187 }
43188
43189
43190 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43191 PyObject *resultobj = 0;
43192 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43193 wxColour result;
43194 void *argp1 = 0 ;
43195 int res1 = 0 ;
43196 PyObject *swig_obj[1] ;
43197
43198 if (!args) SWIG_fail;
43199 swig_obj[0] = args;
43200 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43201 if (!SWIG_IsOK(res1)) {
43202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43203 }
43204 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43205 {
43206 PyThreadState* __tstate = wxPyBeginAllowThreads();
43207 result = wxMenuItem_GetBackgroundColour(arg1);
43208 wxPyEndAllowThreads(__tstate);
43209 if (PyErr_Occurred()) SWIG_fail;
43210 }
43211 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43212 return resultobj;
43213 fail:
43214 return NULL;
43215 }
43216
43217
43218 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43219 PyObject *resultobj = 0;
43220 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43221 wxBitmap *arg2 = 0 ;
43222 wxBitmap const &arg3_defvalue = wxNullBitmap ;
43223 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
43224 void *argp1 = 0 ;
43225 int res1 = 0 ;
43226 void *argp2 = 0 ;
43227 int res2 = 0 ;
43228 void *argp3 = 0 ;
43229 int res3 = 0 ;
43230 PyObject * obj0 = 0 ;
43231 PyObject * obj1 = 0 ;
43232 PyObject * obj2 = 0 ;
43233 char * kwnames[] = {
43234 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
43235 };
43236
43237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43238 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43239 if (!SWIG_IsOK(res1)) {
43240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43241 }
43242 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43243 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43244 if (!SWIG_IsOK(res2)) {
43245 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43246 }
43247 if (!argp2) {
43248 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43249 }
43250 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43251 if (obj2) {
43252 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
43253 if (!SWIG_IsOK(res3)) {
43254 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43255 }
43256 if (!argp3) {
43257 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43258 }
43259 arg3 = reinterpret_cast< wxBitmap * >(argp3);
43260 }
43261 {
43262 PyThreadState* __tstate = wxPyBeginAllowThreads();
43263 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
43264 wxPyEndAllowThreads(__tstate);
43265 if (PyErr_Occurred()) SWIG_fail;
43266 }
43267 resultobj = SWIG_Py_Void();
43268 return resultobj;
43269 fail:
43270 return NULL;
43271 }
43272
43273
43274 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43275 PyObject *resultobj = 0;
43276 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43277 wxBitmap *arg2 = 0 ;
43278 void *argp1 = 0 ;
43279 int res1 = 0 ;
43280 void *argp2 = 0 ;
43281 int res2 = 0 ;
43282 PyObject * obj0 = 0 ;
43283 PyObject * obj1 = 0 ;
43284 char * kwnames[] = {
43285 (char *) "self",(char *) "bmpDisabled", NULL
43286 };
43287
43288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43289 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43290 if (!SWIG_IsOK(res1)) {
43291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43292 }
43293 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43294 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43295 if (!SWIG_IsOK(res2)) {
43296 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43297 }
43298 if (!argp2) {
43299 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43300 }
43301 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43302 {
43303 PyThreadState* __tstate = wxPyBeginAllowThreads();
43304 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
43305 wxPyEndAllowThreads(__tstate);
43306 if (PyErr_Occurred()) SWIG_fail;
43307 }
43308 resultobj = SWIG_Py_Void();
43309 return resultobj;
43310 fail:
43311 return NULL;
43312 }
43313
43314
43315 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43316 PyObject *resultobj = 0;
43317 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43318 wxBitmap *result = 0 ;
43319 void *argp1 = 0 ;
43320 int res1 = 0 ;
43321 PyObject *swig_obj[1] ;
43322
43323 if (!args) SWIG_fail;
43324 swig_obj[0] = args;
43325 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43326 if (!SWIG_IsOK(res1)) {
43327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43328 }
43329 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43330 {
43331 PyThreadState* __tstate = wxPyBeginAllowThreads();
43332 {
43333 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
43334 result = (wxBitmap *) &_result_ref;
43335 }
43336 wxPyEndAllowThreads(__tstate);
43337 if (PyErr_Occurred()) SWIG_fail;
43338 }
43339 {
43340 wxBitmap* resultptr = new wxBitmap(*result);
43341 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43342 }
43343 return resultobj;
43344 fail:
43345 return NULL;
43346 }
43347
43348
43349 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43350 PyObject *resultobj = 0;
43351 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43352 int arg2 ;
43353 void *argp1 = 0 ;
43354 int res1 = 0 ;
43355 int val2 ;
43356 int ecode2 = 0 ;
43357 PyObject * obj0 = 0 ;
43358 PyObject * obj1 = 0 ;
43359 char * kwnames[] = {
43360 (char *) "self",(char *) "nWidth", NULL
43361 };
43362
43363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
43364 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43365 if (!SWIG_IsOK(res1)) {
43366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43367 }
43368 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43369 ecode2 = SWIG_AsVal_int(obj1, &val2);
43370 if (!SWIG_IsOK(ecode2)) {
43371 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
43372 }
43373 arg2 = static_cast< int >(val2);
43374 {
43375 PyThreadState* __tstate = wxPyBeginAllowThreads();
43376 wxMenuItem_SetMarginWidth(arg1,arg2);
43377 wxPyEndAllowThreads(__tstate);
43378 if (PyErr_Occurred()) SWIG_fail;
43379 }
43380 resultobj = SWIG_Py_Void();
43381 return resultobj;
43382 fail:
43383 return NULL;
43384 }
43385
43386
43387 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43388 PyObject *resultobj = 0;
43389 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43390 int result;
43391 void *argp1 = 0 ;
43392 int res1 = 0 ;
43393 PyObject *swig_obj[1] ;
43394
43395 if (!args) SWIG_fail;
43396 swig_obj[0] = args;
43397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43398 if (!SWIG_IsOK(res1)) {
43399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43400 }
43401 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43402 {
43403 PyThreadState* __tstate = wxPyBeginAllowThreads();
43404 result = (int)wxMenuItem_GetMarginWidth(arg1);
43405 wxPyEndAllowThreads(__tstate);
43406 if (PyErr_Occurred()) SWIG_fail;
43407 }
43408 resultobj = SWIG_From_int(static_cast< int >(result));
43409 return resultobj;
43410 fail:
43411 return NULL;
43412 }
43413
43414
43415 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43416 PyObject *resultobj = 0;
43417 int result;
43418
43419 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
43420 {
43421 PyThreadState* __tstate = wxPyBeginAllowThreads();
43422 result = (int)wxMenuItem_GetDefaultMarginWidth();
43423 wxPyEndAllowThreads(__tstate);
43424 if (PyErr_Occurred()) SWIG_fail;
43425 }
43426 resultobj = SWIG_From_int(static_cast< int >(result));
43427 return resultobj;
43428 fail:
43429 return NULL;
43430 }
43431
43432
43433 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43434 PyObject *resultobj = 0;
43435 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43436 bool result;
43437 void *argp1 = 0 ;
43438 int res1 = 0 ;
43439 PyObject *swig_obj[1] ;
43440
43441 if (!args) SWIG_fail;
43442 swig_obj[0] = args;
43443 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43444 if (!SWIG_IsOK(res1)) {
43445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43446 }
43447 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43448 {
43449 PyThreadState* __tstate = wxPyBeginAllowThreads();
43450 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
43451 wxPyEndAllowThreads(__tstate);
43452 if (PyErr_Occurred()) SWIG_fail;
43453 }
43454 {
43455 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43456 }
43457 return resultobj;
43458 fail:
43459 return NULL;
43460 }
43461
43462
43463 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43464 PyObject *resultobj = 0;
43465 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43466 bool arg2 = (bool) true ;
43467 void *argp1 = 0 ;
43468 int res1 = 0 ;
43469 bool val2 ;
43470 int ecode2 = 0 ;
43471 PyObject * obj0 = 0 ;
43472 PyObject * obj1 = 0 ;
43473 char * kwnames[] = {
43474 (char *) "self",(char *) "ownerDrawn", NULL
43475 };
43476
43477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
43478 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43479 if (!SWIG_IsOK(res1)) {
43480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43481 }
43482 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43483 if (obj1) {
43484 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43485 if (!SWIG_IsOK(ecode2)) {
43486 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
43487 }
43488 arg2 = static_cast< bool >(val2);
43489 }
43490 {
43491 PyThreadState* __tstate = wxPyBeginAllowThreads();
43492 wxMenuItem_SetOwnerDrawn(arg1,arg2);
43493 wxPyEndAllowThreads(__tstate);
43494 if (PyErr_Occurred()) SWIG_fail;
43495 }
43496 resultobj = SWIG_Py_Void();
43497 return resultobj;
43498 fail:
43499 return NULL;
43500 }
43501
43502
43503 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43504 PyObject *resultobj = 0;
43505 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43506 void *argp1 = 0 ;
43507 int res1 = 0 ;
43508 PyObject *swig_obj[1] ;
43509
43510 if (!args) SWIG_fail;
43511 swig_obj[0] = args;
43512 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43513 if (!SWIG_IsOK(res1)) {
43514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43515 }
43516 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43517 {
43518 PyThreadState* __tstate = wxPyBeginAllowThreads();
43519 wxMenuItem_ResetOwnerDrawn(arg1);
43520 wxPyEndAllowThreads(__tstate);
43521 if (PyErr_Occurred()) SWIG_fail;
43522 }
43523 resultobj = SWIG_Py_Void();
43524 return resultobj;
43525 fail:
43526 return NULL;
43527 }
43528
43529
43530 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43531 PyObject *obj;
43532 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
43533 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
43534 return SWIG_Py_Void();
43535 }
43536
43537 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43538 return SWIG_Python_InitShadowInstance(args);
43539 }
43540
43541 SWIGINTERN int ControlNameStr_set(PyObject *) {
43542 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
43543 return 1;
43544 }
43545
43546
43547 SWIGINTERN PyObject *ControlNameStr_get(void) {
43548 PyObject *pyobj = 0;
43549
43550 {
43551 #if wxUSE_UNICODE
43552 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
43553 #else
43554 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
43555 #endif
43556 }
43557 return pyobj;
43558 }
43559
43560
43561 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43562 PyObject *resultobj = 0;
43563 wxWindow *arg1 = (wxWindow *) 0 ;
43564 int arg2 = (int) -1 ;
43565 wxPoint const &arg3_defvalue = wxDefaultPosition ;
43566 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
43567 wxSize const &arg4_defvalue = wxDefaultSize ;
43568 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
43569 long arg5 = (long) 0 ;
43570 wxValidator const &arg6_defvalue = wxDefaultValidator ;
43571 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
43572 wxString const &arg7_defvalue = wxPyControlNameStr ;
43573 wxString *arg7 = (wxString *) &arg7_defvalue ;
43574 wxControl *result = 0 ;
43575 void *argp1 = 0 ;
43576 int res1 = 0 ;
43577 int val2 ;
43578 int ecode2 = 0 ;
43579 wxPoint temp3 ;
43580 wxSize temp4 ;
43581 long val5 ;
43582 int ecode5 = 0 ;
43583 void *argp6 = 0 ;
43584 int res6 = 0 ;
43585 bool temp7 = false ;
43586 PyObject * obj0 = 0 ;
43587 PyObject * obj1 = 0 ;
43588 PyObject * obj2 = 0 ;
43589 PyObject * obj3 = 0 ;
43590 PyObject * obj4 = 0 ;
43591 PyObject * obj5 = 0 ;
43592 PyObject * obj6 = 0 ;
43593 char * kwnames[] = {
43594 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
43595 };
43596
43597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
43598 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
43599 if (!SWIG_IsOK(res1)) {
43600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
43601 }
43602 arg1 = reinterpret_cast< wxWindow * >(argp1);
43603 if (obj1) {
43604 ecode2 = SWIG_AsVal_int(obj1, &val2);
43605 if (!SWIG_IsOK(ecode2)) {
43606 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
43607 }
43608 arg2 = static_cast< int >(val2);
43609 }
43610 if (obj2) {
43611 {
43612 arg3 = &temp3;
43613 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
43614 }
43615 }
43616 if (obj3) {
43617 {
43618 arg4 = &temp4;
43619 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
43620 }
43621 }
43622 if (obj4) {
43623 ecode5 = SWIG_AsVal_long(obj4, &val5);
43624 if (!SWIG_IsOK(ecode5)) {
43625 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
43626 }
43627 arg5 = static_cast< long >(val5);
43628 }
43629 if (obj5) {
43630 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
43631 if (!SWIG_IsOK(res6)) {
43632 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
43633 }
43634 if (!argp6) {
43635 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
43636 }
43637 arg6 = reinterpret_cast< wxValidator * >(argp6);
43638 }
43639 if (obj6) {
43640 {
43641 arg7 = wxString_in_helper(obj6);
43642 if (arg7 == NULL) SWIG_fail;
43643 temp7 = true;
43644 }
43645 }
43646 {
43647 if (!wxPyCheckForApp()) SWIG_fail;
43648 PyThreadState* __tstate = wxPyBeginAllowThreads();
43649 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
43650 wxPyEndAllowThreads(__tstate);
43651 if (PyErr_Occurred()) SWIG_fail;
43652 }
43653 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
43654 {
43655 if (temp7)
43656 delete arg7;
43657 }
43658 return resultobj;
43659 fail:
43660 {
43661 if (temp7)
43662 delete arg7;
43663 }
43664 return NULL;
43665 }
43666
43667
43668 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43669 PyObject *resultobj = 0;
43670 wxControl *result = 0 ;
43671
43672 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
43673 {
43674 if (!wxPyCheckForApp()) SWIG_fail;
43675 PyThreadState* __tstate = wxPyBeginAllowThreads();
43676 result = (wxControl *)new wxControl();
43677 wxPyEndAllowThreads(__tstate);
43678 if (PyErr_Occurred()) SWIG_fail;
43679 }
43680 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
43681 return resultobj;
43682 fail:
43683 return NULL;
43684 }
43685
43686
43687 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43688 PyObject *resultobj = 0;
43689 wxControl *arg1 = (wxControl *) 0 ;
43690 wxWindow *arg2 = (wxWindow *) 0 ;
43691 int arg3 = (int) -1 ;
43692 wxPoint const &arg4_defvalue = wxDefaultPosition ;
43693 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
43694 wxSize const &arg5_defvalue = wxDefaultSize ;
43695 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
43696 long arg6 = (long) 0 ;
43697 wxValidator const &arg7_defvalue = wxDefaultValidator ;
43698 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
43699 wxString const &arg8_defvalue = wxPyControlNameStr ;
43700 wxString *arg8 = (wxString *) &arg8_defvalue ;
43701 bool result;
43702 void *argp1 = 0 ;
43703 int res1 = 0 ;
43704 void *argp2 = 0 ;
43705 int res2 = 0 ;
43706 int val3 ;
43707 int ecode3 = 0 ;
43708 wxPoint temp4 ;
43709 wxSize temp5 ;
43710 long val6 ;
43711 int ecode6 = 0 ;
43712 void *argp7 = 0 ;
43713 int res7 = 0 ;
43714 bool temp8 = false ;
43715 PyObject * obj0 = 0 ;
43716 PyObject * obj1 = 0 ;
43717 PyObject * obj2 = 0 ;
43718 PyObject * obj3 = 0 ;
43719 PyObject * obj4 = 0 ;
43720 PyObject * obj5 = 0 ;
43721 PyObject * obj6 = 0 ;
43722 PyObject * obj7 = 0 ;
43723 char * kwnames[] = {
43724 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
43725 };
43726
43727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
43728 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
43729 if (!SWIG_IsOK(res1)) {
43730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
43731 }
43732 arg1 = reinterpret_cast< wxControl * >(argp1);
43733 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
43734 if (!SWIG_IsOK(res2)) {
43735 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
43736 }
43737 arg2 = reinterpret_cast< wxWindow * >(argp2);
43738 if (obj2) {
43739 ecode3 = SWIG_AsVal_int(obj2, &val3);
43740 if (!SWIG_IsOK(ecode3)) {
43741 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
43742 }
43743 arg3 = static_cast< int >(val3);
43744 }
43745 if (obj3) {
43746 {
43747 arg4 = &temp4;
43748 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
43749 }
43750 }
43751 if (obj4) {
43752 {
43753 arg5 = &temp5;
43754 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
43755 }
43756 }
43757 if (obj5) {
43758 ecode6 = SWIG_AsVal_long(obj5, &val6);
43759 if (!SWIG_IsOK(ecode6)) {
43760 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
43761 }
43762 arg6 = static_cast< long >(val6);
43763 }
43764 if (obj6) {
43765 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
43766 if (!SWIG_IsOK(res7)) {
43767 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
43768 }
43769 if (!argp7) {
43770 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
43771 }
43772 arg7 = reinterpret_cast< wxValidator * >(argp7);
43773 }
43774 if (obj7) {
43775 {
43776 arg8 = wxString_in_helper(obj7);
43777 if (arg8 == NULL) SWIG_fail;
43778 temp8 = true;
43779 }
43780 }
43781 {
43782 PyThreadState* __tstate = wxPyBeginAllowThreads();
43783 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
43784 wxPyEndAllowThreads(__tstate);
43785 if (PyErr_Occurred()) SWIG_fail;
43786 }
43787 {
43788 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43789 }
43790 {
43791 if (temp8)
43792 delete arg8;
43793 }
43794 return resultobj;
43795 fail:
43796 {
43797 if (temp8)
43798 delete arg8;
43799 }
43800 return NULL;
43801 }
43802
43803
43804 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43805 PyObject *resultobj = 0;
43806 wxControl *arg1 = (wxControl *) 0 ;
43807 wxCommandEvent *arg2 = 0 ;
43808 void *argp1 = 0 ;
43809 int res1 = 0 ;
43810 void *argp2 = 0 ;
43811 int res2 = 0 ;
43812 PyObject * obj0 = 0 ;
43813 PyObject * obj1 = 0 ;
43814 char * kwnames[] = {
43815 (char *) "self",(char *) "event", NULL
43816 };
43817
43818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
43819 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
43820 if (!SWIG_IsOK(res1)) {
43821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
43822 }
43823 arg1 = reinterpret_cast< wxControl * >(argp1);
43824 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
43825 if (!SWIG_IsOK(res2)) {
43826 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
43827 }
43828 if (!argp2) {
43829 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
43830 }
43831 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
43832 {
43833 PyThreadState* __tstate = wxPyBeginAllowThreads();
43834 (arg1)->Command(*arg2);
43835 wxPyEndAllowThreads(__tstate);
43836 if (PyErr_Occurred()) SWIG_fail;
43837 }
43838 resultobj = SWIG_Py_Void();
43839 return resultobj;
43840 fail:
43841 return NULL;
43842 }
43843
43844
43845 SWIGINTERN PyObject *_wrap_Control_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43846 PyObject *resultobj = 0;
43847 wxControl *arg1 = (wxControl *) 0 ;
43848 wxString result;
43849 void *argp1 = 0 ;
43850 int res1 = 0 ;
43851 PyObject *swig_obj[1] ;
43852
43853 if (!args) SWIG_fail;
43854 swig_obj[0] = args;
43855 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
43856 if (!SWIG_IsOK(res1)) {
43857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabel" "', expected argument " "1"" of type '" "wxControl *""'");
43858 }
43859 arg1 = reinterpret_cast< wxControl * >(argp1);
43860 {
43861 PyThreadState* __tstate = wxPyBeginAllowThreads();
43862 result = (arg1)->GetLabel();
43863 wxPyEndAllowThreads(__tstate);
43864 if (PyErr_Occurred()) SWIG_fail;
43865 }
43866 {
43867 #if wxUSE_UNICODE
43868 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43869 #else
43870 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43871 #endif
43872 }
43873 return resultobj;
43874 fail:
43875 return NULL;
43876 }
43877
43878
43879 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43880 PyObject *resultobj = 0;
43881 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
43882 SwigValueWrapper<wxVisualAttributes > result;
43883 int val1 ;
43884 int ecode1 = 0 ;
43885 PyObject * obj0 = 0 ;
43886 char * kwnames[] = {
43887 (char *) "variant", NULL
43888 };
43889
43890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
43891 if (obj0) {
43892 ecode1 = SWIG_AsVal_int(obj0, &val1);
43893 if (!SWIG_IsOK(ecode1)) {
43894 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
43895 }
43896 arg1 = static_cast< wxWindowVariant >(val1);
43897 }
43898 {
43899 if (!wxPyCheckForApp()) SWIG_fail;
43900 PyThreadState* __tstate = wxPyBeginAllowThreads();
43901 result = wxControl::GetClassDefaultAttributes(arg1);
43902 wxPyEndAllowThreads(__tstate);
43903 if (PyErr_Occurred()) SWIG_fail;
43904 }
43905 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
43906 return resultobj;
43907 fail:
43908 return NULL;
43909 }
43910
43911
43912 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43913 PyObject *obj;
43914 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
43915 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
43916 return SWIG_Py_Void();
43917 }
43918
43919 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43920 return SWIG_Python_InitShadowInstance(args);
43921 }
43922
43923 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43924 PyObject *resultobj = 0;
43925 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
43926 wxString *arg2 = 0 ;
43927 PyObject *arg3 = (PyObject *) NULL ;
43928 int result;
43929 void *argp1 = 0 ;
43930 int res1 = 0 ;
43931 bool temp2 = false ;
43932 PyObject * obj0 = 0 ;
43933 PyObject * obj1 = 0 ;
43934 PyObject * obj2 = 0 ;
43935 char * kwnames[] = {
43936 (char *) "self",(char *) "item",(char *) "clientData", NULL
43937 };
43938
43939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43940 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
43941 if (!SWIG_IsOK(res1)) {
43942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
43943 }
43944 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
43945 {
43946 arg2 = wxString_in_helper(obj1);
43947 if (arg2 == NULL) SWIG_fail;
43948 temp2 = true;
43949 }
43950 if (obj2) {
43951 arg3 = obj2;
43952 }
43953 {
43954 PyThreadState* __tstate = wxPyBeginAllowThreads();
43955 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
43956 wxPyEndAllowThreads(__tstate);
43957 if (PyErr_Occurred()) SWIG_fail;
43958 }
43959 resultobj = SWIG_From_int(static_cast< int >(result));
43960 {
43961 if (temp2)
43962 delete arg2;
43963 }
43964 return resultobj;
43965 fail:
43966 {
43967 if (temp2)
43968 delete arg2;
43969 }
43970 return NULL;
43971 }
43972
43973
43974 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43975 PyObject *resultobj = 0;
43976 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
43977 wxArrayString *arg2 = 0 ;
43978 void *argp1 = 0 ;
43979 int res1 = 0 ;
43980 bool temp2 = false ;
43981 PyObject * obj0 = 0 ;
43982 PyObject * obj1 = 0 ;
43983 char * kwnames[] = {
43984 (char *) "self",(char *) "strings", NULL
43985 };
43986
43987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
43988 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
43989 if (!SWIG_IsOK(res1)) {
43990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
43991 }
43992 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
43993 {
43994 if (! PySequence_Check(obj1)) {
43995 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
43996 SWIG_fail;
43997 }
43998 arg2 = new wxArrayString;
43999 temp2 = true;
44000 int i, len=PySequence_Length(obj1);
44001 for (i=0; i<len; i++) {
44002 PyObject* item = PySequence_GetItem(obj1, i);
44003 wxString* s = wxString_in_helper(item);
44004 if (PyErr_Occurred()) SWIG_fail;
44005 arg2->Add(*s);
44006 delete s;
44007 Py_DECREF(item);
44008 }
44009 }
44010 {
44011 PyThreadState* __tstate = wxPyBeginAllowThreads();
44012 (arg1)->Append((wxArrayString const &)*arg2);
44013 wxPyEndAllowThreads(__tstate);
44014 if (PyErr_Occurred()) SWIG_fail;
44015 }
44016 resultobj = SWIG_Py_Void();
44017 {
44018 if (temp2) delete arg2;
44019 }
44020 return resultobj;
44021 fail:
44022 {
44023 if (temp2) delete arg2;
44024 }
44025 return NULL;
44026 }
44027
44028
44029 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44030 PyObject *resultobj = 0;
44031 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44032 wxString *arg2 = 0 ;
44033 unsigned int arg3 ;
44034 PyObject *arg4 = (PyObject *) NULL ;
44035 int result;
44036 void *argp1 = 0 ;
44037 int res1 = 0 ;
44038 bool temp2 = false ;
44039 unsigned int val3 ;
44040 int ecode3 = 0 ;
44041 PyObject * obj0 = 0 ;
44042 PyObject * obj1 = 0 ;
44043 PyObject * obj2 = 0 ;
44044 PyObject * obj3 = 0 ;
44045 char * kwnames[] = {
44046 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
44047 };
44048
44049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44050 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44051 if (!SWIG_IsOK(res1)) {
44052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44053 }
44054 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44055 {
44056 arg2 = wxString_in_helper(obj1);
44057 if (arg2 == NULL) SWIG_fail;
44058 temp2 = true;
44059 }
44060 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
44061 if (!SWIG_IsOK(ecode3)) {
44062 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "unsigned int""'");
44063 }
44064 arg3 = static_cast< unsigned int >(val3);
44065 if (obj3) {
44066 arg4 = obj3;
44067 }
44068 {
44069 PyThreadState* __tstate = wxPyBeginAllowThreads();
44070 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
44071 wxPyEndAllowThreads(__tstate);
44072 if (PyErr_Occurred()) SWIG_fail;
44073 }
44074 resultobj = SWIG_From_int(static_cast< int >(result));
44075 {
44076 if (temp2)
44077 delete arg2;
44078 }
44079 return resultobj;
44080 fail:
44081 {
44082 if (temp2)
44083 delete arg2;
44084 }
44085 return NULL;
44086 }
44087
44088
44089 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44090 PyObject *resultobj = 0;
44091 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44092 void *argp1 = 0 ;
44093 int res1 = 0 ;
44094 PyObject *swig_obj[1] ;
44095
44096 if (!args) SWIG_fail;
44097 swig_obj[0] = args;
44098 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44099 if (!SWIG_IsOK(res1)) {
44100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44101 }
44102 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44103 {
44104 PyThreadState* __tstate = wxPyBeginAllowThreads();
44105 (arg1)->Clear();
44106 wxPyEndAllowThreads(__tstate);
44107 if (PyErr_Occurred()) SWIG_fail;
44108 }
44109 resultobj = SWIG_Py_Void();
44110 return resultobj;
44111 fail:
44112 return NULL;
44113 }
44114
44115
44116 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44117 PyObject *resultobj = 0;
44118 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44119 unsigned int arg2 ;
44120 void *argp1 = 0 ;
44121 int res1 = 0 ;
44122 unsigned int val2 ;
44123 int ecode2 = 0 ;
44124 PyObject * obj0 = 0 ;
44125 PyObject * obj1 = 0 ;
44126 char * kwnames[] = {
44127 (char *) "self",(char *) "n", NULL
44128 };
44129
44130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
44131 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44132 if (!SWIG_IsOK(res1)) {
44133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44134 }
44135 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44136 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44137 if (!SWIG_IsOK(ecode2)) {
44138 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "unsigned int""'");
44139 }
44140 arg2 = static_cast< unsigned int >(val2);
44141 {
44142 PyThreadState* __tstate = wxPyBeginAllowThreads();
44143 (arg1)->Delete(arg2);
44144 wxPyEndAllowThreads(__tstate);
44145 if (PyErr_Occurred()) SWIG_fail;
44146 }
44147 resultobj = SWIG_Py_Void();
44148 return resultobj;
44149 fail:
44150 return NULL;
44151 }
44152
44153
44154 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44155 PyObject *resultobj = 0;
44156 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44157 unsigned int arg2 ;
44158 PyObject *result = 0 ;
44159 void *argp1 = 0 ;
44160 int res1 = 0 ;
44161 unsigned int val2 ;
44162 int ecode2 = 0 ;
44163 PyObject * obj0 = 0 ;
44164 PyObject * obj1 = 0 ;
44165 char * kwnames[] = {
44166 (char *) "self",(char *) "n", NULL
44167 };
44168
44169 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
44170 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44171 if (!SWIG_IsOK(res1)) {
44172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44173 }
44174 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44175 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44176 if (!SWIG_IsOK(ecode2)) {
44177 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44178 }
44179 arg2 = static_cast< unsigned int >(val2);
44180 {
44181 PyThreadState* __tstate = wxPyBeginAllowThreads();
44182 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
44183 wxPyEndAllowThreads(__tstate);
44184 if (PyErr_Occurred()) SWIG_fail;
44185 }
44186 resultobj = result;
44187 return resultobj;
44188 fail:
44189 return NULL;
44190 }
44191
44192
44193 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44194 PyObject *resultobj = 0;
44195 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44196 unsigned int arg2 ;
44197 PyObject *arg3 = (PyObject *) 0 ;
44198 void *argp1 = 0 ;
44199 int res1 = 0 ;
44200 unsigned int val2 ;
44201 int ecode2 = 0 ;
44202 PyObject * obj0 = 0 ;
44203 PyObject * obj1 = 0 ;
44204 PyObject * obj2 = 0 ;
44205 char * kwnames[] = {
44206 (char *) "self",(char *) "n",(char *) "clientData", NULL
44207 };
44208
44209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44210 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44211 if (!SWIG_IsOK(res1)) {
44212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44213 }
44214 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44215 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44216 if (!SWIG_IsOK(ecode2)) {
44217 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44218 }
44219 arg2 = static_cast< unsigned int >(val2);
44220 arg3 = obj2;
44221 {
44222 PyThreadState* __tstate = wxPyBeginAllowThreads();
44223 wxItemContainer_SetClientData(arg1,arg2,arg3);
44224 wxPyEndAllowThreads(__tstate);
44225 if (PyErr_Occurred()) SWIG_fail;
44226 }
44227 resultobj = SWIG_Py_Void();
44228 return resultobj;
44229 fail:
44230 return NULL;
44231 }
44232
44233
44234 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44235 PyObject *resultobj = 0;
44236 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44237 unsigned int result;
44238 void *argp1 = 0 ;
44239 int res1 = 0 ;
44240 PyObject *swig_obj[1] ;
44241
44242 if (!args) SWIG_fail;
44243 swig_obj[0] = args;
44244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44245 if (!SWIG_IsOK(res1)) {
44246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44247 }
44248 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44249 {
44250 PyThreadState* __tstate = wxPyBeginAllowThreads();
44251 result = (unsigned int)((wxItemContainer const *)arg1)->GetCount();
44252 wxPyEndAllowThreads(__tstate);
44253 if (PyErr_Occurred()) SWIG_fail;
44254 }
44255 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
44256 return resultobj;
44257 fail:
44258 return NULL;
44259 }
44260
44261
44262 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44263 PyObject *resultobj = 0;
44264 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44265 bool result;
44266 void *argp1 = 0 ;
44267 int res1 = 0 ;
44268 PyObject *swig_obj[1] ;
44269
44270 if (!args) SWIG_fail;
44271 swig_obj[0] = args;
44272 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44273 if (!SWIG_IsOK(res1)) {
44274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44275 }
44276 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44277 {
44278 PyThreadState* __tstate = wxPyBeginAllowThreads();
44279 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
44280 wxPyEndAllowThreads(__tstate);
44281 if (PyErr_Occurred()) SWIG_fail;
44282 }
44283 {
44284 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44285 }
44286 return resultobj;
44287 fail:
44288 return NULL;
44289 }
44290
44291
44292 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44293 PyObject *resultobj = 0;
44294 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44295 unsigned int arg2 ;
44296 wxString result;
44297 void *argp1 = 0 ;
44298 int res1 = 0 ;
44299 unsigned int val2 ;
44300 int ecode2 = 0 ;
44301 PyObject * obj0 = 0 ;
44302 PyObject * obj1 = 0 ;
44303 char * kwnames[] = {
44304 (char *) "self",(char *) "n", NULL
44305 };
44306
44307 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
44308 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44309 if (!SWIG_IsOK(res1)) {
44310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44311 }
44312 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44313 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44314 if (!SWIG_IsOK(ecode2)) {
44315 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "unsigned int""'");
44316 }
44317 arg2 = static_cast< unsigned int >(val2);
44318 {
44319 PyThreadState* __tstate = wxPyBeginAllowThreads();
44320 result = ((wxItemContainer const *)arg1)->GetString(arg2);
44321 wxPyEndAllowThreads(__tstate);
44322 if (PyErr_Occurred()) SWIG_fail;
44323 }
44324 {
44325 #if wxUSE_UNICODE
44326 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44327 #else
44328 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44329 #endif
44330 }
44331 return resultobj;
44332 fail:
44333 return NULL;
44334 }
44335
44336
44337 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44338 PyObject *resultobj = 0;
44339 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44340 wxArrayString result;
44341 void *argp1 = 0 ;
44342 int res1 = 0 ;
44343 PyObject *swig_obj[1] ;
44344
44345 if (!args) SWIG_fail;
44346 swig_obj[0] = args;
44347 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44348 if (!SWIG_IsOK(res1)) {
44349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44350 }
44351 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44352 {
44353 PyThreadState* __tstate = wxPyBeginAllowThreads();
44354 result = ((wxItemContainer const *)arg1)->GetStrings();
44355 wxPyEndAllowThreads(__tstate);
44356 if (PyErr_Occurred()) SWIG_fail;
44357 }
44358 {
44359 resultobj = wxArrayString2PyList_helper(result);
44360 }
44361 return resultobj;
44362 fail:
44363 return NULL;
44364 }
44365
44366
44367 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44368 PyObject *resultobj = 0;
44369 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44370 unsigned int arg2 ;
44371 wxString *arg3 = 0 ;
44372 void *argp1 = 0 ;
44373 int res1 = 0 ;
44374 unsigned int val2 ;
44375 int ecode2 = 0 ;
44376 bool temp3 = false ;
44377 PyObject * obj0 = 0 ;
44378 PyObject * obj1 = 0 ;
44379 PyObject * obj2 = 0 ;
44380 char * kwnames[] = {
44381 (char *) "self",(char *) "n",(char *) "s", NULL
44382 };
44383
44384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44385 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44386 if (!SWIG_IsOK(res1)) {
44387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44388 }
44389 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44390 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44391 if (!SWIG_IsOK(ecode2)) {
44392 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "unsigned int""'");
44393 }
44394 arg2 = static_cast< unsigned int >(val2);
44395 {
44396 arg3 = wxString_in_helper(obj2);
44397 if (arg3 == NULL) SWIG_fail;
44398 temp3 = true;
44399 }
44400 {
44401 PyThreadState* __tstate = wxPyBeginAllowThreads();
44402 (arg1)->SetString(arg2,(wxString const &)*arg3);
44403 wxPyEndAllowThreads(__tstate);
44404 if (PyErr_Occurred()) SWIG_fail;
44405 }
44406 resultobj = SWIG_Py_Void();
44407 {
44408 if (temp3)
44409 delete arg3;
44410 }
44411 return resultobj;
44412 fail:
44413 {
44414 if (temp3)
44415 delete arg3;
44416 }
44417 return NULL;
44418 }
44419
44420
44421 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44422 PyObject *resultobj = 0;
44423 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44424 wxString *arg2 = 0 ;
44425 int result;
44426 void *argp1 = 0 ;
44427 int res1 = 0 ;
44428 bool temp2 = false ;
44429 PyObject * obj0 = 0 ;
44430 PyObject * obj1 = 0 ;
44431 char * kwnames[] = {
44432 (char *) "self",(char *) "s", NULL
44433 };
44434
44435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
44436 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44437 if (!SWIG_IsOK(res1)) {
44438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44439 }
44440 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44441 {
44442 arg2 = wxString_in_helper(obj1);
44443 if (arg2 == NULL) SWIG_fail;
44444 temp2 = true;
44445 }
44446 {
44447 PyThreadState* __tstate = wxPyBeginAllowThreads();
44448 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
44449 wxPyEndAllowThreads(__tstate);
44450 if (PyErr_Occurred()) SWIG_fail;
44451 }
44452 resultobj = SWIG_From_int(static_cast< int >(result));
44453 {
44454 if (temp2)
44455 delete arg2;
44456 }
44457 return resultobj;
44458 fail:
44459 {
44460 if (temp2)
44461 delete arg2;
44462 }
44463 return NULL;
44464 }
44465
44466
44467 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44468 PyObject *resultobj = 0;
44469 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44470 int arg2 ;
44471 void *argp1 = 0 ;
44472 int res1 = 0 ;
44473 int val2 ;
44474 int ecode2 = 0 ;
44475 PyObject * obj0 = 0 ;
44476 PyObject * obj1 = 0 ;
44477 char * kwnames[] = {
44478 (char *) "self",(char *) "n", NULL
44479 };
44480
44481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
44482 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44483 if (!SWIG_IsOK(res1)) {
44484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44485 }
44486 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44487 ecode2 = SWIG_AsVal_int(obj1, &val2);
44488 if (!SWIG_IsOK(ecode2)) {
44489 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
44490 }
44491 arg2 = static_cast< int >(val2);
44492 {
44493 PyThreadState* __tstate = wxPyBeginAllowThreads();
44494 (arg1)->SetSelection(arg2);
44495 wxPyEndAllowThreads(__tstate);
44496 if (PyErr_Occurred()) SWIG_fail;
44497 }
44498 resultobj = SWIG_Py_Void();
44499 return resultobj;
44500 fail:
44501 return NULL;
44502 }
44503
44504
44505 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44506 PyObject *resultobj = 0;
44507 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44508 int result;
44509 void *argp1 = 0 ;
44510 int res1 = 0 ;
44511 PyObject *swig_obj[1] ;
44512
44513 if (!args) SWIG_fail;
44514 swig_obj[0] = args;
44515 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44516 if (!SWIG_IsOK(res1)) {
44517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44518 }
44519 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44520 {
44521 PyThreadState* __tstate = wxPyBeginAllowThreads();
44522 result = (int)((wxItemContainer const *)arg1)->GetSelection();
44523 wxPyEndAllowThreads(__tstate);
44524 if (PyErr_Occurred()) SWIG_fail;
44525 }
44526 resultobj = SWIG_From_int(static_cast< int >(result));
44527 return resultobj;
44528 fail:
44529 return NULL;
44530 }
44531
44532
44533 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44534 PyObject *resultobj = 0;
44535 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44536 wxString *arg2 = 0 ;
44537 bool result;
44538 void *argp1 = 0 ;
44539 int res1 = 0 ;
44540 bool temp2 = false ;
44541 PyObject * obj0 = 0 ;
44542 PyObject * obj1 = 0 ;
44543 char * kwnames[] = {
44544 (char *) "self",(char *) "s", NULL
44545 };
44546
44547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
44548 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44549 if (!SWIG_IsOK(res1)) {
44550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44551 }
44552 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44553 {
44554 arg2 = wxString_in_helper(obj1);
44555 if (arg2 == NULL) SWIG_fail;
44556 temp2 = true;
44557 }
44558 {
44559 PyThreadState* __tstate = wxPyBeginAllowThreads();
44560 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
44561 wxPyEndAllowThreads(__tstate);
44562 if (PyErr_Occurred()) SWIG_fail;
44563 }
44564 {
44565 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44566 }
44567 {
44568 if (temp2)
44569 delete arg2;
44570 }
44571 return resultobj;
44572 fail:
44573 {
44574 if (temp2)
44575 delete arg2;
44576 }
44577 return NULL;
44578 }
44579
44580
44581 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44582 PyObject *resultobj = 0;
44583 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44584 wxString result;
44585 void *argp1 = 0 ;
44586 int res1 = 0 ;
44587 PyObject *swig_obj[1] ;
44588
44589 if (!args) SWIG_fail;
44590 swig_obj[0] = args;
44591 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44592 if (!SWIG_IsOK(res1)) {
44593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44594 }
44595 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44596 {
44597 PyThreadState* __tstate = wxPyBeginAllowThreads();
44598 result = ((wxItemContainer const *)arg1)->GetStringSelection();
44599 wxPyEndAllowThreads(__tstate);
44600 if (PyErr_Occurred()) SWIG_fail;
44601 }
44602 {
44603 #if wxUSE_UNICODE
44604 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44605 #else
44606 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44607 #endif
44608 }
44609 return resultobj;
44610 fail:
44611 return NULL;
44612 }
44613
44614
44615 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44616 PyObject *resultobj = 0;
44617 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44618 int arg2 ;
44619 void *argp1 = 0 ;
44620 int res1 = 0 ;
44621 int val2 ;
44622 int ecode2 = 0 ;
44623 PyObject * obj0 = 0 ;
44624 PyObject * obj1 = 0 ;
44625 char * kwnames[] = {
44626 (char *) "self",(char *) "n", NULL
44627 };
44628
44629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
44630 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44631 if (!SWIG_IsOK(res1)) {
44632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44633 }
44634 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44635 ecode2 = SWIG_AsVal_int(obj1, &val2);
44636 if (!SWIG_IsOK(ecode2)) {
44637 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
44638 }
44639 arg2 = static_cast< int >(val2);
44640 {
44641 PyThreadState* __tstate = wxPyBeginAllowThreads();
44642 (arg1)->Select(arg2);
44643 wxPyEndAllowThreads(__tstate);
44644 if (PyErr_Occurred()) SWIG_fail;
44645 }
44646 resultobj = SWIG_Py_Void();
44647 return resultobj;
44648 fail:
44649 return NULL;
44650 }
44651
44652
44653 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44654 PyObject *obj;
44655 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44656 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
44657 return SWIG_Py_Void();
44658 }
44659
44660 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44661 PyObject *obj;
44662 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44663 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
44664 return SWIG_Py_Void();
44665 }
44666
44667 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44668 PyObject *resultobj = 0;
44669 wxSizerItem *result = 0 ;
44670
44671 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
44672 {
44673 PyThreadState* __tstate = wxPyBeginAllowThreads();
44674 result = (wxSizerItem *)new wxSizerItem();
44675 wxPyEndAllowThreads(__tstate);
44676 if (PyErr_Occurred()) SWIG_fail;
44677 }
44678 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
44679 return resultobj;
44680 fail:
44681 return NULL;
44682 }
44683
44684
44685 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44686 PyObject *resultobj = 0;
44687 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44688 void *argp1 = 0 ;
44689 int res1 = 0 ;
44690 PyObject *swig_obj[1] ;
44691
44692 if (!args) SWIG_fail;
44693 swig_obj[0] = args;
44694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
44695 if (!SWIG_IsOK(res1)) {
44696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44697 }
44698 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44699 {
44700 PyThreadState* __tstate = wxPyBeginAllowThreads();
44701 delete arg1;
44702
44703 wxPyEndAllowThreads(__tstate);
44704 if (PyErr_Occurred()) SWIG_fail;
44705 }
44706 resultobj = SWIG_Py_Void();
44707 return resultobj;
44708 fail:
44709 return NULL;
44710 }
44711
44712
44713 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44714 PyObject *resultobj = 0;
44715 wxWindow *arg1 = (wxWindow *) 0 ;
44716 int arg2 ;
44717 int arg3 ;
44718 int arg4 ;
44719 PyObject *arg5 = (PyObject *) NULL ;
44720 wxSizerItem *result = 0 ;
44721 void *argp1 = 0 ;
44722 int res1 = 0 ;
44723 int val2 ;
44724 int ecode2 = 0 ;
44725 int val3 ;
44726 int ecode3 = 0 ;
44727 int val4 ;
44728 int ecode4 = 0 ;
44729 PyObject * obj0 = 0 ;
44730 PyObject * obj1 = 0 ;
44731 PyObject * obj2 = 0 ;
44732 PyObject * obj3 = 0 ;
44733 PyObject * obj4 = 0 ;
44734 char * kwnames[] = {
44735 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
44736 };
44737
44738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
44739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
44740 if (!SWIG_IsOK(res1)) {
44741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
44742 }
44743 arg1 = reinterpret_cast< wxWindow * >(argp1);
44744 ecode2 = SWIG_AsVal_int(obj1, &val2);
44745 if (!SWIG_IsOK(ecode2)) {
44746 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
44747 }
44748 arg2 = static_cast< int >(val2);
44749 ecode3 = SWIG_AsVal_int(obj2, &val3);
44750 if (!SWIG_IsOK(ecode3)) {
44751 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
44752 }
44753 arg3 = static_cast< int >(val3);
44754 ecode4 = SWIG_AsVal_int(obj3, &val4);
44755 if (!SWIG_IsOK(ecode4)) {
44756 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
44757 }
44758 arg4 = static_cast< int >(val4);
44759 if (obj4) {
44760 arg5 = obj4;
44761 }
44762 {
44763 PyThreadState* __tstate = wxPyBeginAllowThreads();
44764 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
44765 wxPyEndAllowThreads(__tstate);
44766 if (PyErr_Occurred()) SWIG_fail;
44767 }
44768 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
44769 return resultobj;
44770 fail:
44771 return NULL;
44772 }
44773
44774
44775 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44776 PyObject *resultobj = 0;
44777 int arg1 ;
44778 int arg2 ;
44779 int arg3 ;
44780 int arg4 ;
44781 int arg5 ;
44782 PyObject *arg6 = (PyObject *) NULL ;
44783 wxSizerItem *result = 0 ;
44784 int val1 ;
44785 int ecode1 = 0 ;
44786 int val2 ;
44787 int ecode2 = 0 ;
44788 int val3 ;
44789 int ecode3 = 0 ;
44790 int val4 ;
44791 int ecode4 = 0 ;
44792 int val5 ;
44793 int ecode5 = 0 ;
44794 PyObject * obj0 = 0 ;
44795 PyObject * obj1 = 0 ;
44796 PyObject * obj2 = 0 ;
44797 PyObject * obj3 = 0 ;
44798 PyObject * obj4 = 0 ;
44799 PyObject * obj5 = 0 ;
44800 char * kwnames[] = {
44801 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
44802 };
44803
44804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
44805 ecode1 = SWIG_AsVal_int(obj0, &val1);
44806 if (!SWIG_IsOK(ecode1)) {
44807 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
44808 }
44809 arg1 = static_cast< int >(val1);
44810 ecode2 = SWIG_AsVal_int(obj1, &val2);
44811 if (!SWIG_IsOK(ecode2)) {
44812 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
44813 }
44814 arg2 = static_cast< int >(val2);
44815 ecode3 = SWIG_AsVal_int(obj2, &val3);
44816 if (!SWIG_IsOK(ecode3)) {
44817 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
44818 }
44819 arg3 = static_cast< int >(val3);
44820 ecode4 = SWIG_AsVal_int(obj3, &val4);
44821 if (!SWIG_IsOK(ecode4)) {
44822 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
44823 }
44824 arg4 = static_cast< int >(val4);
44825 ecode5 = SWIG_AsVal_int(obj4, &val5);
44826 if (!SWIG_IsOK(ecode5)) {
44827 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
44828 }
44829 arg5 = static_cast< int >(val5);
44830 if (obj5) {
44831 arg6 = obj5;
44832 }
44833 {
44834 PyThreadState* __tstate = wxPyBeginAllowThreads();
44835 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
44836 wxPyEndAllowThreads(__tstate);
44837 if (PyErr_Occurred()) SWIG_fail;
44838 }
44839 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
44840 return resultobj;
44841 fail:
44842 return NULL;
44843 }
44844
44845
44846 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44847 PyObject *resultobj = 0;
44848 wxSizer *arg1 = (wxSizer *) 0 ;
44849 int arg2 ;
44850 int arg3 ;
44851 int arg4 ;
44852 PyObject *arg5 = (PyObject *) NULL ;
44853 wxSizerItem *result = 0 ;
44854 int res1 = 0 ;
44855 int val2 ;
44856 int ecode2 = 0 ;
44857 int val3 ;
44858 int ecode3 = 0 ;
44859 int val4 ;
44860 int ecode4 = 0 ;
44861 PyObject * obj0 = 0 ;
44862 PyObject * obj1 = 0 ;
44863 PyObject * obj2 = 0 ;
44864 PyObject * obj3 = 0 ;
44865 PyObject * obj4 = 0 ;
44866 char * kwnames[] = {
44867 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
44868 };
44869
44870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
44871 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
44872 if (!SWIG_IsOK(res1)) {
44873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
44874 }
44875 ecode2 = SWIG_AsVal_int(obj1, &val2);
44876 if (!SWIG_IsOK(ecode2)) {
44877 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
44878 }
44879 arg2 = static_cast< int >(val2);
44880 ecode3 = SWIG_AsVal_int(obj2, &val3);
44881 if (!SWIG_IsOK(ecode3)) {
44882 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
44883 }
44884 arg3 = static_cast< int >(val3);
44885 ecode4 = SWIG_AsVal_int(obj3, &val4);
44886 if (!SWIG_IsOK(ecode4)) {
44887 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
44888 }
44889 arg4 = static_cast< int >(val4);
44890 if (obj4) {
44891 arg5 = obj4;
44892 }
44893 {
44894 PyThreadState* __tstate = wxPyBeginAllowThreads();
44895 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
44896 wxPyEndAllowThreads(__tstate);
44897 if (PyErr_Occurred()) SWIG_fail;
44898 }
44899 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
44900 return resultobj;
44901 fail:
44902 return NULL;
44903 }
44904
44905
44906 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44907 PyObject *resultobj = 0;
44908 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44909 void *argp1 = 0 ;
44910 int res1 = 0 ;
44911 PyObject *swig_obj[1] ;
44912
44913 if (!args) SWIG_fail;
44914 swig_obj[0] = args;
44915 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44916 if (!SWIG_IsOK(res1)) {
44917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44918 }
44919 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44920 {
44921 PyThreadState* __tstate = wxPyBeginAllowThreads();
44922 (arg1)->DeleteWindows();
44923 wxPyEndAllowThreads(__tstate);
44924 if (PyErr_Occurred()) SWIG_fail;
44925 }
44926 resultobj = SWIG_Py_Void();
44927 return resultobj;
44928 fail:
44929 return NULL;
44930 }
44931
44932
44933 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44934 PyObject *resultobj = 0;
44935 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44936 void *argp1 = 0 ;
44937 int res1 = 0 ;
44938 PyObject *swig_obj[1] ;
44939
44940 if (!args) SWIG_fail;
44941 swig_obj[0] = args;
44942 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44943 if (!SWIG_IsOK(res1)) {
44944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44945 }
44946 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44947 {
44948 PyThreadState* __tstate = wxPyBeginAllowThreads();
44949 (arg1)->DetachSizer();
44950 wxPyEndAllowThreads(__tstate);
44951 if (PyErr_Occurred()) SWIG_fail;
44952 }
44953 resultobj = SWIG_Py_Void();
44954 return resultobj;
44955 fail:
44956 return NULL;
44957 }
44958
44959
44960 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44961 PyObject *resultobj = 0;
44962 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44963 wxSize result;
44964 void *argp1 = 0 ;
44965 int res1 = 0 ;
44966 PyObject *swig_obj[1] ;
44967
44968 if (!args) SWIG_fail;
44969 swig_obj[0] = args;
44970 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44971 if (!SWIG_IsOK(res1)) {
44972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44973 }
44974 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44975 {
44976 PyThreadState* __tstate = wxPyBeginAllowThreads();
44977 result = (arg1)->GetSize();
44978 wxPyEndAllowThreads(__tstate);
44979 if (PyErr_Occurred()) SWIG_fail;
44980 }
44981 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
44982 return resultobj;
44983 fail:
44984 return NULL;
44985 }
44986
44987
44988 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44989 PyObject *resultobj = 0;
44990 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44991 wxSize result;
44992 void *argp1 = 0 ;
44993 int res1 = 0 ;
44994 PyObject *swig_obj[1] ;
44995
44996 if (!args) SWIG_fail;
44997 swig_obj[0] = args;
44998 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44999 if (!SWIG_IsOK(res1)) {
45000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45001 }
45002 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45003 {
45004 PyThreadState* __tstate = wxPyBeginAllowThreads();
45005 result = (arg1)->CalcMin();
45006 wxPyEndAllowThreads(__tstate);
45007 if (PyErr_Occurred()) SWIG_fail;
45008 }
45009 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45010 return resultobj;
45011 fail:
45012 return NULL;
45013 }
45014
45015
45016 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45017 PyObject *resultobj = 0;
45018 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45019 wxPoint *arg2 = 0 ;
45020 wxSize *arg3 = 0 ;
45021 void *argp1 = 0 ;
45022 int res1 = 0 ;
45023 wxPoint temp2 ;
45024 wxSize temp3 ;
45025 PyObject * obj0 = 0 ;
45026 PyObject * obj1 = 0 ;
45027 PyObject * obj2 = 0 ;
45028 char * kwnames[] = {
45029 (char *) "self",(char *) "pos",(char *) "size", NULL
45030 };
45031
45032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45033 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45034 if (!SWIG_IsOK(res1)) {
45035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45036 }
45037 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45038 {
45039 arg2 = &temp2;
45040 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
45041 }
45042 {
45043 arg3 = &temp3;
45044 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
45045 }
45046 {
45047 PyThreadState* __tstate = wxPyBeginAllowThreads();
45048 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
45049 wxPyEndAllowThreads(__tstate);
45050 if (PyErr_Occurred()) SWIG_fail;
45051 }
45052 resultobj = SWIG_Py_Void();
45053 return resultobj;
45054 fail:
45055 return NULL;
45056 }
45057
45058
45059 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45060 PyObject *resultobj = 0;
45061 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45062 wxSize result;
45063 void *argp1 = 0 ;
45064 int res1 = 0 ;
45065 PyObject *swig_obj[1] ;
45066
45067 if (!args) SWIG_fail;
45068 swig_obj[0] = args;
45069 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45070 if (!SWIG_IsOK(res1)) {
45071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45072 }
45073 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45074 {
45075 PyThreadState* __tstate = wxPyBeginAllowThreads();
45076 result = (arg1)->GetMinSize();
45077 wxPyEndAllowThreads(__tstate);
45078 if (PyErr_Occurred()) SWIG_fail;
45079 }
45080 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45081 return resultobj;
45082 fail:
45083 return NULL;
45084 }
45085
45086
45087 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45088 PyObject *resultobj = 0;
45089 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45090 wxSize result;
45091 void *argp1 = 0 ;
45092 int res1 = 0 ;
45093 PyObject *swig_obj[1] ;
45094
45095 if (!args) SWIG_fail;
45096 swig_obj[0] = args;
45097 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45098 if (!SWIG_IsOK(res1)) {
45099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
45100 }
45101 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45102 {
45103 PyThreadState* __tstate = wxPyBeginAllowThreads();
45104 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
45105 wxPyEndAllowThreads(__tstate);
45106 if (PyErr_Occurred()) SWIG_fail;
45107 }
45108 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45109 return resultobj;
45110 fail:
45111 return NULL;
45112 }
45113
45114
45115 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45116 PyObject *resultobj = 0;
45117 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45118 int arg2 ;
45119 int arg3 ;
45120 void *argp1 = 0 ;
45121 int res1 = 0 ;
45122 int val2 ;
45123 int ecode2 = 0 ;
45124 int val3 ;
45125 int ecode3 = 0 ;
45126 PyObject * obj0 = 0 ;
45127 PyObject * obj1 = 0 ;
45128 PyObject * obj2 = 0 ;
45129 char * kwnames[] = {
45130 (char *) "self",(char *) "x",(char *) "y", NULL
45131 };
45132
45133 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45134 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45135 if (!SWIG_IsOK(res1)) {
45136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45137 }
45138 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45139 ecode2 = SWIG_AsVal_int(obj1, &val2);
45140 if (!SWIG_IsOK(ecode2)) {
45141 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
45142 }
45143 arg2 = static_cast< int >(val2);
45144 ecode3 = SWIG_AsVal_int(obj2, &val3);
45145 if (!SWIG_IsOK(ecode3)) {
45146 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
45147 }
45148 arg3 = static_cast< int >(val3);
45149 {
45150 PyThreadState* __tstate = wxPyBeginAllowThreads();
45151 (arg1)->SetInitSize(arg2,arg3);
45152 wxPyEndAllowThreads(__tstate);
45153 if (PyErr_Occurred()) SWIG_fail;
45154 }
45155 resultobj = SWIG_Py_Void();
45156 return resultobj;
45157 fail:
45158 return NULL;
45159 }
45160
45161
45162 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45163 PyObject *resultobj = 0;
45164 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45165 int arg2 ;
45166 int arg3 ;
45167 void *argp1 = 0 ;
45168 int res1 = 0 ;
45169 int val2 ;
45170 int ecode2 = 0 ;
45171 int val3 ;
45172 int ecode3 = 0 ;
45173 PyObject * obj0 = 0 ;
45174 PyObject * obj1 = 0 ;
45175 PyObject * obj2 = 0 ;
45176 char * kwnames[] = {
45177 (char *) "self",(char *) "width",(char *) "height", NULL
45178 };
45179
45180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45181 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45182 if (!SWIG_IsOK(res1)) {
45183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45184 }
45185 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45186 ecode2 = SWIG_AsVal_int(obj1, &val2);
45187 if (!SWIG_IsOK(ecode2)) {
45188 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
45189 }
45190 arg2 = static_cast< int >(val2);
45191 ecode3 = SWIG_AsVal_int(obj2, &val3);
45192 if (!SWIG_IsOK(ecode3)) {
45193 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
45194 }
45195 arg3 = static_cast< int >(val3);
45196 {
45197 PyThreadState* __tstate = wxPyBeginAllowThreads();
45198 (arg1)->SetRatio(arg2,arg3);
45199 wxPyEndAllowThreads(__tstate);
45200 if (PyErr_Occurred()) SWIG_fail;
45201 }
45202 resultobj = SWIG_Py_Void();
45203 return resultobj;
45204 fail:
45205 return NULL;
45206 }
45207
45208
45209 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45210 PyObject *resultobj = 0;
45211 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45212 wxSize *arg2 = 0 ;
45213 void *argp1 = 0 ;
45214 int res1 = 0 ;
45215 wxSize temp2 ;
45216 PyObject * obj0 = 0 ;
45217 PyObject * obj1 = 0 ;
45218 char * kwnames[] = {
45219 (char *) "self",(char *) "size", NULL
45220 };
45221
45222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
45223 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45224 if (!SWIG_IsOK(res1)) {
45225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45226 }
45227 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45228 {
45229 arg2 = &temp2;
45230 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
45231 }
45232 {
45233 PyThreadState* __tstate = wxPyBeginAllowThreads();
45234 (arg1)->SetRatio((wxSize const &)*arg2);
45235 wxPyEndAllowThreads(__tstate);
45236 if (PyErr_Occurred()) SWIG_fail;
45237 }
45238 resultobj = SWIG_Py_Void();
45239 return resultobj;
45240 fail:
45241 return NULL;
45242 }
45243
45244
45245 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45246 PyObject *resultobj = 0;
45247 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45248 float arg2 ;
45249 void *argp1 = 0 ;
45250 int res1 = 0 ;
45251 float val2 ;
45252 int ecode2 = 0 ;
45253 PyObject * obj0 = 0 ;
45254 PyObject * obj1 = 0 ;
45255 char * kwnames[] = {
45256 (char *) "self",(char *) "ratio", NULL
45257 };
45258
45259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
45260 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45261 if (!SWIG_IsOK(res1)) {
45262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45263 }
45264 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45265 ecode2 = SWIG_AsVal_float(obj1, &val2);
45266 if (!SWIG_IsOK(ecode2)) {
45267 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
45268 }
45269 arg2 = static_cast< float >(val2);
45270 {
45271 PyThreadState* __tstate = wxPyBeginAllowThreads();
45272 (arg1)->SetRatio(arg2);
45273 wxPyEndAllowThreads(__tstate);
45274 if (PyErr_Occurred()) SWIG_fail;
45275 }
45276 resultobj = SWIG_Py_Void();
45277 return resultobj;
45278 fail:
45279 return NULL;
45280 }
45281
45282
45283 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45284 PyObject *resultobj = 0;
45285 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45286 float result;
45287 void *argp1 = 0 ;
45288 int res1 = 0 ;
45289 PyObject *swig_obj[1] ;
45290
45291 if (!args) SWIG_fail;
45292 swig_obj[0] = args;
45293 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45294 if (!SWIG_IsOK(res1)) {
45295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45296 }
45297 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45298 {
45299 PyThreadState* __tstate = wxPyBeginAllowThreads();
45300 result = (float)(arg1)->GetRatio();
45301 wxPyEndAllowThreads(__tstate);
45302 if (PyErr_Occurred()) SWIG_fail;
45303 }
45304 resultobj = SWIG_From_float(static_cast< float >(result));
45305 return resultobj;
45306 fail:
45307 return NULL;
45308 }
45309
45310
45311 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45312 PyObject *resultobj = 0;
45313 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45314 wxRect result;
45315 void *argp1 = 0 ;
45316 int res1 = 0 ;
45317 PyObject *swig_obj[1] ;
45318
45319 if (!args) SWIG_fail;
45320 swig_obj[0] = args;
45321 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45322 if (!SWIG_IsOK(res1)) {
45323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45324 }
45325 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45326 {
45327 PyThreadState* __tstate = wxPyBeginAllowThreads();
45328 result = (arg1)->GetRect();
45329 wxPyEndAllowThreads(__tstate);
45330 if (PyErr_Occurred()) SWIG_fail;
45331 }
45332 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
45333 return resultobj;
45334 fail:
45335 return NULL;
45336 }
45337
45338
45339 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45340 PyObject *resultobj = 0;
45341 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45342 bool result;
45343 void *argp1 = 0 ;
45344 int res1 = 0 ;
45345 PyObject *swig_obj[1] ;
45346
45347 if (!args) SWIG_fail;
45348 swig_obj[0] = args;
45349 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45350 if (!SWIG_IsOK(res1)) {
45351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45352 }
45353 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45354 {
45355 PyThreadState* __tstate = wxPyBeginAllowThreads();
45356 result = (bool)(arg1)->IsWindow();
45357 wxPyEndAllowThreads(__tstate);
45358 if (PyErr_Occurred()) SWIG_fail;
45359 }
45360 {
45361 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45362 }
45363 return resultobj;
45364 fail:
45365 return NULL;
45366 }
45367
45368
45369 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45370 PyObject *resultobj = 0;
45371 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45372 bool result;
45373 void *argp1 = 0 ;
45374 int res1 = 0 ;
45375 PyObject *swig_obj[1] ;
45376
45377 if (!args) SWIG_fail;
45378 swig_obj[0] = args;
45379 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45380 if (!SWIG_IsOK(res1)) {
45381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45382 }
45383 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45384 {
45385 PyThreadState* __tstate = wxPyBeginAllowThreads();
45386 result = (bool)(arg1)->IsSizer();
45387 wxPyEndAllowThreads(__tstate);
45388 if (PyErr_Occurred()) SWIG_fail;
45389 }
45390 {
45391 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45392 }
45393 return resultobj;
45394 fail:
45395 return NULL;
45396 }
45397
45398
45399 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45400 PyObject *resultobj = 0;
45401 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45402 bool result;
45403 void *argp1 = 0 ;
45404 int res1 = 0 ;
45405 PyObject *swig_obj[1] ;
45406
45407 if (!args) SWIG_fail;
45408 swig_obj[0] = args;
45409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45410 if (!SWIG_IsOK(res1)) {
45411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45412 }
45413 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45414 {
45415 PyThreadState* __tstate = wxPyBeginAllowThreads();
45416 result = (bool)(arg1)->IsSpacer();
45417 wxPyEndAllowThreads(__tstate);
45418 if (PyErr_Occurred()) SWIG_fail;
45419 }
45420 {
45421 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45422 }
45423 return resultobj;
45424 fail:
45425 return NULL;
45426 }
45427
45428
45429 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45430 PyObject *resultobj = 0;
45431 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45432 int arg2 ;
45433 void *argp1 = 0 ;
45434 int res1 = 0 ;
45435 int val2 ;
45436 int ecode2 = 0 ;
45437 PyObject * obj0 = 0 ;
45438 PyObject * obj1 = 0 ;
45439 char * kwnames[] = {
45440 (char *) "self",(char *) "proportion", NULL
45441 };
45442
45443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
45444 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45445 if (!SWIG_IsOK(res1)) {
45446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45447 }
45448 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45449 ecode2 = SWIG_AsVal_int(obj1, &val2);
45450 if (!SWIG_IsOK(ecode2)) {
45451 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
45452 }
45453 arg2 = static_cast< int >(val2);
45454 {
45455 PyThreadState* __tstate = wxPyBeginAllowThreads();
45456 (arg1)->SetProportion(arg2);
45457 wxPyEndAllowThreads(__tstate);
45458 if (PyErr_Occurred()) SWIG_fail;
45459 }
45460 resultobj = SWIG_Py_Void();
45461 return resultobj;
45462 fail:
45463 return NULL;
45464 }
45465
45466
45467 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45468 PyObject *resultobj = 0;
45469 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45470 int result;
45471 void *argp1 = 0 ;
45472 int res1 = 0 ;
45473 PyObject *swig_obj[1] ;
45474
45475 if (!args) SWIG_fail;
45476 swig_obj[0] = args;
45477 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45478 if (!SWIG_IsOK(res1)) {
45479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45480 }
45481 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45482 {
45483 PyThreadState* __tstate = wxPyBeginAllowThreads();
45484 result = (int)(arg1)->GetProportion();
45485 wxPyEndAllowThreads(__tstate);
45486 if (PyErr_Occurred()) SWIG_fail;
45487 }
45488 resultobj = SWIG_From_int(static_cast< int >(result));
45489 return resultobj;
45490 fail:
45491 return NULL;
45492 }
45493
45494
45495 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45496 PyObject *resultobj = 0;
45497 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45498 int arg2 ;
45499 void *argp1 = 0 ;
45500 int res1 = 0 ;
45501 int val2 ;
45502 int ecode2 = 0 ;
45503 PyObject * obj0 = 0 ;
45504 PyObject * obj1 = 0 ;
45505 char * kwnames[] = {
45506 (char *) "self",(char *) "flag", NULL
45507 };
45508
45509 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
45510 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45511 if (!SWIG_IsOK(res1)) {
45512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45513 }
45514 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45515 ecode2 = SWIG_AsVal_int(obj1, &val2);
45516 if (!SWIG_IsOK(ecode2)) {
45517 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
45518 }
45519 arg2 = static_cast< int >(val2);
45520 {
45521 PyThreadState* __tstate = wxPyBeginAllowThreads();
45522 (arg1)->SetFlag(arg2);
45523 wxPyEndAllowThreads(__tstate);
45524 if (PyErr_Occurred()) SWIG_fail;
45525 }
45526 resultobj = SWIG_Py_Void();
45527 return resultobj;
45528 fail:
45529 return NULL;
45530 }
45531
45532
45533 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45534 PyObject *resultobj = 0;
45535 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45536 int result;
45537 void *argp1 = 0 ;
45538 int res1 = 0 ;
45539 PyObject *swig_obj[1] ;
45540
45541 if (!args) SWIG_fail;
45542 swig_obj[0] = args;
45543 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45544 if (!SWIG_IsOK(res1)) {
45545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45546 }
45547 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45548 {
45549 PyThreadState* __tstate = wxPyBeginAllowThreads();
45550 result = (int)(arg1)->GetFlag();
45551 wxPyEndAllowThreads(__tstate);
45552 if (PyErr_Occurred()) SWIG_fail;
45553 }
45554 resultobj = SWIG_From_int(static_cast< int >(result));
45555 return resultobj;
45556 fail:
45557 return NULL;
45558 }
45559
45560
45561 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45562 PyObject *resultobj = 0;
45563 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45564 int arg2 ;
45565 void *argp1 = 0 ;
45566 int res1 = 0 ;
45567 int val2 ;
45568 int ecode2 = 0 ;
45569 PyObject * obj0 = 0 ;
45570 PyObject * obj1 = 0 ;
45571 char * kwnames[] = {
45572 (char *) "self",(char *) "border", NULL
45573 };
45574
45575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
45576 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45577 if (!SWIG_IsOK(res1)) {
45578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45579 }
45580 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45581 ecode2 = SWIG_AsVal_int(obj1, &val2);
45582 if (!SWIG_IsOK(ecode2)) {
45583 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
45584 }
45585 arg2 = static_cast< int >(val2);
45586 {
45587 PyThreadState* __tstate = wxPyBeginAllowThreads();
45588 (arg1)->SetBorder(arg2);
45589 wxPyEndAllowThreads(__tstate);
45590 if (PyErr_Occurred()) SWIG_fail;
45591 }
45592 resultobj = SWIG_Py_Void();
45593 return resultobj;
45594 fail:
45595 return NULL;
45596 }
45597
45598
45599 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45600 PyObject *resultobj = 0;
45601 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45602 int result;
45603 void *argp1 = 0 ;
45604 int res1 = 0 ;
45605 PyObject *swig_obj[1] ;
45606
45607 if (!args) SWIG_fail;
45608 swig_obj[0] = args;
45609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45610 if (!SWIG_IsOK(res1)) {
45611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45612 }
45613 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45614 {
45615 PyThreadState* __tstate = wxPyBeginAllowThreads();
45616 result = (int)(arg1)->GetBorder();
45617 wxPyEndAllowThreads(__tstate);
45618 if (PyErr_Occurred()) SWIG_fail;
45619 }
45620 resultobj = SWIG_From_int(static_cast< int >(result));
45621 return resultobj;
45622 fail:
45623 return NULL;
45624 }
45625
45626
45627 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45628 PyObject *resultobj = 0;
45629 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45630 wxWindow *result = 0 ;
45631 void *argp1 = 0 ;
45632 int res1 = 0 ;
45633 PyObject *swig_obj[1] ;
45634
45635 if (!args) SWIG_fail;
45636 swig_obj[0] = args;
45637 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45638 if (!SWIG_IsOK(res1)) {
45639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45640 }
45641 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45642 {
45643 PyThreadState* __tstate = wxPyBeginAllowThreads();
45644 result = (wxWindow *)(arg1)->GetWindow();
45645 wxPyEndAllowThreads(__tstate);
45646 if (PyErr_Occurred()) SWIG_fail;
45647 }
45648 {
45649 resultobj = wxPyMake_wxObject(result, 0);
45650 }
45651 return resultobj;
45652 fail:
45653 return NULL;
45654 }
45655
45656
45657 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45658 PyObject *resultobj = 0;
45659 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45660 wxWindow *arg2 = (wxWindow *) 0 ;
45661 void *argp1 = 0 ;
45662 int res1 = 0 ;
45663 void *argp2 = 0 ;
45664 int res2 = 0 ;
45665 PyObject * obj0 = 0 ;
45666 PyObject * obj1 = 0 ;
45667 char * kwnames[] = {
45668 (char *) "self",(char *) "window", NULL
45669 };
45670
45671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
45672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45673 if (!SWIG_IsOK(res1)) {
45674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45675 }
45676 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45677 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
45678 if (!SWIG_IsOK(res2)) {
45679 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
45680 }
45681 arg2 = reinterpret_cast< wxWindow * >(argp2);
45682 {
45683 PyThreadState* __tstate = wxPyBeginAllowThreads();
45684 (arg1)->SetWindow(arg2);
45685 wxPyEndAllowThreads(__tstate);
45686 if (PyErr_Occurred()) SWIG_fail;
45687 }
45688 resultobj = SWIG_Py_Void();
45689 return resultobj;
45690 fail:
45691 return NULL;
45692 }
45693
45694
45695 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45696 PyObject *resultobj = 0;
45697 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45698 wxSizer *result = 0 ;
45699 void *argp1 = 0 ;
45700 int res1 = 0 ;
45701 PyObject *swig_obj[1] ;
45702
45703 if (!args) SWIG_fail;
45704 swig_obj[0] = args;
45705 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45706 if (!SWIG_IsOK(res1)) {
45707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45708 }
45709 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45710 {
45711 PyThreadState* __tstate = wxPyBeginAllowThreads();
45712 result = (wxSizer *)(arg1)->GetSizer();
45713 wxPyEndAllowThreads(__tstate);
45714 if (PyErr_Occurred()) SWIG_fail;
45715 }
45716 {
45717 resultobj = wxPyMake_wxObject(result, (bool)0);
45718 }
45719 return resultobj;
45720 fail:
45721 return NULL;
45722 }
45723
45724
45725 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45726 PyObject *resultobj = 0;
45727 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45728 wxSizer *arg2 = (wxSizer *) 0 ;
45729 void *argp1 = 0 ;
45730 int res1 = 0 ;
45731 int res2 = 0 ;
45732 PyObject * obj0 = 0 ;
45733 PyObject * obj1 = 0 ;
45734 char * kwnames[] = {
45735 (char *) "self",(char *) "sizer", NULL
45736 };
45737
45738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
45739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45740 if (!SWIG_IsOK(res1)) {
45741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45742 }
45743 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45744 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
45745 if (!SWIG_IsOK(res2)) {
45746 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
45747 }
45748 {
45749 PyThreadState* __tstate = wxPyBeginAllowThreads();
45750 (arg1)->SetSizer(arg2);
45751 wxPyEndAllowThreads(__tstate);
45752 if (PyErr_Occurred()) SWIG_fail;
45753 }
45754 resultobj = SWIG_Py_Void();
45755 return resultobj;
45756 fail:
45757 return NULL;
45758 }
45759
45760
45761 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45762 PyObject *resultobj = 0;
45763 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45764 wxSize *result = 0 ;
45765 void *argp1 = 0 ;
45766 int res1 = 0 ;
45767 PyObject *swig_obj[1] ;
45768
45769 if (!args) SWIG_fail;
45770 swig_obj[0] = args;
45771 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45772 if (!SWIG_IsOK(res1)) {
45773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45774 }
45775 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45776 {
45777 PyThreadState* __tstate = wxPyBeginAllowThreads();
45778 {
45779 wxSize const &_result_ref = (arg1)->GetSpacer();
45780 result = (wxSize *) &_result_ref;
45781 }
45782 wxPyEndAllowThreads(__tstate);
45783 if (PyErr_Occurred()) SWIG_fail;
45784 }
45785 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
45786 return resultobj;
45787 fail:
45788 return NULL;
45789 }
45790
45791
45792 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45793 PyObject *resultobj = 0;
45794 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45795 wxSize *arg2 = 0 ;
45796 void *argp1 = 0 ;
45797 int res1 = 0 ;
45798 wxSize temp2 ;
45799 PyObject * obj0 = 0 ;
45800 PyObject * obj1 = 0 ;
45801 char * kwnames[] = {
45802 (char *) "self",(char *) "size", NULL
45803 };
45804
45805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
45806 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45807 if (!SWIG_IsOK(res1)) {
45808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45809 }
45810 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45811 {
45812 arg2 = &temp2;
45813 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
45814 }
45815 {
45816 PyThreadState* __tstate = wxPyBeginAllowThreads();
45817 (arg1)->SetSpacer((wxSize const &)*arg2);
45818 wxPyEndAllowThreads(__tstate);
45819 if (PyErr_Occurred()) SWIG_fail;
45820 }
45821 resultobj = SWIG_Py_Void();
45822 return resultobj;
45823 fail:
45824 return NULL;
45825 }
45826
45827
45828 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45829 PyObject *resultobj = 0;
45830 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45831 bool arg2 ;
45832 void *argp1 = 0 ;
45833 int res1 = 0 ;
45834 bool val2 ;
45835 int ecode2 = 0 ;
45836 PyObject * obj0 = 0 ;
45837 PyObject * obj1 = 0 ;
45838 char * kwnames[] = {
45839 (char *) "self",(char *) "show", NULL
45840 };
45841
45842 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
45843 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45844 if (!SWIG_IsOK(res1)) {
45845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45846 }
45847 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45848 ecode2 = SWIG_AsVal_bool(obj1, &val2);
45849 if (!SWIG_IsOK(ecode2)) {
45850 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
45851 }
45852 arg2 = static_cast< bool >(val2);
45853 {
45854 PyThreadState* __tstate = wxPyBeginAllowThreads();
45855 (arg1)->Show(arg2);
45856 wxPyEndAllowThreads(__tstate);
45857 if (PyErr_Occurred()) SWIG_fail;
45858 }
45859 resultobj = SWIG_Py_Void();
45860 return resultobj;
45861 fail:
45862 return NULL;
45863 }
45864
45865
45866 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45867 PyObject *resultobj = 0;
45868 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45869 bool result;
45870 void *argp1 = 0 ;
45871 int res1 = 0 ;
45872 PyObject *swig_obj[1] ;
45873
45874 if (!args) SWIG_fail;
45875 swig_obj[0] = args;
45876 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45877 if (!SWIG_IsOK(res1)) {
45878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45879 }
45880 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45881 {
45882 PyThreadState* __tstate = wxPyBeginAllowThreads();
45883 result = (bool)(arg1)->IsShown();
45884 wxPyEndAllowThreads(__tstate);
45885 if (PyErr_Occurred()) SWIG_fail;
45886 }
45887 {
45888 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45889 }
45890 return resultobj;
45891 fail:
45892 return NULL;
45893 }
45894
45895
45896 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45897 PyObject *resultobj = 0;
45898 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45899 wxPoint result;
45900 void *argp1 = 0 ;
45901 int res1 = 0 ;
45902 PyObject *swig_obj[1] ;
45903
45904 if (!args) SWIG_fail;
45905 swig_obj[0] = args;
45906 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45907 if (!SWIG_IsOK(res1)) {
45908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45909 }
45910 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45911 {
45912 PyThreadState* __tstate = wxPyBeginAllowThreads();
45913 result = (arg1)->GetPosition();
45914 wxPyEndAllowThreads(__tstate);
45915 if (PyErr_Occurred()) SWIG_fail;
45916 }
45917 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
45918 return resultobj;
45919 fail:
45920 return NULL;
45921 }
45922
45923
45924 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45925 PyObject *resultobj = 0;
45926 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45927 PyObject *result = 0 ;
45928 void *argp1 = 0 ;
45929 int res1 = 0 ;
45930 PyObject *swig_obj[1] ;
45931
45932 if (!args) SWIG_fail;
45933 swig_obj[0] = args;
45934 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45935 if (!SWIG_IsOK(res1)) {
45936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45937 }
45938 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45939 {
45940 PyThreadState* __tstate = wxPyBeginAllowThreads();
45941 result = (PyObject *)wxSizerItem_GetUserData(arg1);
45942 wxPyEndAllowThreads(__tstate);
45943 if (PyErr_Occurred()) SWIG_fail;
45944 }
45945 resultobj = result;
45946 return resultobj;
45947 fail:
45948 return NULL;
45949 }
45950
45951
45952 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45953 PyObject *resultobj = 0;
45954 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45955 PyObject *arg2 = (PyObject *) 0 ;
45956 void *argp1 = 0 ;
45957 int res1 = 0 ;
45958 PyObject * obj0 = 0 ;
45959 PyObject * obj1 = 0 ;
45960 char * kwnames[] = {
45961 (char *) "self",(char *) "userData", NULL
45962 };
45963
45964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
45965 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45966 if (!SWIG_IsOK(res1)) {
45967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45968 }
45969 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45970 arg2 = obj1;
45971 {
45972 PyThreadState* __tstate = wxPyBeginAllowThreads();
45973 wxSizerItem_SetUserData(arg1,arg2);
45974 wxPyEndAllowThreads(__tstate);
45975 if (PyErr_Occurred()) SWIG_fail;
45976 }
45977 resultobj = SWIG_Py_Void();
45978 return resultobj;
45979 fail:
45980 return NULL;
45981 }
45982
45983
45984 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45985 PyObject *obj;
45986 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45987 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
45988 return SWIG_Py_Void();
45989 }
45990
45991 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45992 return SWIG_Python_InitShadowInstance(args);
45993 }
45994
45995 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45996 PyObject *resultobj = 0;
45997 wxSizer *arg1 = (wxSizer *) 0 ;
45998 void *argp1 = 0 ;
45999 int res1 = 0 ;
46000 PyObject *swig_obj[1] ;
46001
46002 if (!args) SWIG_fail;
46003 swig_obj[0] = args;
46004 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46005 if (!SWIG_IsOK(res1)) {
46006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
46007 }
46008 arg1 = reinterpret_cast< wxSizer * >(argp1);
46009 {
46010 PyThreadState* __tstate = wxPyBeginAllowThreads();
46011 delete arg1;
46012
46013 wxPyEndAllowThreads(__tstate);
46014 if (PyErr_Occurred()) SWIG_fail;
46015 }
46016 resultobj = SWIG_Py_Void();
46017 return resultobj;
46018 fail:
46019 return NULL;
46020 }
46021
46022
46023 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46024 PyObject *resultobj = 0;
46025 wxSizer *arg1 = (wxSizer *) 0 ;
46026 PyObject *arg2 = (PyObject *) 0 ;
46027 void *argp1 = 0 ;
46028 int res1 = 0 ;
46029 PyObject * obj0 = 0 ;
46030 PyObject * obj1 = 0 ;
46031 char * kwnames[] = {
46032 (char *) "self",(char *) "_self", NULL
46033 };
46034
46035 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
46036 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46037 if (!SWIG_IsOK(res1)) {
46038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
46039 }
46040 arg1 = reinterpret_cast< wxSizer * >(argp1);
46041 arg2 = obj1;
46042 {
46043 PyThreadState* __tstate = wxPyBeginAllowThreads();
46044 wxSizer__setOORInfo(arg1,arg2);
46045 wxPyEndAllowThreads(__tstate);
46046 if (PyErr_Occurred()) SWIG_fail;
46047 }
46048 resultobj = SWIG_Py_Void();
46049 return resultobj;
46050 fail:
46051 return NULL;
46052 }
46053
46054
46055 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46056 PyObject *resultobj = 0;
46057 wxSizer *arg1 = (wxSizer *) 0 ;
46058 PyObject *arg2 = (PyObject *) 0 ;
46059 int arg3 = (int) 0 ;
46060 int arg4 = (int) 0 ;
46061 int arg5 = (int) 0 ;
46062 PyObject *arg6 = (PyObject *) NULL ;
46063 wxSizerItem *result = 0 ;
46064 void *argp1 = 0 ;
46065 int res1 = 0 ;
46066 int val3 ;
46067 int ecode3 = 0 ;
46068 int val4 ;
46069 int ecode4 = 0 ;
46070 int val5 ;
46071 int ecode5 = 0 ;
46072 PyObject * obj0 = 0 ;
46073 PyObject * obj1 = 0 ;
46074 PyObject * obj2 = 0 ;
46075 PyObject * obj3 = 0 ;
46076 PyObject * obj4 = 0 ;
46077 PyObject * obj5 = 0 ;
46078 char * kwnames[] = {
46079 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46080 };
46081
46082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46083 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46084 if (!SWIG_IsOK(res1)) {
46085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
46086 }
46087 arg1 = reinterpret_cast< wxSizer * >(argp1);
46088 arg2 = obj1;
46089 if (obj2) {
46090 ecode3 = SWIG_AsVal_int(obj2, &val3);
46091 if (!SWIG_IsOK(ecode3)) {
46092 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
46093 }
46094 arg3 = static_cast< int >(val3);
46095 }
46096 if (obj3) {
46097 ecode4 = SWIG_AsVal_int(obj3, &val4);
46098 if (!SWIG_IsOK(ecode4)) {
46099 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
46100 }
46101 arg4 = static_cast< int >(val4);
46102 }
46103 if (obj4) {
46104 ecode5 = SWIG_AsVal_int(obj4, &val5);
46105 if (!SWIG_IsOK(ecode5)) {
46106 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
46107 }
46108 arg5 = static_cast< int >(val5);
46109 }
46110 if (obj5) {
46111 arg6 = obj5;
46112 }
46113 {
46114 PyThreadState* __tstate = wxPyBeginAllowThreads();
46115 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
46116 wxPyEndAllowThreads(__tstate);
46117 if (PyErr_Occurred()) SWIG_fail;
46118 }
46119 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46120 return resultobj;
46121 fail:
46122 return NULL;
46123 }
46124
46125
46126 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46127 PyObject *resultobj = 0;
46128 wxSizer *arg1 = (wxSizer *) 0 ;
46129 int arg2 ;
46130 PyObject *arg3 = (PyObject *) 0 ;
46131 int arg4 = (int) 0 ;
46132 int arg5 = (int) 0 ;
46133 int arg6 = (int) 0 ;
46134 PyObject *arg7 = (PyObject *) NULL ;
46135 wxSizerItem *result = 0 ;
46136 void *argp1 = 0 ;
46137 int res1 = 0 ;
46138 int val2 ;
46139 int ecode2 = 0 ;
46140 int val4 ;
46141 int ecode4 = 0 ;
46142 int val5 ;
46143 int ecode5 = 0 ;
46144 int val6 ;
46145 int ecode6 = 0 ;
46146 PyObject * obj0 = 0 ;
46147 PyObject * obj1 = 0 ;
46148 PyObject * obj2 = 0 ;
46149 PyObject * obj3 = 0 ;
46150 PyObject * obj4 = 0 ;
46151 PyObject * obj5 = 0 ;
46152 PyObject * obj6 = 0 ;
46153 char * kwnames[] = {
46154 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46155 };
46156
46157 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
46158 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46159 if (!SWIG_IsOK(res1)) {
46160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
46161 }
46162 arg1 = reinterpret_cast< wxSizer * >(argp1);
46163 ecode2 = SWIG_AsVal_int(obj1, &val2);
46164 if (!SWIG_IsOK(ecode2)) {
46165 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
46166 }
46167 arg2 = static_cast< int >(val2);
46168 arg3 = obj2;
46169 if (obj3) {
46170 ecode4 = SWIG_AsVal_int(obj3, &val4);
46171 if (!SWIG_IsOK(ecode4)) {
46172 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
46173 }
46174 arg4 = static_cast< int >(val4);
46175 }
46176 if (obj4) {
46177 ecode5 = SWIG_AsVal_int(obj4, &val5);
46178 if (!SWIG_IsOK(ecode5)) {
46179 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
46180 }
46181 arg5 = static_cast< int >(val5);
46182 }
46183 if (obj5) {
46184 ecode6 = SWIG_AsVal_int(obj5, &val6);
46185 if (!SWIG_IsOK(ecode6)) {
46186 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
46187 }
46188 arg6 = static_cast< int >(val6);
46189 }
46190 if (obj6) {
46191 arg7 = obj6;
46192 }
46193 {
46194 PyThreadState* __tstate = wxPyBeginAllowThreads();
46195 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
46196 wxPyEndAllowThreads(__tstate);
46197 if (PyErr_Occurred()) SWIG_fail;
46198 }
46199 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46200 return resultobj;
46201 fail:
46202 return NULL;
46203 }
46204
46205
46206 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46207 PyObject *resultobj = 0;
46208 wxSizer *arg1 = (wxSizer *) 0 ;
46209 PyObject *arg2 = (PyObject *) 0 ;
46210 int arg3 = (int) 0 ;
46211 int arg4 = (int) 0 ;
46212 int arg5 = (int) 0 ;
46213 PyObject *arg6 = (PyObject *) NULL ;
46214 wxSizerItem *result = 0 ;
46215 void *argp1 = 0 ;
46216 int res1 = 0 ;
46217 int val3 ;
46218 int ecode3 = 0 ;
46219 int val4 ;
46220 int ecode4 = 0 ;
46221 int val5 ;
46222 int ecode5 = 0 ;
46223 PyObject * obj0 = 0 ;
46224 PyObject * obj1 = 0 ;
46225 PyObject * obj2 = 0 ;
46226 PyObject * obj3 = 0 ;
46227 PyObject * obj4 = 0 ;
46228 PyObject * obj5 = 0 ;
46229 char * kwnames[] = {
46230 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46231 };
46232
46233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46234 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46235 if (!SWIG_IsOK(res1)) {
46236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
46237 }
46238 arg1 = reinterpret_cast< wxSizer * >(argp1);
46239 arg2 = obj1;
46240 if (obj2) {
46241 ecode3 = SWIG_AsVal_int(obj2, &val3);
46242 if (!SWIG_IsOK(ecode3)) {
46243 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
46244 }
46245 arg3 = static_cast< int >(val3);
46246 }
46247 if (obj3) {
46248 ecode4 = SWIG_AsVal_int(obj3, &val4);
46249 if (!SWIG_IsOK(ecode4)) {
46250 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
46251 }
46252 arg4 = static_cast< int >(val4);
46253 }
46254 if (obj4) {
46255 ecode5 = SWIG_AsVal_int(obj4, &val5);
46256 if (!SWIG_IsOK(ecode5)) {
46257 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
46258 }
46259 arg5 = static_cast< int >(val5);
46260 }
46261 if (obj5) {
46262 arg6 = obj5;
46263 }
46264 {
46265 PyThreadState* __tstate = wxPyBeginAllowThreads();
46266 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
46267 wxPyEndAllowThreads(__tstate);
46268 if (PyErr_Occurred()) SWIG_fail;
46269 }
46270 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46271 return resultobj;
46272 fail:
46273 return NULL;
46274 }
46275
46276
46277 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46278 PyObject *resultobj = 0;
46279 wxSizer *arg1 = (wxSizer *) 0 ;
46280 PyObject *arg2 = (PyObject *) 0 ;
46281 bool result;
46282 void *argp1 = 0 ;
46283 int res1 = 0 ;
46284 PyObject * obj0 = 0 ;
46285 PyObject * obj1 = 0 ;
46286 char * kwnames[] = {
46287 (char *) "self",(char *) "item", NULL
46288 };
46289
46290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
46291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46292 if (!SWIG_IsOK(res1)) {
46293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
46294 }
46295 arg1 = reinterpret_cast< wxSizer * >(argp1);
46296 arg2 = obj1;
46297 {
46298 PyThreadState* __tstate = wxPyBeginAllowThreads();
46299 result = (bool)wxSizer_Remove(arg1,arg2);
46300 wxPyEndAllowThreads(__tstate);
46301 if (PyErr_Occurred()) SWIG_fail;
46302 }
46303 {
46304 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46305 }
46306 return resultobj;
46307 fail:
46308 return NULL;
46309 }
46310
46311
46312 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46313 PyObject *resultobj = 0;
46314 wxSizer *arg1 = (wxSizer *) 0 ;
46315 PyObject *arg2 = (PyObject *) 0 ;
46316 bool result;
46317 void *argp1 = 0 ;
46318 int res1 = 0 ;
46319 PyObject * obj0 = 0 ;
46320 PyObject * obj1 = 0 ;
46321 char * kwnames[] = {
46322 (char *) "self",(char *) "item", NULL
46323 };
46324
46325 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
46326 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46327 if (!SWIG_IsOK(res1)) {
46328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
46329 }
46330 arg1 = reinterpret_cast< wxSizer * >(argp1);
46331 arg2 = obj1;
46332 {
46333 PyThreadState* __tstate = wxPyBeginAllowThreads();
46334 result = (bool)wxSizer_Detach(arg1,arg2);
46335 wxPyEndAllowThreads(__tstate);
46336 if (PyErr_Occurred()) SWIG_fail;
46337 }
46338 {
46339 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46340 }
46341 return resultobj;
46342 fail:
46343 return NULL;
46344 }
46345
46346
46347 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46348 PyObject *resultobj = 0;
46349 wxSizer *arg1 = (wxSizer *) 0 ;
46350 PyObject *arg2 = (PyObject *) 0 ;
46351 wxSizerItem *result = 0 ;
46352 void *argp1 = 0 ;
46353 int res1 = 0 ;
46354 PyObject * obj0 = 0 ;
46355 PyObject * obj1 = 0 ;
46356 char * kwnames[] = {
46357 (char *) "self",(char *) "item", NULL
46358 };
46359
46360 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
46361 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46362 if (!SWIG_IsOK(res1)) {
46363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46364 }
46365 arg1 = reinterpret_cast< wxSizer * >(argp1);
46366 arg2 = obj1;
46367 {
46368 PyThreadState* __tstate = wxPyBeginAllowThreads();
46369 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
46370 wxPyEndAllowThreads(__tstate);
46371 if (PyErr_Occurred()) SWIG_fail;
46372 }
46373 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46374 return resultobj;
46375 fail:
46376 return NULL;
46377 }
46378
46379
46380 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46381 PyObject *resultobj = 0;
46382 wxSizer *arg1 = (wxSizer *) 0 ;
46383 PyObject *arg2 = (PyObject *) 0 ;
46384 wxSize *arg3 = 0 ;
46385 void *argp1 = 0 ;
46386 int res1 = 0 ;
46387 wxSize temp3 ;
46388 PyObject * obj0 = 0 ;
46389 PyObject * obj1 = 0 ;
46390 PyObject * obj2 = 0 ;
46391 char * kwnames[] = {
46392 (char *) "self",(char *) "item",(char *) "size", NULL
46393 };
46394
46395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46396 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46397 if (!SWIG_IsOK(res1)) {
46398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46399 }
46400 arg1 = reinterpret_cast< wxSizer * >(argp1);
46401 arg2 = obj1;
46402 {
46403 arg3 = &temp3;
46404 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
46405 }
46406 {
46407 PyThreadState* __tstate = wxPyBeginAllowThreads();
46408 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
46409 wxPyEndAllowThreads(__tstate);
46410 if (PyErr_Occurred()) SWIG_fail;
46411 }
46412 resultobj = SWIG_Py_Void();
46413 return resultobj;
46414 fail:
46415 return NULL;
46416 }
46417
46418
46419 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46420 PyObject *resultobj = 0;
46421 wxSizer *arg1 = (wxSizer *) 0 ;
46422 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
46423 wxSizerItem *result = 0 ;
46424 void *argp1 = 0 ;
46425 int res1 = 0 ;
46426 int res2 = 0 ;
46427 PyObject * obj0 = 0 ;
46428 PyObject * obj1 = 0 ;
46429 char * kwnames[] = {
46430 (char *) "self",(char *) "item", NULL
46431 };
46432
46433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
46434 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46435 if (!SWIG_IsOK(res1)) {
46436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46437 }
46438 arg1 = reinterpret_cast< wxSizer * >(argp1);
46439 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46440 if (!SWIG_IsOK(res2)) {
46441 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
46442 }
46443 {
46444 PyThreadState* __tstate = wxPyBeginAllowThreads();
46445 result = (wxSizerItem *)(arg1)->Add(arg2);
46446 wxPyEndAllowThreads(__tstate);
46447 if (PyErr_Occurred()) SWIG_fail;
46448 }
46449 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46450 return resultobj;
46451 fail:
46452 return NULL;
46453 }
46454
46455
46456 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46457 PyObject *resultobj = 0;
46458 wxSizer *arg1 = (wxSizer *) 0 ;
46459 size_t arg2 ;
46460 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
46461 wxSizerItem *result = 0 ;
46462 void *argp1 = 0 ;
46463 int res1 = 0 ;
46464 size_t val2 ;
46465 int ecode2 = 0 ;
46466 int res3 = 0 ;
46467 PyObject * obj0 = 0 ;
46468 PyObject * obj1 = 0 ;
46469 PyObject * obj2 = 0 ;
46470 char * kwnames[] = {
46471 (char *) "self",(char *) "index",(char *) "item", NULL
46472 };
46473
46474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46475 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46476 if (!SWIG_IsOK(res1)) {
46477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46478 }
46479 arg1 = reinterpret_cast< wxSizer * >(argp1);
46480 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
46481 if (!SWIG_IsOK(ecode2)) {
46482 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
46483 }
46484 arg2 = static_cast< size_t >(val2);
46485 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46486 if (!SWIG_IsOK(res3)) {
46487 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
46488 }
46489 {
46490 PyThreadState* __tstate = wxPyBeginAllowThreads();
46491 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
46492 wxPyEndAllowThreads(__tstate);
46493 if (PyErr_Occurred()) SWIG_fail;
46494 }
46495 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46496 return resultobj;
46497 fail:
46498 return NULL;
46499 }
46500
46501
46502 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46503 PyObject *resultobj = 0;
46504 wxSizer *arg1 = (wxSizer *) 0 ;
46505 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
46506 wxSizerItem *result = 0 ;
46507 void *argp1 = 0 ;
46508 int res1 = 0 ;
46509 int res2 = 0 ;
46510 PyObject * obj0 = 0 ;
46511 PyObject * obj1 = 0 ;
46512 char * kwnames[] = {
46513 (char *) "self",(char *) "item", NULL
46514 };
46515
46516 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
46517 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46518 if (!SWIG_IsOK(res1)) {
46519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46520 }
46521 arg1 = reinterpret_cast< wxSizer * >(argp1);
46522 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46523 if (!SWIG_IsOK(res2)) {
46524 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
46525 }
46526 {
46527 PyThreadState* __tstate = wxPyBeginAllowThreads();
46528 result = (wxSizerItem *)(arg1)->Prepend(arg2);
46529 wxPyEndAllowThreads(__tstate);
46530 if (PyErr_Occurred()) SWIG_fail;
46531 }
46532 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46533 return resultobj;
46534 fail:
46535 return NULL;
46536 }
46537
46538
46539 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46540 PyObject *resultobj = 0;
46541 wxSizer *arg1 = (wxSizer *) 0 ;
46542 int arg2 ;
46543 int arg3 ;
46544 int arg4 ;
46545 int arg5 ;
46546 void *argp1 = 0 ;
46547 int res1 = 0 ;
46548 int val2 ;
46549 int ecode2 = 0 ;
46550 int val3 ;
46551 int ecode3 = 0 ;
46552 int val4 ;
46553 int ecode4 = 0 ;
46554 int val5 ;
46555 int ecode5 = 0 ;
46556 PyObject * obj0 = 0 ;
46557 PyObject * obj1 = 0 ;
46558 PyObject * obj2 = 0 ;
46559 PyObject * obj3 = 0 ;
46560 PyObject * obj4 = 0 ;
46561 char * kwnames[] = {
46562 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
46563 };
46564
46565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
46566 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46567 if (!SWIG_IsOK(res1)) {
46568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
46569 }
46570 arg1 = reinterpret_cast< wxSizer * >(argp1);
46571 ecode2 = SWIG_AsVal_int(obj1, &val2);
46572 if (!SWIG_IsOK(ecode2)) {
46573 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
46574 }
46575 arg2 = static_cast< int >(val2);
46576 ecode3 = SWIG_AsVal_int(obj2, &val3);
46577 if (!SWIG_IsOK(ecode3)) {
46578 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
46579 }
46580 arg3 = static_cast< int >(val3);
46581 ecode4 = SWIG_AsVal_int(obj3, &val4);
46582 if (!SWIG_IsOK(ecode4)) {
46583 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
46584 }
46585 arg4 = static_cast< int >(val4);
46586 ecode5 = SWIG_AsVal_int(obj4, &val5);
46587 if (!SWIG_IsOK(ecode5)) {
46588 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
46589 }
46590 arg5 = static_cast< int >(val5);
46591 {
46592 PyThreadState* __tstate = wxPyBeginAllowThreads();
46593 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
46594 wxPyEndAllowThreads(__tstate);
46595 if (PyErr_Occurred()) SWIG_fail;
46596 }
46597 resultobj = SWIG_Py_Void();
46598 return resultobj;
46599 fail:
46600 return NULL;
46601 }
46602
46603
46604 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46605 PyObject *resultobj = 0;
46606 wxSizer *arg1 = (wxSizer *) 0 ;
46607 wxSize *arg2 = 0 ;
46608 void *argp1 = 0 ;
46609 int res1 = 0 ;
46610 wxSize temp2 ;
46611 PyObject * obj0 = 0 ;
46612 PyObject * obj1 = 0 ;
46613 char * kwnames[] = {
46614 (char *) "self",(char *) "size", NULL
46615 };
46616
46617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
46618 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46619 if (!SWIG_IsOK(res1)) {
46620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46621 }
46622 arg1 = reinterpret_cast< wxSizer * >(argp1);
46623 {
46624 arg2 = &temp2;
46625 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46626 }
46627 {
46628 PyThreadState* __tstate = wxPyBeginAllowThreads();
46629 (arg1)->SetMinSize((wxSize const &)*arg2);
46630 wxPyEndAllowThreads(__tstate);
46631 if (PyErr_Occurred()) SWIG_fail;
46632 }
46633 resultobj = SWIG_Py_Void();
46634 return resultobj;
46635 fail:
46636 return NULL;
46637 }
46638
46639
46640 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46641 PyObject *resultobj = 0;
46642 wxSizer *arg1 = (wxSizer *) 0 ;
46643 wxSize result;
46644 void *argp1 = 0 ;
46645 int res1 = 0 ;
46646 PyObject *swig_obj[1] ;
46647
46648 if (!args) SWIG_fail;
46649 swig_obj[0] = args;
46650 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46651 if (!SWIG_IsOK(res1)) {
46652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46653 }
46654 arg1 = reinterpret_cast< wxSizer * >(argp1);
46655 {
46656 PyThreadState* __tstate = wxPyBeginAllowThreads();
46657 result = (arg1)->GetSize();
46658 wxPyEndAllowThreads(__tstate);
46659 if (PyErr_Occurred()) SWIG_fail;
46660 }
46661 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46662 return resultobj;
46663 fail:
46664 return NULL;
46665 }
46666
46667
46668 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46669 PyObject *resultobj = 0;
46670 wxSizer *arg1 = (wxSizer *) 0 ;
46671 wxPoint result;
46672 void *argp1 = 0 ;
46673 int res1 = 0 ;
46674 PyObject *swig_obj[1] ;
46675
46676 if (!args) SWIG_fail;
46677 swig_obj[0] = args;
46678 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46679 if (!SWIG_IsOK(res1)) {
46680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
46681 }
46682 arg1 = reinterpret_cast< wxSizer * >(argp1);
46683 {
46684 PyThreadState* __tstate = wxPyBeginAllowThreads();
46685 result = (arg1)->GetPosition();
46686 wxPyEndAllowThreads(__tstate);
46687 if (PyErr_Occurred()) SWIG_fail;
46688 }
46689 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
46690 return resultobj;
46691 fail:
46692 return NULL;
46693 }
46694
46695
46696 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46697 PyObject *resultobj = 0;
46698 wxSizer *arg1 = (wxSizer *) 0 ;
46699 wxSize result;
46700 void *argp1 = 0 ;
46701 int res1 = 0 ;
46702 PyObject *swig_obj[1] ;
46703
46704 if (!args) SWIG_fail;
46705 swig_obj[0] = args;
46706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46707 if (!SWIG_IsOK(res1)) {
46708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46709 }
46710 arg1 = reinterpret_cast< wxSizer * >(argp1);
46711 {
46712 PyThreadState* __tstate = wxPyBeginAllowThreads();
46713 result = (arg1)->GetMinSize();
46714 wxPyEndAllowThreads(__tstate);
46715 if (PyErr_Occurred()) SWIG_fail;
46716 }
46717 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46718 return resultobj;
46719 fail:
46720 return NULL;
46721 }
46722
46723
46724 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46725 PyObject *resultobj = 0;
46726 wxSizer *arg1 = (wxSizer *) 0 ;
46727 void *argp1 = 0 ;
46728 int res1 = 0 ;
46729 PyObject *swig_obj[1] ;
46730
46731 if (!args) SWIG_fail;
46732 swig_obj[0] = args;
46733 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46734 if (!SWIG_IsOK(res1)) {
46735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
46736 }
46737 arg1 = reinterpret_cast< wxSizer * >(argp1);
46738 {
46739 PyThreadState* __tstate = wxPyBeginAllowThreads();
46740 (arg1)->RecalcSizes();
46741 wxPyEndAllowThreads(__tstate);
46742 if (PyErr_Occurred()) SWIG_fail;
46743 }
46744 resultobj = SWIG_Py_Void();
46745 return resultobj;
46746 fail:
46747 return NULL;
46748 }
46749
46750
46751 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46752 PyObject *resultobj = 0;
46753 wxSizer *arg1 = (wxSizer *) 0 ;
46754 wxSize result;
46755 void *argp1 = 0 ;
46756 int res1 = 0 ;
46757 PyObject *swig_obj[1] ;
46758
46759 if (!args) SWIG_fail;
46760 swig_obj[0] = args;
46761 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46762 if (!SWIG_IsOK(res1)) {
46763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
46764 }
46765 arg1 = reinterpret_cast< wxSizer * >(argp1);
46766 {
46767 PyThreadState* __tstate = wxPyBeginAllowThreads();
46768 result = (arg1)->CalcMin();
46769 wxPyEndAllowThreads(__tstate);
46770 if (PyErr_Occurred()) SWIG_fail;
46771 }
46772 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46773 return resultobj;
46774 fail:
46775 return NULL;
46776 }
46777
46778
46779 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46780 PyObject *resultobj = 0;
46781 wxSizer *arg1 = (wxSizer *) 0 ;
46782 void *argp1 = 0 ;
46783 int res1 = 0 ;
46784 PyObject *swig_obj[1] ;
46785
46786 if (!args) SWIG_fail;
46787 swig_obj[0] = args;
46788 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46789 if (!SWIG_IsOK(res1)) {
46790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
46791 }
46792 arg1 = reinterpret_cast< wxSizer * >(argp1);
46793 {
46794 PyThreadState* __tstate = wxPyBeginAllowThreads();
46795 (arg1)->Layout();
46796 wxPyEndAllowThreads(__tstate);
46797 if (PyErr_Occurred()) SWIG_fail;
46798 }
46799 resultobj = SWIG_Py_Void();
46800 return resultobj;
46801 fail:
46802 return NULL;
46803 }
46804
46805
46806 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46807 PyObject *resultobj = 0;
46808 wxSizer *arg1 = (wxSizer *) 0 ;
46809 wxWindow *arg2 = (wxWindow *) 0 ;
46810 wxSize result;
46811 void *argp1 = 0 ;
46812 int res1 = 0 ;
46813 void *argp2 = 0 ;
46814 int res2 = 0 ;
46815 PyObject * obj0 = 0 ;
46816 PyObject * obj1 = 0 ;
46817 char * kwnames[] = {
46818 (char *) "self",(char *) "window", NULL
46819 };
46820
46821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
46822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46823 if (!SWIG_IsOK(res1)) {
46824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
46825 }
46826 arg1 = reinterpret_cast< wxSizer * >(argp1);
46827 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46828 if (!SWIG_IsOK(res2)) {
46829 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
46830 }
46831 arg2 = reinterpret_cast< wxWindow * >(argp2);
46832 {
46833 PyThreadState* __tstate = wxPyBeginAllowThreads();
46834 result = (arg1)->Fit(arg2);
46835 wxPyEndAllowThreads(__tstate);
46836 if (PyErr_Occurred()) SWIG_fail;
46837 }
46838 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46839 return resultobj;
46840 fail:
46841 return NULL;
46842 }
46843
46844
46845 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46846 PyObject *resultobj = 0;
46847 wxSizer *arg1 = (wxSizer *) 0 ;
46848 wxWindow *arg2 = (wxWindow *) 0 ;
46849 void *argp1 = 0 ;
46850 int res1 = 0 ;
46851 void *argp2 = 0 ;
46852 int res2 = 0 ;
46853 PyObject * obj0 = 0 ;
46854 PyObject * obj1 = 0 ;
46855 char * kwnames[] = {
46856 (char *) "self",(char *) "window", NULL
46857 };
46858
46859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
46860 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46861 if (!SWIG_IsOK(res1)) {
46862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
46863 }
46864 arg1 = reinterpret_cast< wxSizer * >(argp1);
46865 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46866 if (!SWIG_IsOK(res2)) {
46867 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
46868 }
46869 arg2 = reinterpret_cast< wxWindow * >(argp2);
46870 {
46871 PyThreadState* __tstate = wxPyBeginAllowThreads();
46872 (arg1)->FitInside(arg2);
46873 wxPyEndAllowThreads(__tstate);
46874 if (PyErr_Occurred()) SWIG_fail;
46875 }
46876 resultobj = SWIG_Py_Void();
46877 return resultobj;
46878 fail:
46879 return NULL;
46880 }
46881
46882
46883 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46884 PyObject *resultobj = 0;
46885 wxSizer *arg1 = (wxSizer *) 0 ;
46886 wxWindow *arg2 = (wxWindow *) 0 ;
46887 void *argp1 = 0 ;
46888 int res1 = 0 ;
46889 void *argp2 = 0 ;
46890 int res2 = 0 ;
46891 PyObject * obj0 = 0 ;
46892 PyObject * obj1 = 0 ;
46893 char * kwnames[] = {
46894 (char *) "self",(char *) "window", NULL
46895 };
46896
46897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
46898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46899 if (!SWIG_IsOK(res1)) {
46900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
46901 }
46902 arg1 = reinterpret_cast< wxSizer * >(argp1);
46903 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46904 if (!SWIG_IsOK(res2)) {
46905 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
46906 }
46907 arg2 = reinterpret_cast< wxWindow * >(argp2);
46908 {
46909 PyThreadState* __tstate = wxPyBeginAllowThreads();
46910 (arg1)->SetSizeHints(arg2);
46911 wxPyEndAllowThreads(__tstate);
46912 if (PyErr_Occurred()) SWIG_fail;
46913 }
46914 resultobj = SWIG_Py_Void();
46915 return resultobj;
46916 fail:
46917 return NULL;
46918 }
46919
46920
46921 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46922 PyObject *resultobj = 0;
46923 wxSizer *arg1 = (wxSizer *) 0 ;
46924 wxWindow *arg2 = (wxWindow *) 0 ;
46925 void *argp1 = 0 ;
46926 int res1 = 0 ;
46927 void *argp2 = 0 ;
46928 int res2 = 0 ;
46929 PyObject * obj0 = 0 ;
46930 PyObject * obj1 = 0 ;
46931 char * kwnames[] = {
46932 (char *) "self",(char *) "window", NULL
46933 };
46934
46935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
46936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46937 if (!SWIG_IsOK(res1)) {
46938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
46939 }
46940 arg1 = reinterpret_cast< wxSizer * >(argp1);
46941 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46942 if (!SWIG_IsOK(res2)) {
46943 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
46944 }
46945 arg2 = reinterpret_cast< wxWindow * >(argp2);
46946 {
46947 PyThreadState* __tstate = wxPyBeginAllowThreads();
46948 (arg1)->SetVirtualSizeHints(arg2);
46949 wxPyEndAllowThreads(__tstate);
46950 if (PyErr_Occurred()) SWIG_fail;
46951 }
46952 resultobj = SWIG_Py_Void();
46953 return resultobj;
46954 fail:
46955 return NULL;
46956 }
46957
46958
46959 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46960 PyObject *resultobj = 0;
46961 wxSizer *arg1 = (wxSizer *) 0 ;
46962 bool arg2 = (bool) false ;
46963 void *argp1 = 0 ;
46964 int res1 = 0 ;
46965 bool val2 ;
46966 int ecode2 = 0 ;
46967 PyObject * obj0 = 0 ;
46968 PyObject * obj1 = 0 ;
46969 char * kwnames[] = {
46970 (char *) "self",(char *) "deleteWindows", NULL
46971 };
46972
46973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
46974 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46975 if (!SWIG_IsOK(res1)) {
46976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
46977 }
46978 arg1 = reinterpret_cast< wxSizer * >(argp1);
46979 if (obj1) {
46980 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46981 if (!SWIG_IsOK(ecode2)) {
46982 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
46983 }
46984 arg2 = static_cast< bool >(val2);
46985 }
46986 {
46987 PyThreadState* __tstate = wxPyBeginAllowThreads();
46988 (arg1)->Clear(arg2);
46989 wxPyEndAllowThreads(__tstate);
46990 if (PyErr_Occurred()) SWIG_fail;
46991 }
46992 resultobj = SWIG_Py_Void();
46993 return resultobj;
46994 fail:
46995 return NULL;
46996 }
46997
46998
46999 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47000 PyObject *resultobj = 0;
47001 wxSizer *arg1 = (wxSizer *) 0 ;
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_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
47011 }
47012 arg1 = reinterpret_cast< wxSizer * >(argp1);
47013 {
47014 PyThreadState* __tstate = wxPyBeginAllowThreads();
47015 (arg1)->DeleteWindows();
47016 wxPyEndAllowThreads(__tstate);
47017 if (PyErr_Occurred()) SWIG_fail;
47018 }
47019 resultobj = SWIG_Py_Void();
47020 return resultobj;
47021 fail:
47022 return NULL;
47023 }
47024
47025
47026 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47027 PyObject *resultobj = 0;
47028 wxSizer *arg1 = (wxSizer *) 0 ;
47029 PyObject *result = 0 ;
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_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
47039 }
47040 arg1 = reinterpret_cast< wxSizer * >(argp1);
47041 {
47042 PyThreadState* __tstate = wxPyBeginAllowThreads();
47043 result = (PyObject *)wxSizer_GetChildren(arg1);
47044 wxPyEndAllowThreads(__tstate);
47045 if (PyErr_Occurred()) SWIG_fail;
47046 }
47047 resultobj = result;
47048 return resultobj;
47049 fail:
47050 return NULL;
47051 }
47052
47053
47054 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47055 PyObject *resultobj = 0;
47056 wxSizer *arg1 = (wxSizer *) 0 ;
47057 PyObject *arg2 = (PyObject *) 0 ;
47058 bool arg3 = (bool) true ;
47059 bool arg4 = (bool) false ;
47060 bool result;
47061 void *argp1 = 0 ;
47062 int res1 = 0 ;
47063 bool val3 ;
47064 int ecode3 = 0 ;
47065 bool val4 ;
47066 int ecode4 = 0 ;
47067 PyObject * obj0 = 0 ;
47068 PyObject * obj1 = 0 ;
47069 PyObject * obj2 = 0 ;
47070 PyObject * obj3 = 0 ;
47071 char * kwnames[] = {
47072 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
47073 };
47074
47075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47077 if (!SWIG_IsOK(res1)) {
47078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
47079 }
47080 arg1 = reinterpret_cast< wxSizer * >(argp1);
47081 arg2 = obj1;
47082 if (obj2) {
47083 ecode3 = SWIG_AsVal_bool(obj2, &val3);
47084 if (!SWIG_IsOK(ecode3)) {
47085 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
47086 }
47087 arg3 = static_cast< bool >(val3);
47088 }
47089 if (obj3) {
47090 ecode4 = SWIG_AsVal_bool(obj3, &val4);
47091 if (!SWIG_IsOK(ecode4)) {
47092 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
47093 }
47094 arg4 = static_cast< bool >(val4);
47095 }
47096 {
47097 PyThreadState* __tstate = wxPyBeginAllowThreads();
47098 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
47099 wxPyEndAllowThreads(__tstate);
47100 if (PyErr_Occurred()) SWIG_fail;
47101 }
47102 {
47103 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47104 }
47105 return resultobj;
47106 fail:
47107 return NULL;
47108 }
47109
47110
47111 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47112 PyObject *resultobj = 0;
47113 wxSizer *arg1 = (wxSizer *) 0 ;
47114 PyObject *arg2 = (PyObject *) 0 ;
47115 bool result;
47116 void *argp1 = 0 ;
47117 int res1 = 0 ;
47118 PyObject * obj0 = 0 ;
47119 PyObject * obj1 = 0 ;
47120 char * kwnames[] = {
47121 (char *) "self",(char *) "item", NULL
47122 };
47123
47124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
47125 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47126 if (!SWIG_IsOK(res1)) {
47127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
47128 }
47129 arg1 = reinterpret_cast< wxSizer * >(argp1);
47130 arg2 = obj1;
47131 {
47132 PyThreadState* __tstate = wxPyBeginAllowThreads();
47133 result = (bool)wxSizer_IsShown(arg1,arg2);
47134 wxPyEndAllowThreads(__tstate);
47135 if (PyErr_Occurred()) SWIG_fail;
47136 }
47137 {
47138 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47139 }
47140 return resultobj;
47141 fail:
47142 return NULL;
47143 }
47144
47145
47146 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47147 PyObject *resultobj = 0;
47148 wxSizer *arg1 = (wxSizer *) 0 ;
47149 bool arg2 ;
47150 void *argp1 = 0 ;
47151 int res1 = 0 ;
47152 bool val2 ;
47153 int ecode2 = 0 ;
47154 PyObject * obj0 = 0 ;
47155 PyObject * obj1 = 0 ;
47156 char * kwnames[] = {
47157 (char *) "self",(char *) "show", NULL
47158 };
47159
47160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
47161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47162 if (!SWIG_IsOK(res1)) {
47163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
47164 }
47165 arg1 = reinterpret_cast< wxSizer * >(argp1);
47166 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47167 if (!SWIG_IsOK(ecode2)) {
47168 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
47169 }
47170 arg2 = static_cast< bool >(val2);
47171 {
47172 PyThreadState* __tstate = wxPyBeginAllowThreads();
47173 (arg1)->ShowItems(arg2);
47174 wxPyEndAllowThreads(__tstate);
47175 if (PyErr_Occurred()) SWIG_fail;
47176 }
47177 resultobj = SWIG_Py_Void();
47178 return resultobj;
47179 fail:
47180 return NULL;
47181 }
47182
47183
47184 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47185 PyObject *obj;
47186 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47187 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
47188 return SWIG_Py_Void();
47189 }
47190
47191 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47192 PyObject *resultobj = 0;
47193 wxPySizer *result = 0 ;
47194
47195 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
47196 {
47197 PyThreadState* __tstate = wxPyBeginAllowThreads();
47198 result = (wxPySizer *)new wxPySizer();
47199 wxPyEndAllowThreads(__tstate);
47200 if (PyErr_Occurred()) SWIG_fail;
47201 }
47202 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
47203 return resultobj;
47204 fail:
47205 return NULL;
47206 }
47207
47208
47209 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47210 PyObject *resultobj = 0;
47211 wxPySizer *arg1 = (wxPySizer *) 0 ;
47212 PyObject *arg2 = (PyObject *) 0 ;
47213 PyObject *arg3 = (PyObject *) 0 ;
47214 void *argp1 = 0 ;
47215 int res1 = 0 ;
47216 PyObject * obj0 = 0 ;
47217 PyObject * obj1 = 0 ;
47218 PyObject * obj2 = 0 ;
47219 char * kwnames[] = {
47220 (char *) "self",(char *) "self",(char *) "_class", NULL
47221 };
47222
47223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
47225 if (!SWIG_IsOK(res1)) {
47226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
47227 }
47228 arg1 = reinterpret_cast< wxPySizer * >(argp1);
47229 arg2 = obj1;
47230 arg3 = obj2;
47231 {
47232 PyThreadState* __tstate = wxPyBeginAllowThreads();
47233 (arg1)->_setCallbackInfo(arg2,arg3);
47234 wxPyEndAllowThreads(__tstate);
47235 if (PyErr_Occurred()) SWIG_fail;
47236 }
47237 resultobj = SWIG_Py_Void();
47238 return resultobj;
47239 fail:
47240 return NULL;
47241 }
47242
47243
47244 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47245 PyObject *obj;
47246 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47247 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
47248 return SWIG_Py_Void();
47249 }
47250
47251 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47252 return SWIG_Python_InitShadowInstance(args);
47253 }
47254
47255 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47256 PyObject *resultobj = 0;
47257 int arg1 = (int) wxHORIZONTAL ;
47258 wxBoxSizer *result = 0 ;
47259 int val1 ;
47260 int ecode1 = 0 ;
47261 PyObject * obj0 = 0 ;
47262 char * kwnames[] = {
47263 (char *) "orient", NULL
47264 };
47265
47266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
47267 if (obj0) {
47268 ecode1 = SWIG_AsVal_int(obj0, &val1);
47269 if (!SWIG_IsOK(ecode1)) {
47270 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
47271 }
47272 arg1 = static_cast< int >(val1);
47273 }
47274 {
47275 PyThreadState* __tstate = wxPyBeginAllowThreads();
47276 result = (wxBoxSizer *)new wxBoxSizer(arg1);
47277 wxPyEndAllowThreads(__tstate);
47278 if (PyErr_Occurred()) SWIG_fail;
47279 }
47280 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
47281 return resultobj;
47282 fail:
47283 return NULL;
47284 }
47285
47286
47287 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47288 PyObject *resultobj = 0;
47289 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47290 int result;
47291 void *argp1 = 0 ;
47292 int res1 = 0 ;
47293 PyObject *swig_obj[1] ;
47294
47295 if (!args) SWIG_fail;
47296 swig_obj[0] = args;
47297 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47298 if (!SWIG_IsOK(res1)) {
47299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47300 }
47301 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47302 {
47303 PyThreadState* __tstate = wxPyBeginAllowThreads();
47304 result = (int)(arg1)->GetOrientation();
47305 wxPyEndAllowThreads(__tstate);
47306 if (PyErr_Occurred()) SWIG_fail;
47307 }
47308 resultobj = SWIG_From_int(static_cast< int >(result));
47309 return resultobj;
47310 fail:
47311 return NULL;
47312 }
47313
47314
47315 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47316 PyObject *resultobj = 0;
47317 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47318 int arg2 ;
47319 void *argp1 = 0 ;
47320 int res1 = 0 ;
47321 int val2 ;
47322 int ecode2 = 0 ;
47323 PyObject * obj0 = 0 ;
47324 PyObject * obj1 = 0 ;
47325 char * kwnames[] = {
47326 (char *) "self",(char *) "orient", NULL
47327 };
47328
47329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
47330 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47331 if (!SWIG_IsOK(res1)) {
47332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47333 }
47334 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47335 ecode2 = SWIG_AsVal_int(obj1, &val2);
47336 if (!SWIG_IsOK(ecode2)) {
47337 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
47338 }
47339 arg2 = static_cast< int >(val2);
47340 {
47341 PyThreadState* __tstate = wxPyBeginAllowThreads();
47342 (arg1)->SetOrientation(arg2);
47343 wxPyEndAllowThreads(__tstate);
47344 if (PyErr_Occurred()) SWIG_fail;
47345 }
47346 resultobj = SWIG_Py_Void();
47347 return resultobj;
47348 fail:
47349 return NULL;
47350 }
47351
47352
47353 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47354 PyObject *obj;
47355 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47356 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
47357 return SWIG_Py_Void();
47358 }
47359
47360 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47361 return SWIG_Python_InitShadowInstance(args);
47362 }
47363
47364 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47365 PyObject *resultobj = 0;
47366 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
47367 int arg2 = (int) wxHORIZONTAL ;
47368 wxStaticBoxSizer *result = 0 ;
47369 void *argp1 = 0 ;
47370 int res1 = 0 ;
47371 int val2 ;
47372 int ecode2 = 0 ;
47373 PyObject * obj0 = 0 ;
47374 PyObject * obj1 = 0 ;
47375 char * kwnames[] = {
47376 (char *) "box",(char *) "orient", NULL
47377 };
47378
47379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
47380 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
47381 if (!SWIG_IsOK(res1)) {
47382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
47383 }
47384 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
47385 if (obj1) {
47386 ecode2 = SWIG_AsVal_int(obj1, &val2);
47387 if (!SWIG_IsOK(ecode2)) {
47388 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
47389 }
47390 arg2 = static_cast< int >(val2);
47391 }
47392 {
47393 PyThreadState* __tstate = wxPyBeginAllowThreads();
47394 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
47395 wxPyEndAllowThreads(__tstate);
47396 if (PyErr_Occurred()) SWIG_fail;
47397 }
47398 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
47399 return resultobj;
47400 fail:
47401 return NULL;
47402 }
47403
47404
47405 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47406 PyObject *resultobj = 0;
47407 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
47408 wxStaticBox *result = 0 ;
47409 void *argp1 = 0 ;
47410 int res1 = 0 ;
47411 PyObject *swig_obj[1] ;
47412
47413 if (!args) SWIG_fail;
47414 swig_obj[0] = args;
47415 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
47416 if (!SWIG_IsOK(res1)) {
47417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
47418 }
47419 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
47420 {
47421 PyThreadState* __tstate = wxPyBeginAllowThreads();
47422 result = (wxStaticBox *)(arg1)->GetStaticBox();
47423 wxPyEndAllowThreads(__tstate);
47424 if (PyErr_Occurred()) SWIG_fail;
47425 }
47426 {
47427 resultobj = wxPyMake_wxObject(result, (bool)0);
47428 }
47429 return resultobj;
47430 fail:
47431 return NULL;
47432 }
47433
47434
47435 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47436 PyObject *obj;
47437 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47438 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
47439 return SWIG_Py_Void();
47440 }
47441
47442 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47443 return SWIG_Python_InitShadowInstance(args);
47444 }
47445
47446 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47447 PyObject *resultobj = 0;
47448 int arg1 = (int) 1 ;
47449 int arg2 = (int) 0 ;
47450 int arg3 = (int) 0 ;
47451 int arg4 = (int) 0 ;
47452 wxGridSizer *result = 0 ;
47453 int val1 ;
47454 int ecode1 = 0 ;
47455 int val2 ;
47456 int ecode2 = 0 ;
47457 int val3 ;
47458 int ecode3 = 0 ;
47459 int val4 ;
47460 int ecode4 = 0 ;
47461 PyObject * obj0 = 0 ;
47462 PyObject * obj1 = 0 ;
47463 PyObject * obj2 = 0 ;
47464 PyObject * obj3 = 0 ;
47465 char * kwnames[] = {
47466 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
47467 };
47468
47469 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47470 if (obj0) {
47471 ecode1 = SWIG_AsVal_int(obj0, &val1);
47472 if (!SWIG_IsOK(ecode1)) {
47473 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
47474 }
47475 arg1 = static_cast< int >(val1);
47476 }
47477 if (obj1) {
47478 ecode2 = SWIG_AsVal_int(obj1, &val2);
47479 if (!SWIG_IsOK(ecode2)) {
47480 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
47481 }
47482 arg2 = static_cast< int >(val2);
47483 }
47484 if (obj2) {
47485 ecode3 = SWIG_AsVal_int(obj2, &val3);
47486 if (!SWIG_IsOK(ecode3)) {
47487 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
47488 }
47489 arg3 = static_cast< int >(val3);
47490 }
47491 if (obj3) {
47492 ecode4 = SWIG_AsVal_int(obj3, &val4);
47493 if (!SWIG_IsOK(ecode4)) {
47494 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
47495 }
47496 arg4 = static_cast< int >(val4);
47497 }
47498 {
47499 PyThreadState* __tstate = wxPyBeginAllowThreads();
47500 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
47501 wxPyEndAllowThreads(__tstate);
47502 if (PyErr_Occurred()) SWIG_fail;
47503 }
47504 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
47505 return resultobj;
47506 fail:
47507 return NULL;
47508 }
47509
47510
47511 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47512 PyObject *resultobj = 0;
47513 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47514 int arg2 ;
47515 void *argp1 = 0 ;
47516 int res1 = 0 ;
47517 int val2 ;
47518 int ecode2 = 0 ;
47519 PyObject * obj0 = 0 ;
47520 PyObject * obj1 = 0 ;
47521 char * kwnames[] = {
47522 (char *) "self",(char *) "cols", NULL
47523 };
47524
47525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
47526 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47527 if (!SWIG_IsOK(res1)) {
47528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47529 }
47530 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47531 ecode2 = SWIG_AsVal_int(obj1, &val2);
47532 if (!SWIG_IsOK(ecode2)) {
47533 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
47534 }
47535 arg2 = static_cast< int >(val2);
47536 {
47537 PyThreadState* __tstate = wxPyBeginAllowThreads();
47538 (arg1)->SetCols(arg2);
47539 wxPyEndAllowThreads(__tstate);
47540 if (PyErr_Occurred()) SWIG_fail;
47541 }
47542 resultobj = SWIG_Py_Void();
47543 return resultobj;
47544 fail:
47545 return NULL;
47546 }
47547
47548
47549 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47550 PyObject *resultobj = 0;
47551 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47552 int arg2 ;
47553 void *argp1 = 0 ;
47554 int res1 = 0 ;
47555 int val2 ;
47556 int ecode2 = 0 ;
47557 PyObject * obj0 = 0 ;
47558 PyObject * obj1 = 0 ;
47559 char * kwnames[] = {
47560 (char *) "self",(char *) "rows", NULL
47561 };
47562
47563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
47564 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47565 if (!SWIG_IsOK(res1)) {
47566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47567 }
47568 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47569 ecode2 = SWIG_AsVal_int(obj1, &val2);
47570 if (!SWIG_IsOK(ecode2)) {
47571 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
47572 }
47573 arg2 = static_cast< int >(val2);
47574 {
47575 PyThreadState* __tstate = wxPyBeginAllowThreads();
47576 (arg1)->SetRows(arg2);
47577 wxPyEndAllowThreads(__tstate);
47578 if (PyErr_Occurred()) SWIG_fail;
47579 }
47580 resultobj = SWIG_Py_Void();
47581 return resultobj;
47582 fail:
47583 return NULL;
47584 }
47585
47586
47587 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47588 PyObject *resultobj = 0;
47589 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47590 int arg2 ;
47591 void *argp1 = 0 ;
47592 int res1 = 0 ;
47593 int val2 ;
47594 int ecode2 = 0 ;
47595 PyObject * obj0 = 0 ;
47596 PyObject * obj1 = 0 ;
47597 char * kwnames[] = {
47598 (char *) "self",(char *) "gap", NULL
47599 };
47600
47601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
47602 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47603 if (!SWIG_IsOK(res1)) {
47604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47605 }
47606 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47607 ecode2 = SWIG_AsVal_int(obj1, &val2);
47608 if (!SWIG_IsOK(ecode2)) {
47609 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
47610 }
47611 arg2 = static_cast< int >(val2);
47612 {
47613 PyThreadState* __tstate = wxPyBeginAllowThreads();
47614 (arg1)->SetVGap(arg2);
47615 wxPyEndAllowThreads(__tstate);
47616 if (PyErr_Occurred()) SWIG_fail;
47617 }
47618 resultobj = SWIG_Py_Void();
47619 return resultobj;
47620 fail:
47621 return NULL;
47622 }
47623
47624
47625 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47626 PyObject *resultobj = 0;
47627 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47628 int arg2 ;
47629 void *argp1 = 0 ;
47630 int res1 = 0 ;
47631 int val2 ;
47632 int ecode2 = 0 ;
47633 PyObject * obj0 = 0 ;
47634 PyObject * obj1 = 0 ;
47635 char * kwnames[] = {
47636 (char *) "self",(char *) "gap", NULL
47637 };
47638
47639 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
47640 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47641 if (!SWIG_IsOK(res1)) {
47642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47643 }
47644 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47645 ecode2 = SWIG_AsVal_int(obj1, &val2);
47646 if (!SWIG_IsOK(ecode2)) {
47647 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
47648 }
47649 arg2 = static_cast< int >(val2);
47650 {
47651 PyThreadState* __tstate = wxPyBeginAllowThreads();
47652 (arg1)->SetHGap(arg2);
47653 wxPyEndAllowThreads(__tstate);
47654 if (PyErr_Occurred()) SWIG_fail;
47655 }
47656 resultobj = SWIG_Py_Void();
47657 return resultobj;
47658 fail:
47659 return NULL;
47660 }
47661
47662
47663 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47664 PyObject *resultobj = 0;
47665 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47666 int result;
47667 void *argp1 = 0 ;
47668 int res1 = 0 ;
47669 PyObject *swig_obj[1] ;
47670
47671 if (!args) SWIG_fail;
47672 swig_obj[0] = args;
47673 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47674 if (!SWIG_IsOK(res1)) {
47675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47676 }
47677 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47678 {
47679 PyThreadState* __tstate = wxPyBeginAllowThreads();
47680 result = (int)(arg1)->GetCols();
47681 wxPyEndAllowThreads(__tstate);
47682 if (PyErr_Occurred()) SWIG_fail;
47683 }
47684 resultobj = SWIG_From_int(static_cast< int >(result));
47685 return resultobj;
47686 fail:
47687 return NULL;
47688 }
47689
47690
47691 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47692 PyObject *resultobj = 0;
47693 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47694 int result;
47695 void *argp1 = 0 ;
47696 int res1 = 0 ;
47697 PyObject *swig_obj[1] ;
47698
47699 if (!args) SWIG_fail;
47700 swig_obj[0] = args;
47701 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47702 if (!SWIG_IsOK(res1)) {
47703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47704 }
47705 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47706 {
47707 PyThreadState* __tstate = wxPyBeginAllowThreads();
47708 result = (int)(arg1)->GetRows();
47709 wxPyEndAllowThreads(__tstate);
47710 if (PyErr_Occurred()) SWIG_fail;
47711 }
47712 resultobj = SWIG_From_int(static_cast< int >(result));
47713 return resultobj;
47714 fail:
47715 return NULL;
47716 }
47717
47718
47719 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47720 PyObject *resultobj = 0;
47721 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47722 int result;
47723 void *argp1 = 0 ;
47724 int res1 = 0 ;
47725 PyObject *swig_obj[1] ;
47726
47727 if (!args) SWIG_fail;
47728 swig_obj[0] = args;
47729 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47730 if (!SWIG_IsOK(res1)) {
47731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47732 }
47733 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47734 {
47735 PyThreadState* __tstate = wxPyBeginAllowThreads();
47736 result = (int)(arg1)->GetVGap();
47737 wxPyEndAllowThreads(__tstate);
47738 if (PyErr_Occurred()) SWIG_fail;
47739 }
47740 resultobj = SWIG_From_int(static_cast< int >(result));
47741 return resultobj;
47742 fail:
47743 return NULL;
47744 }
47745
47746
47747 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47748 PyObject *resultobj = 0;
47749 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47750 int result;
47751 void *argp1 = 0 ;
47752 int res1 = 0 ;
47753 PyObject *swig_obj[1] ;
47754
47755 if (!args) SWIG_fail;
47756 swig_obj[0] = args;
47757 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47758 if (!SWIG_IsOK(res1)) {
47759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47760 }
47761 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47762 {
47763 PyThreadState* __tstate = wxPyBeginAllowThreads();
47764 result = (int)(arg1)->GetHGap();
47765 wxPyEndAllowThreads(__tstate);
47766 if (PyErr_Occurred()) SWIG_fail;
47767 }
47768 resultobj = SWIG_From_int(static_cast< int >(result));
47769 return resultobj;
47770 fail:
47771 return NULL;
47772 }
47773
47774
47775 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47776 PyObject *obj;
47777 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47778 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
47779 return SWIG_Py_Void();
47780 }
47781
47782 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47783 return SWIG_Python_InitShadowInstance(args);
47784 }
47785
47786 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47787 PyObject *resultobj = 0;
47788 int arg1 = (int) 1 ;
47789 int arg2 = (int) 0 ;
47790 int arg3 = (int) 0 ;
47791 int arg4 = (int) 0 ;
47792 wxFlexGridSizer *result = 0 ;
47793 int val1 ;
47794 int ecode1 = 0 ;
47795 int val2 ;
47796 int ecode2 = 0 ;
47797 int val3 ;
47798 int ecode3 = 0 ;
47799 int val4 ;
47800 int ecode4 = 0 ;
47801 PyObject * obj0 = 0 ;
47802 PyObject * obj1 = 0 ;
47803 PyObject * obj2 = 0 ;
47804 PyObject * obj3 = 0 ;
47805 char * kwnames[] = {
47806 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
47807 };
47808
47809 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47810 if (obj0) {
47811 ecode1 = SWIG_AsVal_int(obj0, &val1);
47812 if (!SWIG_IsOK(ecode1)) {
47813 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
47814 }
47815 arg1 = static_cast< int >(val1);
47816 }
47817 if (obj1) {
47818 ecode2 = SWIG_AsVal_int(obj1, &val2);
47819 if (!SWIG_IsOK(ecode2)) {
47820 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
47821 }
47822 arg2 = static_cast< int >(val2);
47823 }
47824 if (obj2) {
47825 ecode3 = SWIG_AsVal_int(obj2, &val3);
47826 if (!SWIG_IsOK(ecode3)) {
47827 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
47828 }
47829 arg3 = static_cast< int >(val3);
47830 }
47831 if (obj3) {
47832 ecode4 = SWIG_AsVal_int(obj3, &val4);
47833 if (!SWIG_IsOK(ecode4)) {
47834 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
47835 }
47836 arg4 = static_cast< int >(val4);
47837 }
47838 {
47839 PyThreadState* __tstate = wxPyBeginAllowThreads();
47840 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
47841 wxPyEndAllowThreads(__tstate);
47842 if (PyErr_Occurred()) SWIG_fail;
47843 }
47844 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
47845 return resultobj;
47846 fail:
47847 return NULL;
47848 }
47849
47850
47851 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47852 PyObject *resultobj = 0;
47853 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47854 size_t arg2 ;
47855 int arg3 = (int) 0 ;
47856 void *argp1 = 0 ;
47857 int res1 = 0 ;
47858 size_t val2 ;
47859 int ecode2 = 0 ;
47860 int val3 ;
47861 int ecode3 = 0 ;
47862 PyObject * obj0 = 0 ;
47863 PyObject * obj1 = 0 ;
47864 PyObject * obj2 = 0 ;
47865 char * kwnames[] = {
47866 (char *) "self",(char *) "idx",(char *) "proportion", NULL
47867 };
47868
47869 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47870 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47871 if (!SWIG_IsOK(res1)) {
47872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47873 }
47874 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47875 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47876 if (!SWIG_IsOK(ecode2)) {
47877 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
47878 }
47879 arg2 = static_cast< size_t >(val2);
47880 if (obj2) {
47881 ecode3 = SWIG_AsVal_int(obj2, &val3);
47882 if (!SWIG_IsOK(ecode3)) {
47883 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
47884 }
47885 arg3 = static_cast< int >(val3);
47886 }
47887 {
47888 PyThreadState* __tstate = wxPyBeginAllowThreads();
47889 (arg1)->AddGrowableRow(arg2,arg3);
47890 wxPyEndAllowThreads(__tstate);
47891 if (PyErr_Occurred()) SWIG_fail;
47892 }
47893 resultobj = SWIG_Py_Void();
47894 return resultobj;
47895 fail:
47896 return NULL;
47897 }
47898
47899
47900 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47901 PyObject *resultobj = 0;
47902 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47903 size_t arg2 ;
47904 void *argp1 = 0 ;
47905 int res1 = 0 ;
47906 size_t val2 ;
47907 int ecode2 = 0 ;
47908 PyObject * obj0 = 0 ;
47909 PyObject * obj1 = 0 ;
47910 char * kwnames[] = {
47911 (char *) "self",(char *) "idx", NULL
47912 };
47913
47914 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
47915 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47916 if (!SWIG_IsOK(res1)) {
47917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47918 }
47919 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47920 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47921 if (!SWIG_IsOK(ecode2)) {
47922 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
47923 }
47924 arg2 = static_cast< size_t >(val2);
47925 {
47926 PyThreadState* __tstate = wxPyBeginAllowThreads();
47927 (arg1)->RemoveGrowableRow(arg2);
47928 wxPyEndAllowThreads(__tstate);
47929 if (PyErr_Occurred()) SWIG_fail;
47930 }
47931 resultobj = SWIG_Py_Void();
47932 return resultobj;
47933 fail:
47934 return NULL;
47935 }
47936
47937
47938 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47939 PyObject *resultobj = 0;
47940 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47941 size_t arg2 ;
47942 int arg3 = (int) 0 ;
47943 void *argp1 = 0 ;
47944 int res1 = 0 ;
47945 size_t val2 ;
47946 int ecode2 = 0 ;
47947 int val3 ;
47948 int ecode3 = 0 ;
47949 PyObject * obj0 = 0 ;
47950 PyObject * obj1 = 0 ;
47951 PyObject * obj2 = 0 ;
47952 char * kwnames[] = {
47953 (char *) "self",(char *) "idx",(char *) "proportion", NULL
47954 };
47955
47956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47957 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47958 if (!SWIG_IsOK(res1)) {
47959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47960 }
47961 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47962 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47963 if (!SWIG_IsOK(ecode2)) {
47964 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
47965 }
47966 arg2 = static_cast< size_t >(val2);
47967 if (obj2) {
47968 ecode3 = SWIG_AsVal_int(obj2, &val3);
47969 if (!SWIG_IsOK(ecode3)) {
47970 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
47971 }
47972 arg3 = static_cast< int >(val3);
47973 }
47974 {
47975 PyThreadState* __tstate = wxPyBeginAllowThreads();
47976 (arg1)->AddGrowableCol(arg2,arg3);
47977 wxPyEndAllowThreads(__tstate);
47978 if (PyErr_Occurred()) SWIG_fail;
47979 }
47980 resultobj = SWIG_Py_Void();
47981 return resultobj;
47982 fail:
47983 return NULL;
47984 }
47985
47986
47987 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47988 PyObject *resultobj = 0;
47989 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47990 size_t arg2 ;
47991 void *argp1 = 0 ;
47992 int res1 = 0 ;
47993 size_t val2 ;
47994 int ecode2 = 0 ;
47995 PyObject * obj0 = 0 ;
47996 PyObject * obj1 = 0 ;
47997 char * kwnames[] = {
47998 (char *) "self",(char *) "idx", NULL
47999 };
48000
48001 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
48002 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48003 if (!SWIG_IsOK(res1)) {
48004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48005 }
48006 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48007 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48008 if (!SWIG_IsOK(ecode2)) {
48009 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
48010 }
48011 arg2 = static_cast< size_t >(val2);
48012 {
48013 PyThreadState* __tstate = wxPyBeginAllowThreads();
48014 (arg1)->RemoveGrowableCol(arg2);
48015 wxPyEndAllowThreads(__tstate);
48016 if (PyErr_Occurred()) SWIG_fail;
48017 }
48018 resultobj = SWIG_Py_Void();
48019 return resultobj;
48020 fail:
48021 return NULL;
48022 }
48023
48024
48025 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48026 PyObject *resultobj = 0;
48027 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48028 int arg2 ;
48029 void *argp1 = 0 ;
48030 int res1 = 0 ;
48031 int val2 ;
48032 int ecode2 = 0 ;
48033 PyObject * obj0 = 0 ;
48034 PyObject * obj1 = 0 ;
48035 char * kwnames[] = {
48036 (char *) "self",(char *) "direction", NULL
48037 };
48038
48039 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
48040 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48041 if (!SWIG_IsOK(res1)) {
48042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48043 }
48044 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48045 ecode2 = SWIG_AsVal_int(obj1, &val2);
48046 if (!SWIG_IsOK(ecode2)) {
48047 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
48048 }
48049 arg2 = static_cast< int >(val2);
48050 {
48051 PyThreadState* __tstate = wxPyBeginAllowThreads();
48052 (arg1)->SetFlexibleDirection(arg2);
48053 wxPyEndAllowThreads(__tstate);
48054 if (PyErr_Occurred()) SWIG_fail;
48055 }
48056 resultobj = SWIG_Py_Void();
48057 return resultobj;
48058 fail:
48059 return NULL;
48060 }
48061
48062
48063 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48064 PyObject *resultobj = 0;
48065 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48066 int result;
48067 void *argp1 = 0 ;
48068 int res1 = 0 ;
48069 PyObject *swig_obj[1] ;
48070
48071 if (!args) SWIG_fail;
48072 swig_obj[0] = args;
48073 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48074 if (!SWIG_IsOK(res1)) {
48075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48076 }
48077 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48078 {
48079 PyThreadState* __tstate = wxPyBeginAllowThreads();
48080 result = (int)(arg1)->GetFlexibleDirection();
48081 wxPyEndAllowThreads(__tstate);
48082 if (PyErr_Occurred()) SWIG_fail;
48083 }
48084 resultobj = SWIG_From_int(static_cast< int >(result));
48085 return resultobj;
48086 fail:
48087 return NULL;
48088 }
48089
48090
48091 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48092 PyObject *resultobj = 0;
48093 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48094 wxFlexSizerGrowMode arg2 ;
48095 void *argp1 = 0 ;
48096 int res1 = 0 ;
48097 int val2 ;
48098 int ecode2 = 0 ;
48099 PyObject * obj0 = 0 ;
48100 PyObject * obj1 = 0 ;
48101 char * kwnames[] = {
48102 (char *) "self",(char *) "mode", NULL
48103 };
48104
48105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
48106 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48107 if (!SWIG_IsOK(res1)) {
48108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48109 }
48110 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48111 ecode2 = SWIG_AsVal_int(obj1, &val2);
48112 if (!SWIG_IsOK(ecode2)) {
48113 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
48114 }
48115 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
48116 {
48117 PyThreadState* __tstate = wxPyBeginAllowThreads();
48118 (arg1)->SetNonFlexibleGrowMode(arg2);
48119 wxPyEndAllowThreads(__tstate);
48120 if (PyErr_Occurred()) SWIG_fail;
48121 }
48122 resultobj = SWIG_Py_Void();
48123 return resultobj;
48124 fail:
48125 return NULL;
48126 }
48127
48128
48129 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48130 PyObject *resultobj = 0;
48131 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48132 wxFlexSizerGrowMode result;
48133 void *argp1 = 0 ;
48134 int res1 = 0 ;
48135 PyObject *swig_obj[1] ;
48136
48137 if (!args) SWIG_fail;
48138 swig_obj[0] = args;
48139 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48140 if (!SWIG_IsOK(res1)) {
48141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48142 }
48143 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48144 {
48145 PyThreadState* __tstate = wxPyBeginAllowThreads();
48146 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
48147 wxPyEndAllowThreads(__tstate);
48148 if (PyErr_Occurred()) SWIG_fail;
48149 }
48150 resultobj = SWIG_From_int(static_cast< int >(result));
48151 return resultobj;
48152 fail:
48153 return NULL;
48154 }
48155
48156
48157 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48158 PyObject *resultobj = 0;
48159 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48160 wxArrayInt *result = 0 ;
48161 void *argp1 = 0 ;
48162 int res1 = 0 ;
48163 PyObject *swig_obj[1] ;
48164
48165 if (!args) SWIG_fail;
48166 swig_obj[0] = args;
48167 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48168 if (!SWIG_IsOK(res1)) {
48169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48170 }
48171 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48172 {
48173 PyThreadState* __tstate = wxPyBeginAllowThreads();
48174 {
48175 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
48176 result = (wxArrayInt *) &_result_ref;
48177 }
48178 wxPyEndAllowThreads(__tstate);
48179 if (PyErr_Occurred()) SWIG_fail;
48180 }
48181 {
48182 resultobj = PyList_New(0);
48183 size_t idx;
48184 for (idx = 0; idx < result->GetCount(); idx += 1) {
48185 PyObject* val = PyInt_FromLong( result->Item(idx) );
48186 PyList_Append(resultobj, val);
48187 Py_DECREF(val);
48188 }
48189 }
48190 return resultobj;
48191 fail:
48192 return NULL;
48193 }
48194
48195
48196 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48197 PyObject *resultobj = 0;
48198 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48199 wxArrayInt *result = 0 ;
48200 void *argp1 = 0 ;
48201 int res1 = 0 ;
48202 PyObject *swig_obj[1] ;
48203
48204 if (!args) SWIG_fail;
48205 swig_obj[0] = args;
48206 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48207 if (!SWIG_IsOK(res1)) {
48208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48209 }
48210 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48211 {
48212 PyThreadState* __tstate = wxPyBeginAllowThreads();
48213 {
48214 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
48215 result = (wxArrayInt *) &_result_ref;
48216 }
48217 wxPyEndAllowThreads(__tstate);
48218 if (PyErr_Occurred()) SWIG_fail;
48219 }
48220 {
48221 resultobj = PyList_New(0);
48222 size_t idx;
48223 for (idx = 0; idx < result->GetCount(); idx += 1) {
48224 PyObject* val = PyInt_FromLong( result->Item(idx) );
48225 PyList_Append(resultobj, val);
48226 Py_DECREF(val);
48227 }
48228 }
48229 return resultobj;
48230 fail:
48231 return NULL;
48232 }
48233
48234
48235 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48236 PyObject *obj;
48237 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48238 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
48239 return SWIG_Py_Void();
48240 }
48241
48242 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48243 return SWIG_Python_InitShadowInstance(args);
48244 }
48245
48246 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48247 PyObject *resultobj = 0;
48248 wxStdDialogButtonSizer *result = 0 ;
48249
48250 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
48251 {
48252 PyThreadState* __tstate = wxPyBeginAllowThreads();
48253 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
48254 wxPyEndAllowThreads(__tstate);
48255 if (PyErr_Occurred()) SWIG_fail;
48256 }
48257 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
48258 return resultobj;
48259 fail:
48260 return NULL;
48261 }
48262
48263
48264 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48265 PyObject *resultobj = 0;
48266 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48267 wxButton *arg2 = (wxButton *) 0 ;
48268 void *argp1 = 0 ;
48269 int res1 = 0 ;
48270 void *argp2 = 0 ;
48271 int res2 = 0 ;
48272 PyObject * obj0 = 0 ;
48273 PyObject * obj1 = 0 ;
48274 char * kwnames[] = {
48275 (char *) "self",(char *) "button", NULL
48276 };
48277
48278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
48279 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48280 if (!SWIG_IsOK(res1)) {
48281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48282 }
48283 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48284 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48285 if (!SWIG_IsOK(res2)) {
48286 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
48287 }
48288 arg2 = reinterpret_cast< wxButton * >(argp2);
48289 {
48290 PyThreadState* __tstate = wxPyBeginAllowThreads();
48291 (arg1)->AddButton(arg2);
48292 wxPyEndAllowThreads(__tstate);
48293 if (PyErr_Occurred()) SWIG_fail;
48294 }
48295 resultobj = SWIG_Py_Void();
48296 return resultobj;
48297 fail:
48298 return NULL;
48299 }
48300
48301
48302 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48303 PyObject *resultobj = 0;
48304 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48305 void *argp1 = 0 ;
48306 int res1 = 0 ;
48307 PyObject *swig_obj[1] ;
48308
48309 if (!args) SWIG_fail;
48310 swig_obj[0] = args;
48311 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48312 if (!SWIG_IsOK(res1)) {
48313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48314 }
48315 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48316 {
48317 PyThreadState* __tstate = wxPyBeginAllowThreads();
48318 (arg1)->Realize();
48319 wxPyEndAllowThreads(__tstate);
48320 if (PyErr_Occurred()) SWIG_fail;
48321 }
48322 resultobj = SWIG_Py_Void();
48323 return resultobj;
48324 fail:
48325 return NULL;
48326 }
48327
48328
48329 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48330 PyObject *resultobj = 0;
48331 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48332 wxButton *arg2 = (wxButton *) 0 ;
48333 void *argp1 = 0 ;
48334 int res1 = 0 ;
48335 void *argp2 = 0 ;
48336 int res2 = 0 ;
48337 PyObject * obj0 = 0 ;
48338 PyObject * obj1 = 0 ;
48339 char * kwnames[] = {
48340 (char *) "self",(char *) "button", NULL
48341 };
48342
48343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48344 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48345 if (!SWIG_IsOK(res1)) {
48346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48347 }
48348 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48349 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48350 if (!SWIG_IsOK(res2)) {
48351 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48352 }
48353 arg2 = reinterpret_cast< wxButton * >(argp2);
48354 {
48355 PyThreadState* __tstate = wxPyBeginAllowThreads();
48356 (arg1)->SetAffirmativeButton(arg2);
48357 wxPyEndAllowThreads(__tstate);
48358 if (PyErr_Occurred()) SWIG_fail;
48359 }
48360 resultobj = SWIG_Py_Void();
48361 return resultobj;
48362 fail:
48363 return NULL;
48364 }
48365
48366
48367 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48368 PyObject *resultobj = 0;
48369 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48370 wxButton *arg2 = (wxButton *) 0 ;
48371 void *argp1 = 0 ;
48372 int res1 = 0 ;
48373 void *argp2 = 0 ;
48374 int res2 = 0 ;
48375 PyObject * obj0 = 0 ;
48376 PyObject * obj1 = 0 ;
48377 char * kwnames[] = {
48378 (char *) "self",(char *) "button", NULL
48379 };
48380
48381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48382 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48383 if (!SWIG_IsOK(res1)) {
48384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48385 }
48386 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48387 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48388 if (!SWIG_IsOK(res2)) {
48389 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48390 }
48391 arg2 = reinterpret_cast< wxButton * >(argp2);
48392 {
48393 PyThreadState* __tstate = wxPyBeginAllowThreads();
48394 (arg1)->SetNegativeButton(arg2);
48395 wxPyEndAllowThreads(__tstate);
48396 if (PyErr_Occurred()) SWIG_fail;
48397 }
48398 resultobj = SWIG_Py_Void();
48399 return resultobj;
48400 fail:
48401 return NULL;
48402 }
48403
48404
48405 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48406 PyObject *resultobj = 0;
48407 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48408 wxButton *arg2 = (wxButton *) 0 ;
48409 void *argp1 = 0 ;
48410 int res1 = 0 ;
48411 void *argp2 = 0 ;
48412 int res2 = 0 ;
48413 PyObject * obj0 = 0 ;
48414 PyObject * obj1 = 0 ;
48415 char * kwnames[] = {
48416 (char *) "self",(char *) "button", NULL
48417 };
48418
48419 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
48420 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48421 if (!SWIG_IsOK(res1)) {
48422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48423 }
48424 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48425 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48426 if (!SWIG_IsOK(res2)) {
48427 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
48428 }
48429 arg2 = reinterpret_cast< wxButton * >(argp2);
48430 {
48431 PyThreadState* __tstate = wxPyBeginAllowThreads();
48432 (arg1)->SetCancelButton(arg2);
48433 wxPyEndAllowThreads(__tstate);
48434 if (PyErr_Occurred()) SWIG_fail;
48435 }
48436 resultobj = SWIG_Py_Void();
48437 return resultobj;
48438 fail:
48439 return NULL;
48440 }
48441
48442
48443 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48444 PyObject *resultobj = 0;
48445 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48446 wxButton *result = 0 ;
48447 void *argp1 = 0 ;
48448 int res1 = 0 ;
48449 PyObject *swig_obj[1] ;
48450
48451 if (!args) SWIG_fail;
48452 swig_obj[0] = args;
48453 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48454 if (!SWIG_IsOK(res1)) {
48455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48456 }
48457 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48458 {
48459 PyThreadState* __tstate = wxPyBeginAllowThreads();
48460 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
48461 wxPyEndAllowThreads(__tstate);
48462 if (PyErr_Occurred()) SWIG_fail;
48463 }
48464 {
48465 resultobj = wxPyMake_wxObject(result, (bool)0);
48466 }
48467 return resultobj;
48468 fail:
48469 return NULL;
48470 }
48471
48472
48473 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48474 PyObject *resultobj = 0;
48475 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48476 wxButton *result = 0 ;
48477 void *argp1 = 0 ;
48478 int res1 = 0 ;
48479 PyObject *swig_obj[1] ;
48480
48481 if (!args) SWIG_fail;
48482 swig_obj[0] = args;
48483 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48484 if (!SWIG_IsOK(res1)) {
48485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48486 }
48487 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48488 {
48489 PyThreadState* __tstate = wxPyBeginAllowThreads();
48490 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
48491 wxPyEndAllowThreads(__tstate);
48492 if (PyErr_Occurred()) SWIG_fail;
48493 }
48494 {
48495 resultobj = wxPyMake_wxObject(result, (bool)0);
48496 }
48497 return resultobj;
48498 fail:
48499 return NULL;
48500 }
48501
48502
48503 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48504 PyObject *resultobj = 0;
48505 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48506 wxButton *result = 0 ;
48507 void *argp1 = 0 ;
48508 int res1 = 0 ;
48509 PyObject *swig_obj[1] ;
48510
48511 if (!args) SWIG_fail;
48512 swig_obj[0] = args;
48513 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48514 if (!SWIG_IsOK(res1)) {
48515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48516 }
48517 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48518 {
48519 PyThreadState* __tstate = wxPyBeginAllowThreads();
48520 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
48521 wxPyEndAllowThreads(__tstate);
48522 if (PyErr_Occurred()) SWIG_fail;
48523 }
48524 {
48525 resultobj = wxPyMake_wxObject(result, (bool)0);
48526 }
48527 return resultobj;
48528 fail:
48529 return NULL;
48530 }
48531
48532
48533 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48534 PyObject *resultobj = 0;
48535 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48536 wxButton *result = 0 ;
48537 void *argp1 = 0 ;
48538 int res1 = 0 ;
48539 PyObject *swig_obj[1] ;
48540
48541 if (!args) SWIG_fail;
48542 swig_obj[0] = args;
48543 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48544 if (!SWIG_IsOK(res1)) {
48545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48546 }
48547 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48548 {
48549 PyThreadState* __tstate = wxPyBeginAllowThreads();
48550 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
48551 wxPyEndAllowThreads(__tstate);
48552 if (PyErr_Occurred()) SWIG_fail;
48553 }
48554 {
48555 resultobj = wxPyMake_wxObject(result, (bool)0);
48556 }
48557 return resultobj;
48558 fail:
48559 return NULL;
48560 }
48561
48562
48563 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48564 PyObject *resultobj = 0;
48565 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48566 wxButton *result = 0 ;
48567 void *argp1 = 0 ;
48568 int res1 = 0 ;
48569 PyObject *swig_obj[1] ;
48570
48571 if (!args) SWIG_fail;
48572 swig_obj[0] = args;
48573 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48574 if (!SWIG_IsOK(res1)) {
48575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48576 }
48577 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48578 {
48579 PyThreadState* __tstate = wxPyBeginAllowThreads();
48580 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
48581 wxPyEndAllowThreads(__tstate);
48582 if (PyErr_Occurred()) SWIG_fail;
48583 }
48584 {
48585 resultobj = wxPyMake_wxObject(result, (bool)0);
48586 }
48587 return resultobj;
48588 fail:
48589 return NULL;
48590 }
48591
48592
48593 SWIGINTERN PyObject *StdDialogButtonSizer_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_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
48597 return SWIG_Py_Void();
48598 }
48599
48600 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48601 return SWIG_Python_InitShadowInstance(args);
48602 }
48603
48604 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48605 PyObject *resultobj = 0;
48606 int arg1 = (int) 0 ;
48607 int arg2 = (int) 0 ;
48608 wxGBPosition *result = 0 ;
48609 int val1 ;
48610 int ecode1 = 0 ;
48611 int val2 ;
48612 int ecode2 = 0 ;
48613 PyObject * obj0 = 0 ;
48614 PyObject * obj1 = 0 ;
48615 char * kwnames[] = {
48616 (char *) "row",(char *) "col", NULL
48617 };
48618
48619 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
48620 if (obj0) {
48621 ecode1 = SWIG_AsVal_int(obj0, &val1);
48622 if (!SWIG_IsOK(ecode1)) {
48623 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
48624 }
48625 arg1 = static_cast< int >(val1);
48626 }
48627 if (obj1) {
48628 ecode2 = SWIG_AsVal_int(obj1, &val2);
48629 if (!SWIG_IsOK(ecode2)) {
48630 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
48631 }
48632 arg2 = static_cast< int >(val2);
48633 }
48634 {
48635 PyThreadState* __tstate = wxPyBeginAllowThreads();
48636 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
48637 wxPyEndAllowThreads(__tstate);
48638 if (PyErr_Occurred()) SWIG_fail;
48639 }
48640 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
48641 return resultobj;
48642 fail:
48643 return NULL;
48644 }
48645
48646
48647 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48648 PyObject *resultobj = 0;
48649 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48650 void *argp1 = 0 ;
48651 int res1 = 0 ;
48652 PyObject *swig_obj[1] ;
48653
48654 if (!args) SWIG_fail;
48655 swig_obj[0] = args;
48656 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
48657 if (!SWIG_IsOK(res1)) {
48658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48659 }
48660 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48661 {
48662 PyThreadState* __tstate = wxPyBeginAllowThreads();
48663 delete arg1;
48664
48665 wxPyEndAllowThreads(__tstate);
48666 if (PyErr_Occurred()) SWIG_fail;
48667 }
48668 resultobj = SWIG_Py_Void();
48669 return resultobj;
48670 fail:
48671 return NULL;
48672 }
48673
48674
48675 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48676 PyObject *resultobj = 0;
48677 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48678 int result;
48679 void *argp1 = 0 ;
48680 int res1 = 0 ;
48681 PyObject *swig_obj[1] ;
48682
48683 if (!args) SWIG_fail;
48684 swig_obj[0] = args;
48685 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48686 if (!SWIG_IsOK(res1)) {
48687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
48688 }
48689 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48690 {
48691 PyThreadState* __tstate = wxPyBeginAllowThreads();
48692 result = (int)((wxGBPosition const *)arg1)->GetRow();
48693 wxPyEndAllowThreads(__tstate);
48694 if (PyErr_Occurred()) SWIG_fail;
48695 }
48696 resultobj = SWIG_From_int(static_cast< int >(result));
48697 return resultobj;
48698 fail:
48699 return NULL;
48700 }
48701
48702
48703 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48704 PyObject *resultobj = 0;
48705 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48706 int result;
48707 void *argp1 = 0 ;
48708 int res1 = 0 ;
48709 PyObject *swig_obj[1] ;
48710
48711 if (!args) SWIG_fail;
48712 swig_obj[0] = args;
48713 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48714 if (!SWIG_IsOK(res1)) {
48715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
48716 }
48717 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48718 {
48719 PyThreadState* __tstate = wxPyBeginAllowThreads();
48720 result = (int)((wxGBPosition const *)arg1)->GetCol();
48721 wxPyEndAllowThreads(__tstate);
48722 if (PyErr_Occurred()) SWIG_fail;
48723 }
48724 resultobj = SWIG_From_int(static_cast< int >(result));
48725 return resultobj;
48726 fail:
48727 return NULL;
48728 }
48729
48730
48731 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48732 PyObject *resultobj = 0;
48733 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48734 int arg2 ;
48735 void *argp1 = 0 ;
48736 int res1 = 0 ;
48737 int val2 ;
48738 int ecode2 = 0 ;
48739 PyObject * obj0 = 0 ;
48740 PyObject * obj1 = 0 ;
48741 char * kwnames[] = {
48742 (char *) "self",(char *) "row", NULL
48743 };
48744
48745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
48746 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48747 if (!SWIG_IsOK(res1)) {
48748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48749 }
48750 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48751 ecode2 = SWIG_AsVal_int(obj1, &val2);
48752 if (!SWIG_IsOK(ecode2)) {
48753 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
48754 }
48755 arg2 = static_cast< int >(val2);
48756 {
48757 PyThreadState* __tstate = wxPyBeginAllowThreads();
48758 (arg1)->SetRow(arg2);
48759 wxPyEndAllowThreads(__tstate);
48760 if (PyErr_Occurred()) SWIG_fail;
48761 }
48762 resultobj = SWIG_Py_Void();
48763 return resultobj;
48764 fail:
48765 return NULL;
48766 }
48767
48768
48769 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48770 PyObject *resultobj = 0;
48771 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48772 int arg2 ;
48773 void *argp1 = 0 ;
48774 int res1 = 0 ;
48775 int val2 ;
48776 int ecode2 = 0 ;
48777 PyObject * obj0 = 0 ;
48778 PyObject * obj1 = 0 ;
48779 char * kwnames[] = {
48780 (char *) "self",(char *) "col", NULL
48781 };
48782
48783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
48784 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48785 if (!SWIG_IsOK(res1)) {
48786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48787 }
48788 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48789 ecode2 = SWIG_AsVal_int(obj1, &val2);
48790 if (!SWIG_IsOK(ecode2)) {
48791 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
48792 }
48793 arg2 = static_cast< int >(val2);
48794 {
48795 PyThreadState* __tstate = wxPyBeginAllowThreads();
48796 (arg1)->SetCol(arg2);
48797 wxPyEndAllowThreads(__tstate);
48798 if (PyErr_Occurred()) SWIG_fail;
48799 }
48800 resultobj = SWIG_Py_Void();
48801 return resultobj;
48802 fail:
48803 return NULL;
48804 }
48805
48806
48807 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48808 PyObject *resultobj = 0;
48809 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48810 PyObject *arg2 = (PyObject *) 0 ;
48811 bool result;
48812 void *argp1 = 0 ;
48813 int res1 = 0 ;
48814 PyObject * obj0 = 0 ;
48815 PyObject * obj1 = 0 ;
48816 char * kwnames[] = {
48817 (char *) "self",(char *) "other", NULL
48818 };
48819
48820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
48821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48822 if (!SWIG_IsOK(res1)) {
48823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48824 }
48825 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48826 arg2 = obj1;
48827 {
48828 result = (bool)wxGBPosition___eq__(arg1,arg2);
48829 if (PyErr_Occurred()) SWIG_fail;
48830 }
48831 {
48832 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48833 }
48834 return resultobj;
48835 fail:
48836 return NULL;
48837 }
48838
48839
48840 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48841 PyObject *resultobj = 0;
48842 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48843 PyObject *arg2 = (PyObject *) 0 ;
48844 bool result;
48845 void *argp1 = 0 ;
48846 int res1 = 0 ;
48847 PyObject * obj0 = 0 ;
48848 PyObject * obj1 = 0 ;
48849 char * kwnames[] = {
48850 (char *) "self",(char *) "other", NULL
48851 };
48852
48853 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
48854 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48855 if (!SWIG_IsOK(res1)) {
48856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48857 }
48858 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48859 arg2 = obj1;
48860 {
48861 result = (bool)wxGBPosition___ne__(arg1,arg2);
48862 if (PyErr_Occurred()) SWIG_fail;
48863 }
48864 {
48865 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48866 }
48867 return resultobj;
48868 fail:
48869 return NULL;
48870 }
48871
48872
48873 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48874 PyObject *resultobj = 0;
48875 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48876 int arg2 = (int) 0 ;
48877 int arg3 = (int) 0 ;
48878 void *argp1 = 0 ;
48879 int res1 = 0 ;
48880 int val2 ;
48881 int ecode2 = 0 ;
48882 int val3 ;
48883 int ecode3 = 0 ;
48884 PyObject * obj0 = 0 ;
48885 PyObject * obj1 = 0 ;
48886 PyObject * obj2 = 0 ;
48887 char * kwnames[] = {
48888 (char *) "self",(char *) "row",(char *) "col", NULL
48889 };
48890
48891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48892 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48893 if (!SWIG_IsOK(res1)) {
48894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48895 }
48896 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48897 if (obj1) {
48898 ecode2 = SWIG_AsVal_int(obj1, &val2);
48899 if (!SWIG_IsOK(ecode2)) {
48900 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
48901 }
48902 arg2 = static_cast< int >(val2);
48903 }
48904 if (obj2) {
48905 ecode3 = SWIG_AsVal_int(obj2, &val3);
48906 if (!SWIG_IsOK(ecode3)) {
48907 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
48908 }
48909 arg3 = static_cast< int >(val3);
48910 }
48911 {
48912 PyThreadState* __tstate = wxPyBeginAllowThreads();
48913 wxGBPosition_Set(arg1,arg2,arg3);
48914 wxPyEndAllowThreads(__tstate);
48915 if (PyErr_Occurred()) SWIG_fail;
48916 }
48917 resultobj = SWIG_Py_Void();
48918 return resultobj;
48919 fail:
48920 return NULL;
48921 }
48922
48923
48924 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48925 PyObject *resultobj = 0;
48926 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48927 PyObject *result = 0 ;
48928 void *argp1 = 0 ;
48929 int res1 = 0 ;
48930 PyObject *swig_obj[1] ;
48931
48932 if (!args) SWIG_fail;
48933 swig_obj[0] = args;
48934 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48935 if (!SWIG_IsOK(res1)) {
48936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48937 }
48938 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48939 {
48940 PyThreadState* __tstate = wxPyBeginAllowThreads();
48941 result = (PyObject *)wxGBPosition_Get(arg1);
48942 wxPyEndAllowThreads(__tstate);
48943 if (PyErr_Occurred()) SWIG_fail;
48944 }
48945 resultobj = result;
48946 return resultobj;
48947 fail:
48948 return NULL;
48949 }
48950
48951
48952 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48953 PyObject *obj;
48954 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48955 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
48956 return SWIG_Py_Void();
48957 }
48958
48959 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48960 return SWIG_Python_InitShadowInstance(args);
48961 }
48962
48963 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48964 PyObject *resultobj = 0;
48965 int arg1 = (int) 1 ;
48966 int arg2 = (int) 1 ;
48967 wxGBSpan *result = 0 ;
48968 int val1 ;
48969 int ecode1 = 0 ;
48970 int val2 ;
48971 int ecode2 = 0 ;
48972 PyObject * obj0 = 0 ;
48973 PyObject * obj1 = 0 ;
48974 char * kwnames[] = {
48975 (char *) "rowspan",(char *) "colspan", NULL
48976 };
48977
48978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
48979 if (obj0) {
48980 ecode1 = SWIG_AsVal_int(obj0, &val1);
48981 if (!SWIG_IsOK(ecode1)) {
48982 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
48983 }
48984 arg1 = static_cast< int >(val1);
48985 }
48986 if (obj1) {
48987 ecode2 = SWIG_AsVal_int(obj1, &val2);
48988 if (!SWIG_IsOK(ecode2)) {
48989 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
48990 }
48991 arg2 = static_cast< int >(val2);
48992 }
48993 {
48994 PyThreadState* __tstate = wxPyBeginAllowThreads();
48995 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
48996 wxPyEndAllowThreads(__tstate);
48997 if (PyErr_Occurred()) SWIG_fail;
48998 }
48999 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
49000 return resultobj;
49001 fail:
49002 return NULL;
49003 }
49004
49005
49006 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49007 PyObject *resultobj = 0;
49008 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49009 void *argp1 = 0 ;
49010 int res1 = 0 ;
49011 PyObject *swig_obj[1] ;
49012
49013 if (!args) SWIG_fail;
49014 swig_obj[0] = args;
49015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
49016 if (!SWIG_IsOK(res1)) {
49017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49018 }
49019 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49020 {
49021 PyThreadState* __tstate = wxPyBeginAllowThreads();
49022 delete arg1;
49023
49024 wxPyEndAllowThreads(__tstate);
49025 if (PyErr_Occurred()) SWIG_fail;
49026 }
49027 resultobj = SWIG_Py_Void();
49028 return resultobj;
49029 fail:
49030 return NULL;
49031 }
49032
49033
49034 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49035 PyObject *resultobj = 0;
49036 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49037 int result;
49038 void *argp1 = 0 ;
49039 int res1 = 0 ;
49040 PyObject *swig_obj[1] ;
49041
49042 if (!args) SWIG_fail;
49043 swig_obj[0] = args;
49044 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49045 if (!SWIG_IsOK(res1)) {
49046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
49047 }
49048 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49049 {
49050 PyThreadState* __tstate = wxPyBeginAllowThreads();
49051 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
49052 wxPyEndAllowThreads(__tstate);
49053 if (PyErr_Occurred()) SWIG_fail;
49054 }
49055 resultobj = SWIG_From_int(static_cast< int >(result));
49056 return resultobj;
49057 fail:
49058 return NULL;
49059 }
49060
49061
49062 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49063 PyObject *resultobj = 0;
49064 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49065 int result;
49066 void *argp1 = 0 ;
49067 int res1 = 0 ;
49068 PyObject *swig_obj[1] ;
49069
49070 if (!args) SWIG_fail;
49071 swig_obj[0] = args;
49072 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49073 if (!SWIG_IsOK(res1)) {
49074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
49075 }
49076 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49077 {
49078 PyThreadState* __tstate = wxPyBeginAllowThreads();
49079 result = (int)((wxGBSpan const *)arg1)->GetColspan();
49080 wxPyEndAllowThreads(__tstate);
49081 if (PyErr_Occurred()) SWIG_fail;
49082 }
49083 resultobj = SWIG_From_int(static_cast< int >(result));
49084 return resultobj;
49085 fail:
49086 return NULL;
49087 }
49088
49089
49090 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49091 PyObject *resultobj = 0;
49092 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49093 int arg2 ;
49094 void *argp1 = 0 ;
49095 int res1 = 0 ;
49096 int val2 ;
49097 int ecode2 = 0 ;
49098 PyObject * obj0 = 0 ;
49099 PyObject * obj1 = 0 ;
49100 char * kwnames[] = {
49101 (char *) "self",(char *) "rowspan", NULL
49102 };
49103
49104 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
49105 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49106 if (!SWIG_IsOK(res1)) {
49107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49108 }
49109 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49110 ecode2 = SWIG_AsVal_int(obj1, &val2);
49111 if (!SWIG_IsOK(ecode2)) {
49112 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
49113 }
49114 arg2 = static_cast< int >(val2);
49115 {
49116 PyThreadState* __tstate = wxPyBeginAllowThreads();
49117 (arg1)->SetRowspan(arg2);
49118 wxPyEndAllowThreads(__tstate);
49119 if (PyErr_Occurred()) SWIG_fail;
49120 }
49121 resultobj = SWIG_Py_Void();
49122 return resultobj;
49123 fail:
49124 return NULL;
49125 }
49126
49127
49128 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49129 PyObject *resultobj = 0;
49130 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49131 int arg2 ;
49132 void *argp1 = 0 ;
49133 int res1 = 0 ;
49134 int val2 ;
49135 int ecode2 = 0 ;
49136 PyObject * obj0 = 0 ;
49137 PyObject * obj1 = 0 ;
49138 char * kwnames[] = {
49139 (char *) "self",(char *) "colspan", NULL
49140 };
49141
49142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
49143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49144 if (!SWIG_IsOK(res1)) {
49145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49146 }
49147 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49148 ecode2 = SWIG_AsVal_int(obj1, &val2);
49149 if (!SWIG_IsOK(ecode2)) {
49150 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
49151 }
49152 arg2 = static_cast< int >(val2);
49153 {
49154 PyThreadState* __tstate = wxPyBeginAllowThreads();
49155 (arg1)->SetColspan(arg2);
49156 wxPyEndAllowThreads(__tstate);
49157 if (PyErr_Occurred()) SWIG_fail;
49158 }
49159 resultobj = SWIG_Py_Void();
49160 return resultobj;
49161 fail:
49162 return NULL;
49163 }
49164
49165
49166 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49167 PyObject *resultobj = 0;
49168 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49169 PyObject *arg2 = (PyObject *) 0 ;
49170 bool result;
49171 void *argp1 = 0 ;
49172 int res1 = 0 ;
49173 PyObject * obj0 = 0 ;
49174 PyObject * obj1 = 0 ;
49175 char * kwnames[] = {
49176 (char *) "self",(char *) "other", NULL
49177 };
49178
49179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
49180 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49181 if (!SWIG_IsOK(res1)) {
49182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49183 }
49184 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49185 arg2 = obj1;
49186 {
49187 result = (bool)wxGBSpan___eq__(arg1,arg2);
49188 if (PyErr_Occurred()) SWIG_fail;
49189 }
49190 {
49191 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49192 }
49193 return resultobj;
49194 fail:
49195 return NULL;
49196 }
49197
49198
49199 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49200 PyObject *resultobj = 0;
49201 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49202 PyObject *arg2 = (PyObject *) 0 ;
49203 bool result;
49204 void *argp1 = 0 ;
49205 int res1 = 0 ;
49206 PyObject * obj0 = 0 ;
49207 PyObject * obj1 = 0 ;
49208 char * kwnames[] = {
49209 (char *) "self",(char *) "other", NULL
49210 };
49211
49212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
49213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49214 if (!SWIG_IsOK(res1)) {
49215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49216 }
49217 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49218 arg2 = obj1;
49219 {
49220 result = (bool)wxGBSpan___ne__(arg1,arg2);
49221 if (PyErr_Occurred()) SWIG_fail;
49222 }
49223 {
49224 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49225 }
49226 return resultobj;
49227 fail:
49228 return NULL;
49229 }
49230
49231
49232 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49233 PyObject *resultobj = 0;
49234 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49235 int arg2 = (int) 1 ;
49236 int arg3 = (int) 1 ;
49237 void *argp1 = 0 ;
49238 int res1 = 0 ;
49239 int val2 ;
49240 int ecode2 = 0 ;
49241 int val3 ;
49242 int ecode3 = 0 ;
49243 PyObject * obj0 = 0 ;
49244 PyObject * obj1 = 0 ;
49245 PyObject * obj2 = 0 ;
49246 char * kwnames[] = {
49247 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
49248 };
49249
49250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49251 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49252 if (!SWIG_IsOK(res1)) {
49253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49254 }
49255 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49256 if (obj1) {
49257 ecode2 = SWIG_AsVal_int(obj1, &val2);
49258 if (!SWIG_IsOK(ecode2)) {
49259 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
49260 }
49261 arg2 = static_cast< int >(val2);
49262 }
49263 if (obj2) {
49264 ecode3 = SWIG_AsVal_int(obj2, &val3);
49265 if (!SWIG_IsOK(ecode3)) {
49266 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
49267 }
49268 arg3 = static_cast< int >(val3);
49269 }
49270 {
49271 PyThreadState* __tstate = wxPyBeginAllowThreads();
49272 wxGBSpan_Set(arg1,arg2,arg3);
49273 wxPyEndAllowThreads(__tstate);
49274 if (PyErr_Occurred()) SWIG_fail;
49275 }
49276 resultobj = SWIG_Py_Void();
49277 return resultobj;
49278 fail:
49279 return NULL;
49280 }
49281
49282
49283 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49284 PyObject *resultobj = 0;
49285 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49286 PyObject *result = 0 ;
49287 void *argp1 = 0 ;
49288 int res1 = 0 ;
49289 PyObject *swig_obj[1] ;
49290
49291 if (!args) SWIG_fail;
49292 swig_obj[0] = args;
49293 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49294 if (!SWIG_IsOK(res1)) {
49295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49296 }
49297 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49298 {
49299 PyThreadState* __tstate = wxPyBeginAllowThreads();
49300 result = (PyObject *)wxGBSpan_Get(arg1);
49301 wxPyEndAllowThreads(__tstate);
49302 if (PyErr_Occurred()) SWIG_fail;
49303 }
49304 resultobj = result;
49305 return resultobj;
49306 fail:
49307 return NULL;
49308 }
49309
49310
49311 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49312 PyObject *obj;
49313 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49314 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
49315 return SWIG_Py_Void();
49316 }
49317
49318 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49319 return SWIG_Python_InitShadowInstance(args);
49320 }
49321
49322 SWIGINTERN int DefaultSpan_set(PyObject *) {
49323 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
49324 return 1;
49325 }
49326
49327
49328 SWIGINTERN PyObject *DefaultSpan_get(void) {
49329 PyObject *pyobj = 0;
49330
49331 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
49332 return pyobj;
49333 }
49334
49335
49336 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49337 PyObject *resultobj = 0;
49338 wxGBSizerItem *result = 0 ;
49339
49340 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
49341 {
49342 PyThreadState* __tstate = wxPyBeginAllowThreads();
49343 result = (wxGBSizerItem *)new wxGBSizerItem();
49344 wxPyEndAllowThreads(__tstate);
49345 if (PyErr_Occurred()) SWIG_fail;
49346 }
49347 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
49348 return resultobj;
49349 fail:
49350 return NULL;
49351 }
49352
49353
49354 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49355 PyObject *resultobj = 0;
49356 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49357 void *argp1 = 0 ;
49358 int res1 = 0 ;
49359 PyObject *swig_obj[1] ;
49360
49361 if (!args) SWIG_fail;
49362 swig_obj[0] = args;
49363 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
49364 if (!SWIG_IsOK(res1)) {
49365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49366 }
49367 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49368 {
49369 PyThreadState* __tstate = wxPyBeginAllowThreads();
49370 delete arg1;
49371
49372 wxPyEndAllowThreads(__tstate);
49373 if (PyErr_Occurred()) SWIG_fail;
49374 }
49375 resultobj = SWIG_Py_Void();
49376 return resultobj;
49377 fail:
49378 return NULL;
49379 }
49380
49381
49382 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49383 PyObject *resultobj = 0;
49384 wxWindow *arg1 = (wxWindow *) 0 ;
49385 wxGBPosition *arg2 = 0 ;
49386 wxGBSpan *arg3 = 0 ;
49387 int arg4 ;
49388 int arg5 ;
49389 PyObject *arg6 = (PyObject *) NULL ;
49390 wxGBSizerItem *result = 0 ;
49391 void *argp1 = 0 ;
49392 int res1 = 0 ;
49393 wxGBPosition temp2 ;
49394 wxGBSpan temp3 ;
49395 int val4 ;
49396 int ecode4 = 0 ;
49397 int val5 ;
49398 int ecode5 = 0 ;
49399 PyObject * obj0 = 0 ;
49400 PyObject * obj1 = 0 ;
49401 PyObject * obj2 = 0 ;
49402 PyObject * obj3 = 0 ;
49403 PyObject * obj4 = 0 ;
49404 PyObject * obj5 = 0 ;
49405 char * kwnames[] = {
49406 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49407 };
49408
49409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49410 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
49411 if (!SWIG_IsOK(res1)) {
49412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
49413 }
49414 arg1 = reinterpret_cast< wxWindow * >(argp1);
49415 {
49416 arg2 = &temp2;
49417 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49418 }
49419 {
49420 arg3 = &temp3;
49421 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49422 }
49423 ecode4 = SWIG_AsVal_int(obj3, &val4);
49424 if (!SWIG_IsOK(ecode4)) {
49425 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
49426 }
49427 arg4 = static_cast< int >(val4);
49428 ecode5 = SWIG_AsVal_int(obj4, &val5);
49429 if (!SWIG_IsOK(ecode5)) {
49430 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
49431 }
49432 arg5 = static_cast< int >(val5);
49433 if (obj5) {
49434 arg6 = obj5;
49435 }
49436 {
49437 PyThreadState* __tstate = wxPyBeginAllowThreads();
49438 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
49439 wxPyEndAllowThreads(__tstate);
49440 if (PyErr_Occurred()) SWIG_fail;
49441 }
49442 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49443 return resultobj;
49444 fail:
49445 return NULL;
49446 }
49447
49448
49449 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49450 PyObject *resultobj = 0;
49451 wxSizer *arg1 = (wxSizer *) 0 ;
49452 wxGBPosition *arg2 = 0 ;
49453 wxGBSpan *arg3 = 0 ;
49454 int arg4 ;
49455 int arg5 ;
49456 PyObject *arg6 = (PyObject *) NULL ;
49457 wxGBSizerItem *result = 0 ;
49458 int res1 = 0 ;
49459 wxGBPosition temp2 ;
49460 wxGBSpan temp3 ;
49461 int val4 ;
49462 int ecode4 = 0 ;
49463 int val5 ;
49464 int ecode5 = 0 ;
49465 PyObject * obj0 = 0 ;
49466 PyObject * obj1 = 0 ;
49467 PyObject * obj2 = 0 ;
49468 PyObject * obj3 = 0 ;
49469 PyObject * obj4 = 0 ;
49470 PyObject * obj5 = 0 ;
49471 char * kwnames[] = {
49472 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49473 };
49474
49475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49476 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49477 if (!SWIG_IsOK(res1)) {
49478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
49479 }
49480 {
49481 arg2 = &temp2;
49482 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49483 }
49484 {
49485 arg3 = &temp3;
49486 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49487 }
49488 ecode4 = SWIG_AsVal_int(obj3, &val4);
49489 if (!SWIG_IsOK(ecode4)) {
49490 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
49491 }
49492 arg4 = static_cast< int >(val4);
49493 ecode5 = SWIG_AsVal_int(obj4, &val5);
49494 if (!SWIG_IsOK(ecode5)) {
49495 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
49496 }
49497 arg5 = static_cast< int >(val5);
49498 if (obj5) {
49499 arg6 = obj5;
49500 }
49501 {
49502 PyThreadState* __tstate = wxPyBeginAllowThreads();
49503 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
49504 wxPyEndAllowThreads(__tstate);
49505 if (PyErr_Occurred()) SWIG_fail;
49506 }
49507 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49508 return resultobj;
49509 fail:
49510 return NULL;
49511 }
49512
49513
49514 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49515 PyObject *resultobj = 0;
49516 int arg1 ;
49517 int arg2 ;
49518 wxGBPosition *arg3 = 0 ;
49519 wxGBSpan *arg4 = 0 ;
49520 int arg5 ;
49521 int arg6 ;
49522 PyObject *arg7 = (PyObject *) NULL ;
49523 wxGBSizerItem *result = 0 ;
49524 int val1 ;
49525 int ecode1 = 0 ;
49526 int val2 ;
49527 int ecode2 = 0 ;
49528 wxGBPosition temp3 ;
49529 wxGBSpan temp4 ;
49530 int val5 ;
49531 int ecode5 = 0 ;
49532 int val6 ;
49533 int ecode6 = 0 ;
49534 PyObject * obj0 = 0 ;
49535 PyObject * obj1 = 0 ;
49536 PyObject * obj2 = 0 ;
49537 PyObject * obj3 = 0 ;
49538 PyObject * obj4 = 0 ;
49539 PyObject * obj5 = 0 ;
49540 PyObject * obj6 = 0 ;
49541 char * kwnames[] = {
49542 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49543 };
49544
49545 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
49546 ecode1 = SWIG_AsVal_int(obj0, &val1);
49547 if (!SWIG_IsOK(ecode1)) {
49548 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
49549 }
49550 arg1 = static_cast< int >(val1);
49551 ecode2 = SWIG_AsVal_int(obj1, &val2);
49552 if (!SWIG_IsOK(ecode2)) {
49553 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
49554 }
49555 arg2 = static_cast< int >(val2);
49556 {
49557 arg3 = &temp3;
49558 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
49559 }
49560 {
49561 arg4 = &temp4;
49562 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
49563 }
49564 ecode5 = SWIG_AsVal_int(obj4, &val5);
49565 if (!SWIG_IsOK(ecode5)) {
49566 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
49567 }
49568 arg5 = static_cast< int >(val5);
49569 ecode6 = SWIG_AsVal_int(obj5, &val6);
49570 if (!SWIG_IsOK(ecode6)) {
49571 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
49572 }
49573 arg6 = static_cast< int >(val6);
49574 if (obj6) {
49575 arg7 = obj6;
49576 }
49577 {
49578 PyThreadState* __tstate = wxPyBeginAllowThreads();
49579 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
49580 wxPyEndAllowThreads(__tstate);
49581 if (PyErr_Occurred()) SWIG_fail;
49582 }
49583 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49584 return resultobj;
49585 fail:
49586 return NULL;
49587 }
49588
49589
49590 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49591 PyObject *resultobj = 0;
49592 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49593 wxGBPosition result;
49594 void *argp1 = 0 ;
49595 int res1 = 0 ;
49596 PyObject *swig_obj[1] ;
49597
49598 if (!args) SWIG_fail;
49599 swig_obj[0] = args;
49600 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49601 if (!SWIG_IsOK(res1)) {
49602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49603 }
49604 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49605 {
49606 PyThreadState* __tstate = wxPyBeginAllowThreads();
49607 result = ((wxGBSizerItem const *)arg1)->GetPos();
49608 wxPyEndAllowThreads(__tstate);
49609 if (PyErr_Occurred()) SWIG_fail;
49610 }
49611 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
49612 return resultobj;
49613 fail:
49614 return NULL;
49615 }
49616
49617
49618 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49619 PyObject *resultobj = 0;
49620 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49621 wxGBSpan result;
49622 void *argp1 = 0 ;
49623 int res1 = 0 ;
49624 PyObject *swig_obj[1] ;
49625
49626 if (!args) SWIG_fail;
49627 swig_obj[0] = args;
49628 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49629 if (!SWIG_IsOK(res1)) {
49630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49631 }
49632 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49633 {
49634 PyThreadState* __tstate = wxPyBeginAllowThreads();
49635 result = ((wxGBSizerItem const *)arg1)->GetSpan();
49636 wxPyEndAllowThreads(__tstate);
49637 if (PyErr_Occurred()) SWIG_fail;
49638 }
49639 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
49640 return resultobj;
49641 fail:
49642 return NULL;
49643 }
49644
49645
49646 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49647 PyObject *resultobj = 0;
49648 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49649 wxGBPosition *arg2 = 0 ;
49650 bool result;
49651 void *argp1 = 0 ;
49652 int res1 = 0 ;
49653 wxGBPosition temp2 ;
49654 PyObject * obj0 = 0 ;
49655 PyObject * obj1 = 0 ;
49656 char * kwnames[] = {
49657 (char *) "self",(char *) "pos", NULL
49658 };
49659
49660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
49661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49662 if (!SWIG_IsOK(res1)) {
49663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49664 }
49665 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49666 {
49667 arg2 = &temp2;
49668 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49669 }
49670 {
49671 PyThreadState* __tstate = wxPyBeginAllowThreads();
49672 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
49673 wxPyEndAllowThreads(__tstate);
49674 if (PyErr_Occurred()) SWIG_fail;
49675 }
49676 {
49677 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49678 }
49679 return resultobj;
49680 fail:
49681 return NULL;
49682 }
49683
49684
49685 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49686 PyObject *resultobj = 0;
49687 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49688 wxGBSpan *arg2 = 0 ;
49689 bool result;
49690 void *argp1 = 0 ;
49691 int res1 = 0 ;
49692 wxGBSpan temp2 ;
49693 PyObject * obj0 = 0 ;
49694 PyObject * obj1 = 0 ;
49695 char * kwnames[] = {
49696 (char *) "self",(char *) "span", NULL
49697 };
49698
49699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
49700 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49701 if (!SWIG_IsOK(res1)) {
49702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49703 }
49704 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49705 {
49706 arg2 = &temp2;
49707 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
49708 }
49709 {
49710 PyThreadState* __tstate = wxPyBeginAllowThreads();
49711 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
49712 wxPyEndAllowThreads(__tstate);
49713 if (PyErr_Occurred()) SWIG_fail;
49714 }
49715 {
49716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49717 }
49718 return resultobj;
49719 fail:
49720 return NULL;
49721 }
49722
49723
49724 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49725 PyObject *resultobj = 0;
49726 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49727 wxGBSizerItem *arg2 = 0 ;
49728 bool result;
49729 void *argp1 = 0 ;
49730 int res1 = 0 ;
49731 void *argp2 = 0 ;
49732 int res2 = 0 ;
49733 PyObject * obj0 = 0 ;
49734 PyObject * obj1 = 0 ;
49735 char * kwnames[] = {
49736 (char *) "self",(char *) "other", NULL
49737 };
49738
49739 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
49740 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49741 if (!SWIG_IsOK(res1)) {
49742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49743 }
49744 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49745 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
49746 if (!SWIG_IsOK(res2)) {
49747 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
49748 }
49749 if (!argp2) {
49750 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
49751 }
49752 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
49753 {
49754 PyThreadState* __tstate = wxPyBeginAllowThreads();
49755 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
49756 wxPyEndAllowThreads(__tstate);
49757 if (PyErr_Occurred()) SWIG_fail;
49758 }
49759 {
49760 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49761 }
49762 return resultobj;
49763 fail:
49764 return NULL;
49765 }
49766
49767
49768 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49769 PyObject *resultobj = 0;
49770 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49771 wxGBPosition *arg2 = 0 ;
49772 wxGBSpan *arg3 = 0 ;
49773 bool result;
49774 void *argp1 = 0 ;
49775 int res1 = 0 ;
49776 wxGBPosition temp2 ;
49777 wxGBSpan temp3 ;
49778 PyObject * obj0 = 0 ;
49779 PyObject * obj1 = 0 ;
49780 PyObject * obj2 = 0 ;
49781 char * kwnames[] = {
49782 (char *) "self",(char *) "pos",(char *) "span", NULL
49783 };
49784
49785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49786 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49787 if (!SWIG_IsOK(res1)) {
49788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49789 }
49790 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49791 {
49792 arg2 = &temp2;
49793 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49794 }
49795 {
49796 arg3 = &temp3;
49797 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49798 }
49799 {
49800 PyThreadState* __tstate = wxPyBeginAllowThreads();
49801 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
49802 wxPyEndAllowThreads(__tstate);
49803 if (PyErr_Occurred()) SWIG_fail;
49804 }
49805 {
49806 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49807 }
49808 return resultobj;
49809 fail:
49810 return NULL;
49811 }
49812
49813
49814 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49815 PyObject *resultobj = 0;
49816 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49817 wxGBPosition result;
49818 void *argp1 = 0 ;
49819 int res1 = 0 ;
49820 PyObject *swig_obj[1] ;
49821
49822 if (!args) SWIG_fail;
49823 swig_obj[0] = args;
49824 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49825 if (!SWIG_IsOK(res1)) {
49826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49827 }
49828 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49829 {
49830 PyThreadState* __tstate = wxPyBeginAllowThreads();
49831 result = wxGBSizerItem_GetEndPos(arg1);
49832 wxPyEndAllowThreads(__tstate);
49833 if (PyErr_Occurred()) SWIG_fail;
49834 }
49835 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
49836 return resultobj;
49837 fail:
49838 return NULL;
49839 }
49840
49841
49842 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49843 PyObject *resultobj = 0;
49844 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49845 wxGridBagSizer *result = 0 ;
49846 void *argp1 = 0 ;
49847 int res1 = 0 ;
49848 PyObject *swig_obj[1] ;
49849
49850 if (!args) SWIG_fail;
49851 swig_obj[0] = args;
49852 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49853 if (!SWIG_IsOK(res1)) {
49854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49855 }
49856 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49857 {
49858 PyThreadState* __tstate = wxPyBeginAllowThreads();
49859 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
49860 wxPyEndAllowThreads(__tstate);
49861 if (PyErr_Occurred()) SWIG_fail;
49862 }
49863 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49864 return resultobj;
49865 fail:
49866 return NULL;
49867 }
49868
49869
49870 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49871 PyObject *resultobj = 0;
49872 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49873 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
49874 void *argp1 = 0 ;
49875 int res1 = 0 ;
49876 void *argp2 = 0 ;
49877 int res2 = 0 ;
49878 PyObject * obj0 = 0 ;
49879 PyObject * obj1 = 0 ;
49880 char * kwnames[] = {
49881 (char *) "self",(char *) "sizer", NULL
49882 };
49883
49884 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
49885 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49886 if (!SWIG_IsOK(res1)) {
49887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49888 }
49889 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49890 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49891 if (!SWIG_IsOK(res2)) {
49892 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
49893 }
49894 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
49895 {
49896 PyThreadState* __tstate = wxPyBeginAllowThreads();
49897 (arg1)->SetGBSizer(arg2);
49898 wxPyEndAllowThreads(__tstate);
49899 if (PyErr_Occurred()) SWIG_fail;
49900 }
49901 resultobj = SWIG_Py_Void();
49902 return resultobj;
49903 fail:
49904 return NULL;
49905 }
49906
49907
49908 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49909 PyObject *obj;
49910 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49911 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
49912 return SWIG_Py_Void();
49913 }
49914
49915 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49916 return SWIG_Python_InitShadowInstance(args);
49917 }
49918
49919 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49920 PyObject *resultobj = 0;
49921 int arg1 = (int) 0 ;
49922 int arg2 = (int) 0 ;
49923 wxGridBagSizer *result = 0 ;
49924 int val1 ;
49925 int ecode1 = 0 ;
49926 int val2 ;
49927 int ecode2 = 0 ;
49928 PyObject * obj0 = 0 ;
49929 PyObject * obj1 = 0 ;
49930 char * kwnames[] = {
49931 (char *) "vgap",(char *) "hgap", NULL
49932 };
49933
49934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
49935 if (obj0) {
49936 ecode1 = SWIG_AsVal_int(obj0, &val1);
49937 if (!SWIG_IsOK(ecode1)) {
49938 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
49939 }
49940 arg1 = static_cast< int >(val1);
49941 }
49942 if (obj1) {
49943 ecode2 = SWIG_AsVal_int(obj1, &val2);
49944 if (!SWIG_IsOK(ecode2)) {
49945 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
49946 }
49947 arg2 = static_cast< int >(val2);
49948 }
49949 {
49950 PyThreadState* __tstate = wxPyBeginAllowThreads();
49951 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
49952 wxPyEndAllowThreads(__tstate);
49953 if (PyErr_Occurred()) SWIG_fail;
49954 }
49955 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
49956 return resultobj;
49957 fail:
49958 return NULL;
49959 }
49960
49961
49962 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49963 PyObject *resultobj = 0;
49964 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
49965 PyObject *arg2 = (PyObject *) 0 ;
49966 wxGBPosition *arg3 = 0 ;
49967 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
49968 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
49969 int arg5 = (int) 0 ;
49970 int arg6 = (int) 0 ;
49971 PyObject *arg7 = (PyObject *) NULL ;
49972 wxGBSizerItem *result = 0 ;
49973 void *argp1 = 0 ;
49974 int res1 = 0 ;
49975 wxGBPosition temp3 ;
49976 wxGBSpan temp4 ;
49977 int val5 ;
49978 int ecode5 = 0 ;
49979 int val6 ;
49980 int ecode6 = 0 ;
49981 PyObject * obj0 = 0 ;
49982 PyObject * obj1 = 0 ;
49983 PyObject * obj2 = 0 ;
49984 PyObject * obj3 = 0 ;
49985 PyObject * obj4 = 0 ;
49986 PyObject * obj5 = 0 ;
49987 PyObject * obj6 = 0 ;
49988 char * kwnames[] = {
49989 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49990 };
49991
49992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
49993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49994 if (!SWIG_IsOK(res1)) {
49995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
49996 }
49997 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
49998 arg2 = obj1;
49999 {
50000 arg3 = &temp3;
50001 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
50002 }
50003 if (obj3) {
50004 {
50005 arg4 = &temp4;
50006 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
50007 }
50008 }
50009 if (obj4) {
50010 ecode5 = SWIG_AsVal_int(obj4, &val5);
50011 if (!SWIG_IsOK(ecode5)) {
50012 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
50013 }
50014 arg5 = static_cast< int >(val5);
50015 }
50016 if (obj5) {
50017 ecode6 = SWIG_AsVal_int(obj5, &val6);
50018 if (!SWIG_IsOK(ecode6)) {
50019 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
50020 }
50021 arg6 = static_cast< int >(val6);
50022 }
50023 if (obj6) {
50024 arg7 = obj6;
50025 }
50026 {
50027 PyThreadState* __tstate = wxPyBeginAllowThreads();
50028 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
50029 wxPyEndAllowThreads(__tstate);
50030 if (PyErr_Occurred()) SWIG_fail;
50031 }
50032 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50033 return resultobj;
50034 fail:
50035 return NULL;
50036 }
50037
50038
50039 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50040 PyObject *resultobj = 0;
50041 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50042 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
50043 wxGBSizerItem *result = 0 ;
50044 void *argp1 = 0 ;
50045 int res1 = 0 ;
50046 int res2 = 0 ;
50047 PyObject * obj0 = 0 ;
50048 PyObject * obj1 = 0 ;
50049 char * kwnames[] = {
50050 (char *) "self",(char *) "item", NULL
50051 };
50052
50053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
50054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50055 if (!SWIG_IsOK(res1)) {
50056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50057 }
50058 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50059 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
50060 if (!SWIG_IsOK(res2)) {
50061 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
50062 }
50063 {
50064 PyThreadState* __tstate = wxPyBeginAllowThreads();
50065 result = (wxGBSizerItem *)(arg1)->Add(arg2);
50066 wxPyEndAllowThreads(__tstate);
50067 if (PyErr_Occurred()) SWIG_fail;
50068 }
50069 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50070 return resultobj;
50071 fail:
50072 return NULL;
50073 }
50074
50075
50076 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50077 PyObject *resultobj = 0;
50078 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50079 int arg2 ;
50080 int arg3 ;
50081 wxSize result;
50082 void *argp1 = 0 ;
50083 int res1 = 0 ;
50084 int val2 ;
50085 int ecode2 = 0 ;
50086 int val3 ;
50087 int ecode3 = 0 ;
50088 PyObject * obj0 = 0 ;
50089 PyObject * obj1 = 0 ;
50090 PyObject * obj2 = 0 ;
50091 char * kwnames[] = {
50092 (char *) "self",(char *) "row",(char *) "col", NULL
50093 };
50094
50095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50096 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50097 if (!SWIG_IsOK(res1)) {
50098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
50099 }
50100 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50101 ecode2 = SWIG_AsVal_int(obj1, &val2);
50102 if (!SWIG_IsOK(ecode2)) {
50103 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
50104 }
50105 arg2 = static_cast< int >(val2);
50106 ecode3 = SWIG_AsVal_int(obj2, &val3);
50107 if (!SWIG_IsOK(ecode3)) {
50108 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
50109 }
50110 arg3 = static_cast< int >(val3);
50111 {
50112 PyThreadState* __tstate = wxPyBeginAllowThreads();
50113 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
50114 wxPyEndAllowThreads(__tstate);
50115 if (PyErr_Occurred()) SWIG_fail;
50116 }
50117 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50118 return resultobj;
50119 fail:
50120 return NULL;
50121 }
50122
50123
50124 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50125 PyObject *resultobj = 0;
50126 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50127 wxSize result;
50128 void *argp1 = 0 ;
50129 int res1 = 0 ;
50130 PyObject *swig_obj[1] ;
50131
50132 if (!args) SWIG_fail;
50133 swig_obj[0] = args;
50134 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50135 if (!SWIG_IsOK(res1)) {
50136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
50137 }
50138 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50139 {
50140 PyThreadState* __tstate = wxPyBeginAllowThreads();
50141 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
50142 wxPyEndAllowThreads(__tstate);
50143 if (PyErr_Occurred()) SWIG_fail;
50144 }
50145 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50146 return resultobj;
50147 fail:
50148 return NULL;
50149 }
50150
50151
50152 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50153 PyObject *resultobj = 0;
50154 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50155 wxSize *arg2 = 0 ;
50156 void *argp1 = 0 ;
50157 int res1 = 0 ;
50158 wxSize temp2 ;
50159 PyObject * obj0 = 0 ;
50160 PyObject * obj1 = 0 ;
50161 char * kwnames[] = {
50162 (char *) "self",(char *) "sz", NULL
50163 };
50164
50165 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
50166 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50167 if (!SWIG_IsOK(res1)) {
50168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50169 }
50170 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50171 {
50172 arg2 = &temp2;
50173 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50174 }
50175 {
50176 PyThreadState* __tstate = wxPyBeginAllowThreads();
50177 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
50178 wxPyEndAllowThreads(__tstate);
50179 if (PyErr_Occurred()) SWIG_fail;
50180 }
50181 resultobj = SWIG_Py_Void();
50182 return resultobj;
50183 fail:
50184 return NULL;
50185 }
50186
50187
50188 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50189 PyObject *resultobj = 0;
50190 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50191 wxWindow *arg2 = (wxWindow *) 0 ;
50192 wxGBPosition result;
50193 void *argp1 = 0 ;
50194 int res1 = 0 ;
50195 void *argp2 = 0 ;
50196 int res2 = 0 ;
50197
50198 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50199 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50200 if (!SWIG_IsOK(res1)) {
50201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50202 }
50203 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50204 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50205 if (!SWIG_IsOK(res2)) {
50206 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50207 }
50208 arg2 = reinterpret_cast< wxWindow * >(argp2);
50209 {
50210 PyThreadState* __tstate = wxPyBeginAllowThreads();
50211 result = (arg1)->GetItemPosition(arg2);
50212 wxPyEndAllowThreads(__tstate);
50213 if (PyErr_Occurred()) SWIG_fail;
50214 }
50215 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50216 return resultobj;
50217 fail:
50218 return NULL;
50219 }
50220
50221
50222 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50223 PyObject *resultobj = 0;
50224 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50225 wxSizer *arg2 = (wxSizer *) 0 ;
50226 wxGBPosition result;
50227 void *argp1 = 0 ;
50228 int res1 = 0 ;
50229 void *argp2 = 0 ;
50230 int res2 = 0 ;
50231
50232 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50233 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50234 if (!SWIG_IsOK(res1)) {
50235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50236 }
50237 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50238 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50239 if (!SWIG_IsOK(res2)) {
50240 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50241 }
50242 arg2 = reinterpret_cast< wxSizer * >(argp2);
50243 {
50244 PyThreadState* __tstate = wxPyBeginAllowThreads();
50245 result = (arg1)->GetItemPosition(arg2);
50246 wxPyEndAllowThreads(__tstate);
50247 if (PyErr_Occurred()) SWIG_fail;
50248 }
50249 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50250 return resultobj;
50251 fail:
50252 return NULL;
50253 }
50254
50255
50256 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50257 PyObject *resultobj = 0;
50258 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50259 size_t arg2 ;
50260 wxGBPosition result;
50261 void *argp1 = 0 ;
50262 int res1 = 0 ;
50263 size_t val2 ;
50264 int ecode2 = 0 ;
50265
50266 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50267 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50268 if (!SWIG_IsOK(res1)) {
50269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50270 }
50271 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50272 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50273 if (!SWIG_IsOK(ecode2)) {
50274 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50275 }
50276 arg2 = static_cast< size_t >(val2);
50277 {
50278 PyThreadState* __tstate = wxPyBeginAllowThreads();
50279 result = (arg1)->GetItemPosition(arg2);
50280 wxPyEndAllowThreads(__tstate);
50281 if (PyErr_Occurred()) SWIG_fail;
50282 }
50283 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50284 return resultobj;
50285 fail:
50286 return NULL;
50287 }
50288
50289
50290 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
50291 int argc;
50292 PyObject *argv[3];
50293
50294 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
50295 --argc;
50296 if (argc == 2) {
50297 int _v = 0;
50298 {
50299 void *vptr = 0;
50300 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50301 _v = SWIG_CheckState(res);
50302 }
50303 if (!_v) goto check_1;
50304 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
50305 }
50306 check_1:
50307
50308 if (argc == 2) {
50309 int _v = 0;
50310 {
50311 void *vptr = 0;
50312 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50313 _v = SWIG_CheckState(res);
50314 }
50315 if (!_v) goto check_2;
50316 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
50317 }
50318 check_2:
50319
50320 if (argc == 2) {
50321 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
50322 }
50323
50324 fail:
50325 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
50326 return NULL;
50327 }
50328
50329
50330 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50331 PyObject *resultobj = 0;
50332 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50333 wxWindow *arg2 = (wxWindow *) 0 ;
50334 wxGBPosition *arg3 = 0 ;
50335 bool result;
50336 void *argp1 = 0 ;
50337 int res1 = 0 ;
50338 void *argp2 = 0 ;
50339 int res2 = 0 ;
50340 wxGBPosition temp3 ;
50341
50342 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50343 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50344 if (!SWIG_IsOK(res1)) {
50345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50346 }
50347 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50348 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50349 if (!SWIG_IsOK(res2)) {
50350 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50351 }
50352 arg2 = reinterpret_cast< wxWindow * >(argp2);
50353 {
50354 arg3 = &temp3;
50355 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50356 }
50357 {
50358 PyThreadState* __tstate = wxPyBeginAllowThreads();
50359 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50360 wxPyEndAllowThreads(__tstate);
50361 if (PyErr_Occurred()) SWIG_fail;
50362 }
50363 {
50364 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50365 }
50366 return resultobj;
50367 fail:
50368 return NULL;
50369 }
50370
50371
50372 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50373 PyObject *resultobj = 0;
50374 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50375 wxSizer *arg2 = (wxSizer *) 0 ;
50376 wxGBPosition *arg3 = 0 ;
50377 bool result;
50378 void *argp1 = 0 ;
50379 int res1 = 0 ;
50380 void *argp2 = 0 ;
50381 int res2 = 0 ;
50382 wxGBPosition temp3 ;
50383
50384 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50385 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50386 if (!SWIG_IsOK(res1)) {
50387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50388 }
50389 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50390 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50391 if (!SWIG_IsOK(res2)) {
50392 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50393 }
50394 arg2 = reinterpret_cast< wxSizer * >(argp2);
50395 {
50396 arg3 = &temp3;
50397 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50398 }
50399 {
50400 PyThreadState* __tstate = wxPyBeginAllowThreads();
50401 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50402 wxPyEndAllowThreads(__tstate);
50403 if (PyErr_Occurred()) SWIG_fail;
50404 }
50405 {
50406 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50407 }
50408 return resultobj;
50409 fail:
50410 return NULL;
50411 }
50412
50413
50414 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50415 PyObject *resultobj = 0;
50416 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50417 size_t arg2 ;
50418 wxGBPosition *arg3 = 0 ;
50419 bool result;
50420 void *argp1 = 0 ;
50421 int res1 = 0 ;
50422 size_t val2 ;
50423 int ecode2 = 0 ;
50424 wxGBPosition temp3 ;
50425
50426 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50427 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50428 if (!SWIG_IsOK(res1)) {
50429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50430 }
50431 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50432 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50433 if (!SWIG_IsOK(ecode2)) {
50434 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50435 }
50436 arg2 = static_cast< size_t >(val2);
50437 {
50438 arg3 = &temp3;
50439 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50440 }
50441 {
50442 PyThreadState* __tstate = wxPyBeginAllowThreads();
50443 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50444 wxPyEndAllowThreads(__tstate);
50445 if (PyErr_Occurred()) SWIG_fail;
50446 }
50447 {
50448 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50449 }
50450 return resultobj;
50451 fail:
50452 return NULL;
50453 }
50454
50455
50456 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
50457 int argc;
50458 PyObject *argv[4];
50459
50460 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
50461 --argc;
50462 if (argc == 3) {
50463 int _v = 0;
50464 {
50465 void *vptr = 0;
50466 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50467 _v = SWIG_CheckState(res);
50468 }
50469 if (!_v) goto check_1;
50470 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
50471 }
50472 check_1:
50473
50474 if (argc == 3) {
50475 int _v = 0;
50476 {
50477 void *vptr = 0;
50478 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50479 _v = SWIG_CheckState(res);
50480 }
50481 if (!_v) goto check_2;
50482 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
50483 }
50484 check_2:
50485
50486 if (argc == 3) {
50487 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
50488 }
50489
50490 fail:
50491 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
50492 return NULL;
50493 }
50494
50495
50496 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50497 PyObject *resultobj = 0;
50498 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50499 wxWindow *arg2 = (wxWindow *) 0 ;
50500 wxGBSpan result;
50501 void *argp1 = 0 ;
50502 int res1 = 0 ;
50503 void *argp2 = 0 ;
50504 int res2 = 0 ;
50505
50506 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50508 if (!SWIG_IsOK(res1)) {
50509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50510 }
50511 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50512 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50513 if (!SWIG_IsOK(res2)) {
50514 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
50515 }
50516 arg2 = reinterpret_cast< wxWindow * >(argp2);
50517 {
50518 PyThreadState* __tstate = wxPyBeginAllowThreads();
50519 result = (arg1)->GetItemSpan(arg2);
50520 wxPyEndAllowThreads(__tstate);
50521 if (PyErr_Occurred()) SWIG_fail;
50522 }
50523 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50524 return resultobj;
50525 fail:
50526 return NULL;
50527 }
50528
50529
50530 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50531 PyObject *resultobj = 0;
50532 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50533 wxSizer *arg2 = (wxSizer *) 0 ;
50534 wxGBSpan result;
50535 void *argp1 = 0 ;
50536 int res1 = 0 ;
50537 void *argp2 = 0 ;
50538 int res2 = 0 ;
50539
50540 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50542 if (!SWIG_IsOK(res1)) {
50543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50544 }
50545 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50546 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50547 if (!SWIG_IsOK(res2)) {
50548 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
50549 }
50550 arg2 = reinterpret_cast< wxSizer * >(argp2);
50551 {
50552 PyThreadState* __tstate = wxPyBeginAllowThreads();
50553 result = (arg1)->GetItemSpan(arg2);
50554 wxPyEndAllowThreads(__tstate);
50555 if (PyErr_Occurred()) SWIG_fail;
50556 }
50557 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50558 return resultobj;
50559 fail:
50560 return NULL;
50561 }
50562
50563
50564 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50565 PyObject *resultobj = 0;
50566 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50567 size_t arg2 ;
50568 wxGBSpan result;
50569 void *argp1 = 0 ;
50570 int res1 = 0 ;
50571 size_t val2 ;
50572 int ecode2 = 0 ;
50573
50574 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50576 if (!SWIG_IsOK(res1)) {
50577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50578 }
50579 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50580 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50581 if (!SWIG_IsOK(ecode2)) {
50582 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
50583 }
50584 arg2 = static_cast< size_t >(val2);
50585 {
50586 PyThreadState* __tstate = wxPyBeginAllowThreads();
50587 result = (arg1)->GetItemSpan(arg2);
50588 wxPyEndAllowThreads(__tstate);
50589 if (PyErr_Occurred()) SWIG_fail;
50590 }
50591 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50592 return resultobj;
50593 fail:
50594 return NULL;
50595 }
50596
50597
50598 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
50599 int argc;
50600 PyObject *argv[3];
50601
50602 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
50603 --argc;
50604 if (argc == 2) {
50605 int _v = 0;
50606 {
50607 void *vptr = 0;
50608 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50609 _v = SWIG_CheckState(res);
50610 }
50611 if (!_v) goto check_1;
50612 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
50613 }
50614 check_1:
50615
50616 if (argc == 2) {
50617 int _v = 0;
50618 {
50619 void *vptr = 0;
50620 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50621 _v = SWIG_CheckState(res);
50622 }
50623 if (!_v) goto check_2;
50624 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
50625 }
50626 check_2:
50627
50628 if (argc == 2) {
50629 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
50630 }
50631
50632 fail:
50633 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
50634 return NULL;
50635 }
50636
50637
50638 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50639 PyObject *resultobj = 0;
50640 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50641 wxWindow *arg2 = (wxWindow *) 0 ;
50642 wxGBSpan *arg3 = 0 ;
50643 bool result;
50644 void *argp1 = 0 ;
50645 int res1 = 0 ;
50646 void *argp2 = 0 ;
50647 int res2 = 0 ;
50648 wxGBSpan temp3 ;
50649
50650 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50651 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50652 if (!SWIG_IsOK(res1)) {
50653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50654 }
50655 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50656 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50657 if (!SWIG_IsOK(res2)) {
50658 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
50659 }
50660 arg2 = reinterpret_cast< wxWindow * >(argp2);
50661 {
50662 arg3 = &temp3;
50663 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50664 }
50665 {
50666 PyThreadState* __tstate = wxPyBeginAllowThreads();
50667 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50668 wxPyEndAllowThreads(__tstate);
50669 if (PyErr_Occurred()) SWIG_fail;
50670 }
50671 {
50672 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50673 }
50674 return resultobj;
50675 fail:
50676 return NULL;
50677 }
50678
50679
50680 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50681 PyObject *resultobj = 0;
50682 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50683 wxSizer *arg2 = (wxSizer *) 0 ;
50684 wxGBSpan *arg3 = 0 ;
50685 bool result;
50686 void *argp1 = 0 ;
50687 int res1 = 0 ;
50688 void *argp2 = 0 ;
50689 int res2 = 0 ;
50690 wxGBSpan temp3 ;
50691
50692 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50693 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50694 if (!SWIG_IsOK(res1)) {
50695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50696 }
50697 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50698 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50699 if (!SWIG_IsOK(res2)) {
50700 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
50701 }
50702 arg2 = reinterpret_cast< wxSizer * >(argp2);
50703 {
50704 arg3 = &temp3;
50705 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50706 }
50707 {
50708 PyThreadState* __tstate = wxPyBeginAllowThreads();
50709 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50710 wxPyEndAllowThreads(__tstate);
50711 if (PyErr_Occurred()) SWIG_fail;
50712 }
50713 {
50714 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50715 }
50716 return resultobj;
50717 fail:
50718 return NULL;
50719 }
50720
50721
50722 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50723 PyObject *resultobj = 0;
50724 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50725 size_t arg2 ;
50726 wxGBSpan *arg3 = 0 ;
50727 bool result;
50728 void *argp1 = 0 ;
50729 int res1 = 0 ;
50730 size_t val2 ;
50731 int ecode2 = 0 ;
50732 wxGBSpan temp3 ;
50733
50734 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50735 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50736 if (!SWIG_IsOK(res1)) {
50737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50738 }
50739 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50740 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50741 if (!SWIG_IsOK(ecode2)) {
50742 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
50743 }
50744 arg2 = static_cast< size_t >(val2);
50745 {
50746 arg3 = &temp3;
50747 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50748 }
50749 {
50750 PyThreadState* __tstate = wxPyBeginAllowThreads();
50751 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50752 wxPyEndAllowThreads(__tstate);
50753 if (PyErr_Occurred()) SWIG_fail;
50754 }
50755 {
50756 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50757 }
50758 return resultobj;
50759 fail:
50760 return NULL;
50761 }
50762
50763
50764 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
50765 int argc;
50766 PyObject *argv[4];
50767
50768 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
50769 --argc;
50770 if (argc == 3) {
50771 int _v = 0;
50772 {
50773 void *vptr = 0;
50774 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50775 _v = SWIG_CheckState(res);
50776 }
50777 if (!_v) goto check_1;
50778 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
50779 }
50780 check_1:
50781
50782 if (argc == 3) {
50783 int _v = 0;
50784 {
50785 void *vptr = 0;
50786 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50787 _v = SWIG_CheckState(res);
50788 }
50789 if (!_v) goto check_2;
50790 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
50791 }
50792 check_2:
50793
50794 if (argc == 3) {
50795 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
50796 }
50797
50798 fail:
50799 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
50800 return NULL;
50801 }
50802
50803
50804 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50805 PyObject *resultobj = 0;
50806 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50807 wxWindow *arg2 = (wxWindow *) 0 ;
50808 wxGBSizerItem *result = 0 ;
50809 void *argp1 = 0 ;
50810 int res1 = 0 ;
50811 void *argp2 = 0 ;
50812 int res2 = 0 ;
50813
50814 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50815 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50816 if (!SWIG_IsOK(res1)) {
50817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50818 }
50819 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50820 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50821 if (!SWIG_IsOK(res2)) {
50822 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
50823 }
50824 arg2 = reinterpret_cast< wxWindow * >(argp2);
50825 {
50826 PyThreadState* __tstate = wxPyBeginAllowThreads();
50827 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
50828 wxPyEndAllowThreads(__tstate);
50829 if (PyErr_Occurred()) SWIG_fail;
50830 }
50831 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50832 return resultobj;
50833 fail:
50834 return NULL;
50835 }
50836
50837
50838 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50839 PyObject *resultobj = 0;
50840 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50841 wxSizer *arg2 = (wxSizer *) 0 ;
50842 wxGBSizerItem *result = 0 ;
50843 void *argp1 = 0 ;
50844 int res1 = 0 ;
50845 void *argp2 = 0 ;
50846 int res2 = 0 ;
50847
50848 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50850 if (!SWIG_IsOK(res1)) {
50851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50852 }
50853 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50854 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50855 if (!SWIG_IsOK(res2)) {
50856 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
50857 }
50858 arg2 = reinterpret_cast< wxSizer * >(argp2);
50859 {
50860 PyThreadState* __tstate = wxPyBeginAllowThreads();
50861 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
50862 wxPyEndAllowThreads(__tstate);
50863 if (PyErr_Occurred()) SWIG_fail;
50864 }
50865 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50866 return resultobj;
50867 fail:
50868 return NULL;
50869 }
50870
50871
50872 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
50873 int argc;
50874 PyObject *argv[3];
50875
50876 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
50877 --argc;
50878 if (argc == 2) {
50879 int _v = 0;
50880 {
50881 void *vptr = 0;
50882 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50883 _v = SWIG_CheckState(res);
50884 }
50885 if (!_v) goto check_1;
50886 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
50887 }
50888 check_1:
50889
50890 if (argc == 2) {
50891 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
50892 }
50893
50894 fail:
50895 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
50896 return NULL;
50897 }
50898
50899
50900 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50901 PyObject *resultobj = 0;
50902 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50903 wxGBPosition *arg2 = 0 ;
50904 wxGBSizerItem *result = 0 ;
50905 void *argp1 = 0 ;
50906 int res1 = 0 ;
50907 wxGBPosition temp2 ;
50908 PyObject * obj0 = 0 ;
50909 PyObject * obj1 = 0 ;
50910 char * kwnames[] = {
50911 (char *) "self",(char *) "pos", NULL
50912 };
50913
50914 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
50915 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50916 if (!SWIG_IsOK(res1)) {
50917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50918 }
50919 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50920 {
50921 arg2 = &temp2;
50922 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50923 }
50924 {
50925 PyThreadState* __tstate = wxPyBeginAllowThreads();
50926 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
50927 wxPyEndAllowThreads(__tstate);
50928 if (PyErr_Occurred()) SWIG_fail;
50929 }
50930 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50931 return resultobj;
50932 fail:
50933 return NULL;
50934 }
50935
50936
50937 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50938 PyObject *resultobj = 0;
50939 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50940 wxPoint *arg2 = 0 ;
50941 wxGBSizerItem *result = 0 ;
50942 void *argp1 = 0 ;
50943 int res1 = 0 ;
50944 wxPoint temp2 ;
50945 PyObject * obj0 = 0 ;
50946 PyObject * obj1 = 0 ;
50947 char * kwnames[] = {
50948 (char *) "self",(char *) "pt", NULL
50949 };
50950
50951 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
50952 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50953 if (!SWIG_IsOK(res1)) {
50954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50955 }
50956 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50957 {
50958 arg2 = &temp2;
50959 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
50960 }
50961 {
50962 PyThreadState* __tstate = wxPyBeginAllowThreads();
50963 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
50964 wxPyEndAllowThreads(__tstate);
50965 if (PyErr_Occurred()) SWIG_fail;
50966 }
50967 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50968 return resultobj;
50969 fail:
50970 return NULL;
50971 }
50972
50973
50974 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50975 PyObject *resultobj = 0;
50976 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50977 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
50978 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
50979 bool result;
50980 void *argp1 = 0 ;
50981 int res1 = 0 ;
50982 void *argp2 = 0 ;
50983 int res2 = 0 ;
50984 void *argp3 = 0 ;
50985 int res3 = 0 ;
50986 PyObject * obj0 = 0 ;
50987 PyObject * obj1 = 0 ;
50988 PyObject * obj2 = 0 ;
50989 char * kwnames[] = {
50990 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
50991 };
50992
50993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50995 if (!SWIG_IsOK(res1)) {
50996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50997 }
50998 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50999 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51000 if (!SWIG_IsOK(res2)) {
51001 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
51002 }
51003 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
51004 if (obj2) {
51005 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51006 if (!SWIG_IsOK(res3)) {
51007 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
51008 }
51009 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
51010 }
51011 {
51012 PyThreadState* __tstate = wxPyBeginAllowThreads();
51013 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
51014 wxPyEndAllowThreads(__tstate);
51015 if (PyErr_Occurred()) SWIG_fail;
51016 }
51017 {
51018 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51019 }
51020 return resultobj;
51021 fail:
51022 return NULL;
51023 }
51024
51025
51026 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51027 PyObject *resultobj = 0;
51028 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51029 wxGBPosition *arg2 = 0 ;
51030 wxGBSpan *arg3 = 0 ;
51031 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
51032 bool result;
51033 void *argp1 = 0 ;
51034 int res1 = 0 ;
51035 wxGBPosition temp2 ;
51036 wxGBSpan temp3 ;
51037 void *argp4 = 0 ;
51038 int res4 = 0 ;
51039 PyObject * obj0 = 0 ;
51040 PyObject * obj1 = 0 ;
51041 PyObject * obj2 = 0 ;
51042 PyObject * obj3 = 0 ;
51043 char * kwnames[] = {
51044 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
51045 };
51046
51047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51049 if (!SWIG_IsOK(res1)) {
51050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51051 }
51052 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51053 {
51054 arg2 = &temp2;
51055 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51056 }
51057 {
51058 arg3 = &temp3;
51059 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
51060 }
51061 if (obj3) {
51062 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51063 if (!SWIG_IsOK(res4)) {
51064 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
51065 }
51066 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
51067 }
51068 {
51069 PyThreadState* __tstate = wxPyBeginAllowThreads();
51070 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
51071 wxPyEndAllowThreads(__tstate);
51072 if (PyErr_Occurred()) SWIG_fail;
51073 }
51074 {
51075 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51076 }
51077 return resultobj;
51078 fail:
51079 return NULL;
51080 }
51081
51082
51083 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51084 PyObject *obj;
51085 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51086 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
51087 return SWIG_Py_Void();
51088 }
51089
51090 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51091 return SWIG_Python_InitShadowInstance(args);
51092 }
51093
51094 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51095 PyObject *resultobj = 0;
51096 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51097 wxRelationship arg2 ;
51098 wxWindow *arg3 = (wxWindow *) 0 ;
51099 wxEdge arg4 ;
51100 int arg5 = (int) 0 ;
51101 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
51102 void *argp1 = 0 ;
51103 int res1 = 0 ;
51104 int val2 ;
51105 int ecode2 = 0 ;
51106 void *argp3 = 0 ;
51107 int res3 = 0 ;
51108 int val4 ;
51109 int ecode4 = 0 ;
51110 int val5 ;
51111 int ecode5 = 0 ;
51112 int val6 ;
51113 int ecode6 = 0 ;
51114 PyObject * obj0 = 0 ;
51115 PyObject * obj1 = 0 ;
51116 PyObject * obj2 = 0 ;
51117 PyObject * obj3 = 0 ;
51118 PyObject * obj4 = 0 ;
51119 PyObject * obj5 = 0 ;
51120 char * kwnames[] = {
51121 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
51122 };
51123
51124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
51125 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51126 if (!SWIG_IsOK(res1)) {
51127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51128 }
51129 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51130 ecode2 = SWIG_AsVal_int(obj1, &val2);
51131 if (!SWIG_IsOK(ecode2)) {
51132 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
51133 }
51134 arg2 = static_cast< wxRelationship >(val2);
51135 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
51136 if (!SWIG_IsOK(res3)) {
51137 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
51138 }
51139 arg3 = reinterpret_cast< wxWindow * >(argp3);
51140 ecode4 = SWIG_AsVal_int(obj3, &val4);
51141 if (!SWIG_IsOK(ecode4)) {
51142 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
51143 }
51144 arg4 = static_cast< wxEdge >(val4);
51145 if (obj4) {
51146 ecode5 = SWIG_AsVal_int(obj4, &val5);
51147 if (!SWIG_IsOK(ecode5)) {
51148 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
51149 }
51150 arg5 = static_cast< int >(val5);
51151 }
51152 if (obj5) {
51153 ecode6 = SWIG_AsVal_int(obj5, &val6);
51154 if (!SWIG_IsOK(ecode6)) {
51155 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
51156 }
51157 arg6 = static_cast< int >(val6);
51158 }
51159 {
51160 PyThreadState* __tstate = wxPyBeginAllowThreads();
51161 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
51162 wxPyEndAllowThreads(__tstate);
51163 if (PyErr_Occurred()) SWIG_fail;
51164 }
51165 resultobj = SWIG_Py_Void();
51166 return resultobj;
51167 fail:
51168 return NULL;
51169 }
51170
51171
51172 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51173 PyObject *resultobj = 0;
51174 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51175 wxWindow *arg2 = (wxWindow *) 0 ;
51176 int arg3 = (int) 0 ;
51177 void *argp1 = 0 ;
51178 int res1 = 0 ;
51179 void *argp2 = 0 ;
51180 int res2 = 0 ;
51181 int val3 ;
51182 int ecode3 = 0 ;
51183 PyObject * obj0 = 0 ;
51184 PyObject * obj1 = 0 ;
51185 PyObject * obj2 = 0 ;
51186 char * kwnames[] = {
51187 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51188 };
51189
51190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51191 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51192 if (!SWIG_IsOK(res1)) {
51193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51194 }
51195 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51196 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51197 if (!SWIG_IsOK(res2)) {
51198 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51199 }
51200 arg2 = reinterpret_cast< wxWindow * >(argp2);
51201 if (obj2) {
51202 ecode3 = SWIG_AsVal_int(obj2, &val3);
51203 if (!SWIG_IsOK(ecode3)) {
51204 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
51205 }
51206 arg3 = static_cast< int >(val3);
51207 }
51208 {
51209 PyThreadState* __tstate = wxPyBeginAllowThreads();
51210 (arg1)->LeftOf(arg2,arg3);
51211 wxPyEndAllowThreads(__tstate);
51212 if (PyErr_Occurred()) SWIG_fail;
51213 }
51214 resultobj = SWIG_Py_Void();
51215 return resultobj;
51216 fail:
51217 return NULL;
51218 }
51219
51220
51221 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51222 PyObject *resultobj = 0;
51223 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51224 wxWindow *arg2 = (wxWindow *) 0 ;
51225 int arg3 = (int) 0 ;
51226 void *argp1 = 0 ;
51227 int res1 = 0 ;
51228 void *argp2 = 0 ;
51229 int res2 = 0 ;
51230 int val3 ;
51231 int ecode3 = 0 ;
51232 PyObject * obj0 = 0 ;
51233 PyObject * obj1 = 0 ;
51234 PyObject * obj2 = 0 ;
51235 char * kwnames[] = {
51236 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51237 };
51238
51239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51240 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51241 if (!SWIG_IsOK(res1)) {
51242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51243 }
51244 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51245 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51246 if (!SWIG_IsOK(res2)) {
51247 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51248 }
51249 arg2 = reinterpret_cast< wxWindow * >(argp2);
51250 if (obj2) {
51251 ecode3 = SWIG_AsVal_int(obj2, &val3);
51252 if (!SWIG_IsOK(ecode3)) {
51253 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
51254 }
51255 arg3 = static_cast< int >(val3);
51256 }
51257 {
51258 PyThreadState* __tstate = wxPyBeginAllowThreads();
51259 (arg1)->RightOf(arg2,arg3);
51260 wxPyEndAllowThreads(__tstate);
51261 if (PyErr_Occurred()) SWIG_fail;
51262 }
51263 resultobj = SWIG_Py_Void();
51264 return resultobj;
51265 fail:
51266 return NULL;
51267 }
51268
51269
51270 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51271 PyObject *resultobj = 0;
51272 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51273 wxWindow *arg2 = (wxWindow *) 0 ;
51274 int arg3 = (int) 0 ;
51275 void *argp1 = 0 ;
51276 int res1 = 0 ;
51277 void *argp2 = 0 ;
51278 int res2 = 0 ;
51279 int val3 ;
51280 int ecode3 = 0 ;
51281 PyObject * obj0 = 0 ;
51282 PyObject * obj1 = 0 ;
51283 PyObject * obj2 = 0 ;
51284 char * kwnames[] = {
51285 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51286 };
51287
51288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51289 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51290 if (!SWIG_IsOK(res1)) {
51291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51292 }
51293 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51294 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51295 if (!SWIG_IsOK(res2)) {
51296 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
51297 }
51298 arg2 = reinterpret_cast< wxWindow * >(argp2);
51299 if (obj2) {
51300 ecode3 = SWIG_AsVal_int(obj2, &val3);
51301 if (!SWIG_IsOK(ecode3)) {
51302 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
51303 }
51304 arg3 = static_cast< int >(val3);
51305 }
51306 {
51307 PyThreadState* __tstate = wxPyBeginAllowThreads();
51308 (arg1)->Above(arg2,arg3);
51309 wxPyEndAllowThreads(__tstate);
51310 if (PyErr_Occurred()) SWIG_fail;
51311 }
51312 resultobj = SWIG_Py_Void();
51313 return resultobj;
51314 fail:
51315 return NULL;
51316 }
51317
51318
51319 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51320 PyObject *resultobj = 0;
51321 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51322 wxWindow *arg2 = (wxWindow *) 0 ;
51323 int arg3 = (int) 0 ;
51324 void *argp1 = 0 ;
51325 int res1 = 0 ;
51326 void *argp2 = 0 ;
51327 int res2 = 0 ;
51328 int val3 ;
51329 int ecode3 = 0 ;
51330 PyObject * obj0 = 0 ;
51331 PyObject * obj1 = 0 ;
51332 PyObject * obj2 = 0 ;
51333 char * kwnames[] = {
51334 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51335 };
51336
51337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51338 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51339 if (!SWIG_IsOK(res1)) {
51340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51341 }
51342 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51343 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51344 if (!SWIG_IsOK(res2)) {
51345 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
51346 }
51347 arg2 = reinterpret_cast< wxWindow * >(argp2);
51348 if (obj2) {
51349 ecode3 = SWIG_AsVal_int(obj2, &val3);
51350 if (!SWIG_IsOK(ecode3)) {
51351 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
51352 }
51353 arg3 = static_cast< int >(val3);
51354 }
51355 {
51356 PyThreadState* __tstate = wxPyBeginAllowThreads();
51357 (arg1)->Below(arg2,arg3);
51358 wxPyEndAllowThreads(__tstate);
51359 if (PyErr_Occurred()) SWIG_fail;
51360 }
51361 resultobj = SWIG_Py_Void();
51362 return resultobj;
51363 fail:
51364 return NULL;
51365 }
51366
51367
51368 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51369 PyObject *resultobj = 0;
51370 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51371 wxWindow *arg2 = (wxWindow *) 0 ;
51372 wxEdge arg3 ;
51373 int arg4 = (int) 0 ;
51374 void *argp1 = 0 ;
51375 int res1 = 0 ;
51376 void *argp2 = 0 ;
51377 int res2 = 0 ;
51378 int val3 ;
51379 int ecode3 = 0 ;
51380 int val4 ;
51381 int ecode4 = 0 ;
51382 PyObject * obj0 = 0 ;
51383 PyObject * obj1 = 0 ;
51384 PyObject * obj2 = 0 ;
51385 PyObject * obj3 = 0 ;
51386 char * kwnames[] = {
51387 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
51388 };
51389
51390 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51391 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51392 if (!SWIG_IsOK(res1)) {
51393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51394 }
51395 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51396 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51397 if (!SWIG_IsOK(res2)) {
51398 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
51399 }
51400 arg2 = reinterpret_cast< wxWindow * >(argp2);
51401 ecode3 = SWIG_AsVal_int(obj2, &val3);
51402 if (!SWIG_IsOK(ecode3)) {
51403 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
51404 }
51405 arg3 = static_cast< wxEdge >(val3);
51406 if (obj3) {
51407 ecode4 = SWIG_AsVal_int(obj3, &val4);
51408 if (!SWIG_IsOK(ecode4)) {
51409 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
51410 }
51411 arg4 = static_cast< int >(val4);
51412 }
51413 {
51414 PyThreadState* __tstate = wxPyBeginAllowThreads();
51415 (arg1)->SameAs(arg2,arg3,arg4);
51416 wxPyEndAllowThreads(__tstate);
51417 if (PyErr_Occurred()) SWIG_fail;
51418 }
51419 resultobj = SWIG_Py_Void();
51420 return resultobj;
51421 fail:
51422 return NULL;
51423 }
51424
51425
51426 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51427 PyObject *resultobj = 0;
51428 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51429 wxWindow *arg2 = (wxWindow *) 0 ;
51430 wxEdge arg3 ;
51431 int arg4 ;
51432 void *argp1 = 0 ;
51433 int res1 = 0 ;
51434 void *argp2 = 0 ;
51435 int res2 = 0 ;
51436 int val3 ;
51437 int ecode3 = 0 ;
51438 int val4 ;
51439 int ecode4 = 0 ;
51440 PyObject * obj0 = 0 ;
51441 PyObject * obj1 = 0 ;
51442 PyObject * obj2 = 0 ;
51443 PyObject * obj3 = 0 ;
51444 char * kwnames[] = {
51445 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
51446 };
51447
51448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51450 if (!SWIG_IsOK(res1)) {
51451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51452 }
51453 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51454 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51455 if (!SWIG_IsOK(res2)) {
51456 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51457 }
51458 arg2 = reinterpret_cast< wxWindow * >(argp2);
51459 ecode3 = SWIG_AsVal_int(obj2, &val3);
51460 if (!SWIG_IsOK(ecode3)) {
51461 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
51462 }
51463 arg3 = static_cast< wxEdge >(val3);
51464 ecode4 = SWIG_AsVal_int(obj3, &val4);
51465 if (!SWIG_IsOK(ecode4)) {
51466 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
51467 }
51468 arg4 = static_cast< int >(val4);
51469 {
51470 PyThreadState* __tstate = wxPyBeginAllowThreads();
51471 (arg1)->PercentOf(arg2,arg3,arg4);
51472 wxPyEndAllowThreads(__tstate);
51473 if (PyErr_Occurred()) SWIG_fail;
51474 }
51475 resultobj = SWIG_Py_Void();
51476 return resultobj;
51477 fail:
51478 return NULL;
51479 }
51480
51481
51482 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51483 PyObject *resultobj = 0;
51484 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51485 int arg2 ;
51486 void *argp1 = 0 ;
51487 int res1 = 0 ;
51488 int val2 ;
51489 int ecode2 = 0 ;
51490 PyObject * obj0 = 0 ;
51491 PyObject * obj1 = 0 ;
51492 char * kwnames[] = {
51493 (char *) "self",(char *) "val", NULL
51494 };
51495
51496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
51497 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51498 if (!SWIG_IsOK(res1)) {
51499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51500 }
51501 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51502 ecode2 = SWIG_AsVal_int(obj1, &val2);
51503 if (!SWIG_IsOK(ecode2)) {
51504 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
51505 }
51506 arg2 = static_cast< int >(val2);
51507 {
51508 PyThreadState* __tstate = wxPyBeginAllowThreads();
51509 (arg1)->Absolute(arg2);
51510 wxPyEndAllowThreads(__tstate);
51511 if (PyErr_Occurred()) SWIG_fail;
51512 }
51513 resultobj = SWIG_Py_Void();
51514 return resultobj;
51515 fail:
51516 return NULL;
51517 }
51518
51519
51520 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51521 PyObject *resultobj = 0;
51522 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51523 void *argp1 = 0 ;
51524 int res1 = 0 ;
51525 PyObject *swig_obj[1] ;
51526
51527 if (!args) SWIG_fail;
51528 swig_obj[0] = args;
51529 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51530 if (!SWIG_IsOK(res1)) {
51531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51532 }
51533 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51534 {
51535 PyThreadState* __tstate = wxPyBeginAllowThreads();
51536 (arg1)->Unconstrained();
51537 wxPyEndAllowThreads(__tstate);
51538 if (PyErr_Occurred()) SWIG_fail;
51539 }
51540 resultobj = SWIG_Py_Void();
51541 return resultobj;
51542 fail:
51543 return NULL;
51544 }
51545
51546
51547 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51548 PyObject *resultobj = 0;
51549 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51550 void *argp1 = 0 ;
51551 int res1 = 0 ;
51552 PyObject *swig_obj[1] ;
51553
51554 if (!args) SWIG_fail;
51555 swig_obj[0] = args;
51556 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51557 if (!SWIG_IsOK(res1)) {
51558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51559 }
51560 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51561 {
51562 PyThreadState* __tstate = wxPyBeginAllowThreads();
51563 (arg1)->AsIs();
51564 wxPyEndAllowThreads(__tstate);
51565 if (PyErr_Occurred()) SWIG_fail;
51566 }
51567 resultobj = SWIG_Py_Void();
51568 return resultobj;
51569 fail:
51570 return NULL;
51571 }
51572
51573
51574 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51575 PyObject *resultobj = 0;
51576 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51577 wxWindow *result = 0 ;
51578 void *argp1 = 0 ;
51579 int res1 = 0 ;
51580 PyObject *swig_obj[1] ;
51581
51582 if (!args) SWIG_fail;
51583 swig_obj[0] = args;
51584 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51585 if (!SWIG_IsOK(res1)) {
51586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51587 }
51588 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51589 {
51590 PyThreadState* __tstate = wxPyBeginAllowThreads();
51591 result = (wxWindow *)(arg1)->GetOtherWindow();
51592 wxPyEndAllowThreads(__tstate);
51593 if (PyErr_Occurred()) SWIG_fail;
51594 }
51595 {
51596 resultobj = wxPyMake_wxObject(result, 0);
51597 }
51598 return resultobj;
51599 fail:
51600 return NULL;
51601 }
51602
51603
51604 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51605 PyObject *resultobj = 0;
51606 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51607 wxEdge result;
51608 void *argp1 = 0 ;
51609 int res1 = 0 ;
51610 PyObject *swig_obj[1] ;
51611
51612 if (!args) SWIG_fail;
51613 swig_obj[0] = args;
51614 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51615 if (!SWIG_IsOK(res1)) {
51616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51617 }
51618 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51619 {
51620 PyThreadState* __tstate = wxPyBeginAllowThreads();
51621 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
51622 wxPyEndAllowThreads(__tstate);
51623 if (PyErr_Occurred()) SWIG_fail;
51624 }
51625 resultobj = SWIG_From_int(static_cast< int >(result));
51626 return resultobj;
51627 fail:
51628 return NULL;
51629 }
51630
51631
51632 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51633 PyObject *resultobj = 0;
51634 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51635 wxEdge arg2 ;
51636 void *argp1 = 0 ;
51637 int res1 = 0 ;
51638 int val2 ;
51639 int ecode2 = 0 ;
51640 PyObject * obj0 = 0 ;
51641 PyObject * obj1 = 0 ;
51642 char * kwnames[] = {
51643 (char *) "self",(char *) "which", NULL
51644 };
51645
51646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) 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_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51650 }
51651 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51652 ecode2 = SWIG_AsVal_int(obj1, &val2);
51653 if (!SWIG_IsOK(ecode2)) {
51654 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
51655 }
51656 arg2 = static_cast< wxEdge >(val2);
51657 {
51658 PyThreadState* __tstate = wxPyBeginAllowThreads();
51659 (arg1)->SetEdge(arg2);
51660 wxPyEndAllowThreads(__tstate);
51661 if (PyErr_Occurred()) SWIG_fail;
51662 }
51663 resultobj = SWIG_Py_Void();
51664 return resultobj;
51665 fail:
51666 return NULL;
51667 }
51668
51669
51670 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51671 PyObject *resultobj = 0;
51672 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51673 int arg2 ;
51674 void *argp1 = 0 ;
51675 int res1 = 0 ;
51676 int val2 ;
51677 int ecode2 = 0 ;
51678 PyObject * obj0 = 0 ;
51679 PyObject * obj1 = 0 ;
51680 char * kwnames[] = {
51681 (char *) "self",(char *) "v", NULL
51682 };
51683
51684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
51685 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51686 if (!SWIG_IsOK(res1)) {
51687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51688 }
51689 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51690 ecode2 = SWIG_AsVal_int(obj1, &val2);
51691 if (!SWIG_IsOK(ecode2)) {
51692 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
51693 }
51694 arg2 = static_cast< int >(val2);
51695 {
51696 PyThreadState* __tstate = wxPyBeginAllowThreads();
51697 (arg1)->SetValue(arg2);
51698 wxPyEndAllowThreads(__tstate);
51699 if (PyErr_Occurred()) SWIG_fail;
51700 }
51701 resultobj = SWIG_Py_Void();
51702 return resultobj;
51703 fail:
51704 return NULL;
51705 }
51706
51707
51708 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51709 PyObject *resultobj = 0;
51710 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51711 int result;
51712 void *argp1 = 0 ;
51713 int res1 = 0 ;
51714 PyObject *swig_obj[1] ;
51715
51716 if (!args) SWIG_fail;
51717 swig_obj[0] = args;
51718 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51719 if (!SWIG_IsOK(res1)) {
51720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51721 }
51722 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51723 {
51724 PyThreadState* __tstate = wxPyBeginAllowThreads();
51725 result = (int)(arg1)->GetMargin();
51726 wxPyEndAllowThreads(__tstate);
51727 if (PyErr_Occurred()) SWIG_fail;
51728 }
51729 resultobj = SWIG_From_int(static_cast< int >(result));
51730 return resultobj;
51731 fail:
51732 return NULL;
51733 }
51734
51735
51736 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51737 PyObject *resultobj = 0;
51738 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51739 int arg2 ;
51740 void *argp1 = 0 ;
51741 int res1 = 0 ;
51742 int val2 ;
51743 int ecode2 = 0 ;
51744 PyObject * obj0 = 0 ;
51745 PyObject * obj1 = 0 ;
51746 char * kwnames[] = {
51747 (char *) "self",(char *) "m", NULL
51748 };
51749
51750 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
51751 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51752 if (!SWIG_IsOK(res1)) {
51753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51754 }
51755 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51756 ecode2 = SWIG_AsVal_int(obj1, &val2);
51757 if (!SWIG_IsOK(ecode2)) {
51758 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
51759 }
51760 arg2 = static_cast< int >(val2);
51761 {
51762 PyThreadState* __tstate = wxPyBeginAllowThreads();
51763 (arg1)->SetMargin(arg2);
51764 wxPyEndAllowThreads(__tstate);
51765 if (PyErr_Occurred()) SWIG_fail;
51766 }
51767 resultobj = SWIG_Py_Void();
51768 return resultobj;
51769 fail:
51770 return NULL;
51771 }
51772
51773
51774 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51775 PyObject *resultobj = 0;
51776 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51777 int result;
51778 void *argp1 = 0 ;
51779 int res1 = 0 ;
51780 PyObject *swig_obj[1] ;
51781
51782 if (!args) SWIG_fail;
51783 swig_obj[0] = args;
51784 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51785 if (!SWIG_IsOK(res1)) {
51786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51787 }
51788 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51789 {
51790 PyThreadState* __tstate = wxPyBeginAllowThreads();
51791 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
51792 wxPyEndAllowThreads(__tstate);
51793 if (PyErr_Occurred()) SWIG_fail;
51794 }
51795 resultobj = SWIG_From_int(static_cast< int >(result));
51796 return resultobj;
51797 fail:
51798 return NULL;
51799 }
51800
51801
51802 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51803 PyObject *resultobj = 0;
51804 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51805 int result;
51806 void *argp1 = 0 ;
51807 int res1 = 0 ;
51808 PyObject *swig_obj[1] ;
51809
51810 if (!args) SWIG_fail;
51811 swig_obj[0] = args;
51812 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51813 if (!SWIG_IsOK(res1)) {
51814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51815 }
51816 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51817 {
51818 PyThreadState* __tstate = wxPyBeginAllowThreads();
51819 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
51820 wxPyEndAllowThreads(__tstate);
51821 if (PyErr_Occurred()) SWIG_fail;
51822 }
51823 resultobj = SWIG_From_int(static_cast< int >(result));
51824 return resultobj;
51825 fail:
51826 return NULL;
51827 }
51828
51829
51830 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51831 PyObject *resultobj = 0;
51832 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51833 int result;
51834 void *argp1 = 0 ;
51835 int res1 = 0 ;
51836 PyObject *swig_obj[1] ;
51837
51838 if (!args) SWIG_fail;
51839 swig_obj[0] = args;
51840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51841 if (!SWIG_IsOK(res1)) {
51842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51843 }
51844 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51845 {
51846 PyThreadState* __tstate = wxPyBeginAllowThreads();
51847 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
51848 wxPyEndAllowThreads(__tstate);
51849 if (PyErr_Occurred()) SWIG_fail;
51850 }
51851 resultobj = SWIG_From_int(static_cast< int >(result));
51852 return resultobj;
51853 fail:
51854 return NULL;
51855 }
51856
51857
51858 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51859 PyObject *resultobj = 0;
51860 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51861 bool result;
51862 void *argp1 = 0 ;
51863 int res1 = 0 ;
51864 PyObject *swig_obj[1] ;
51865
51866 if (!args) SWIG_fail;
51867 swig_obj[0] = args;
51868 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51869 if (!SWIG_IsOK(res1)) {
51870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51871 }
51872 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51873 {
51874 PyThreadState* __tstate = wxPyBeginAllowThreads();
51875 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
51876 wxPyEndAllowThreads(__tstate);
51877 if (PyErr_Occurred()) SWIG_fail;
51878 }
51879 {
51880 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51881 }
51882 return resultobj;
51883 fail:
51884 return NULL;
51885 }
51886
51887
51888 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51889 PyObject *resultobj = 0;
51890 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51891 bool arg2 ;
51892 void *argp1 = 0 ;
51893 int res1 = 0 ;
51894 bool val2 ;
51895 int ecode2 = 0 ;
51896 PyObject * obj0 = 0 ;
51897 PyObject * obj1 = 0 ;
51898 char * kwnames[] = {
51899 (char *) "self",(char *) "d", NULL
51900 };
51901
51902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
51903 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51904 if (!SWIG_IsOK(res1)) {
51905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51906 }
51907 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51908 ecode2 = SWIG_AsVal_bool(obj1, &val2);
51909 if (!SWIG_IsOK(ecode2)) {
51910 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
51911 }
51912 arg2 = static_cast< bool >(val2);
51913 {
51914 PyThreadState* __tstate = wxPyBeginAllowThreads();
51915 (arg1)->SetDone(arg2);
51916 wxPyEndAllowThreads(__tstate);
51917 if (PyErr_Occurred()) SWIG_fail;
51918 }
51919 resultobj = SWIG_Py_Void();
51920 return resultobj;
51921 fail:
51922 return NULL;
51923 }
51924
51925
51926 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51927 PyObject *resultobj = 0;
51928 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51929 wxRelationship result;
51930 void *argp1 = 0 ;
51931 int res1 = 0 ;
51932 PyObject *swig_obj[1] ;
51933
51934 if (!args) SWIG_fail;
51935 swig_obj[0] = args;
51936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51937 if (!SWIG_IsOK(res1)) {
51938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51939 }
51940 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51941 {
51942 PyThreadState* __tstate = wxPyBeginAllowThreads();
51943 result = (wxRelationship)(arg1)->GetRelationship();
51944 wxPyEndAllowThreads(__tstate);
51945 if (PyErr_Occurred()) SWIG_fail;
51946 }
51947 resultobj = SWIG_From_int(static_cast< int >(result));
51948 return resultobj;
51949 fail:
51950 return NULL;
51951 }
51952
51953
51954 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51955 PyObject *resultobj = 0;
51956 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51957 wxRelationship arg2 ;
51958 void *argp1 = 0 ;
51959 int res1 = 0 ;
51960 int val2 ;
51961 int ecode2 = 0 ;
51962 PyObject * obj0 = 0 ;
51963 PyObject * obj1 = 0 ;
51964 char * kwnames[] = {
51965 (char *) "self",(char *) "r", NULL
51966 };
51967
51968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
51969 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51970 if (!SWIG_IsOK(res1)) {
51971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51972 }
51973 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51974 ecode2 = SWIG_AsVal_int(obj1, &val2);
51975 if (!SWIG_IsOK(ecode2)) {
51976 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
51977 }
51978 arg2 = static_cast< wxRelationship >(val2);
51979 {
51980 PyThreadState* __tstate = wxPyBeginAllowThreads();
51981 (arg1)->SetRelationship(arg2);
51982 wxPyEndAllowThreads(__tstate);
51983 if (PyErr_Occurred()) SWIG_fail;
51984 }
51985 resultobj = SWIG_Py_Void();
51986 return resultobj;
51987 fail:
51988 return NULL;
51989 }
51990
51991
51992 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51993 PyObject *resultobj = 0;
51994 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51995 wxWindow *arg2 = (wxWindow *) 0 ;
51996 bool result;
51997 void *argp1 = 0 ;
51998 int res1 = 0 ;
51999 void *argp2 = 0 ;
52000 int res2 = 0 ;
52001 PyObject * obj0 = 0 ;
52002 PyObject * obj1 = 0 ;
52003 char * kwnames[] = {
52004 (char *) "self",(char *) "otherW", NULL
52005 };
52006
52007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
52008 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52009 if (!SWIG_IsOK(res1)) {
52010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52011 }
52012 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52013 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52014 if (!SWIG_IsOK(res2)) {
52015 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
52016 }
52017 arg2 = reinterpret_cast< wxWindow * >(argp2);
52018 {
52019 PyThreadState* __tstate = wxPyBeginAllowThreads();
52020 result = (bool)(arg1)->ResetIfWin(arg2);
52021 wxPyEndAllowThreads(__tstate);
52022 if (PyErr_Occurred()) SWIG_fail;
52023 }
52024 {
52025 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52026 }
52027 return resultobj;
52028 fail:
52029 return NULL;
52030 }
52031
52032
52033 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52034 PyObject *resultobj = 0;
52035 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52036 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
52037 wxWindow *arg3 = (wxWindow *) 0 ;
52038 bool result;
52039 void *argp1 = 0 ;
52040 int res1 = 0 ;
52041 void *argp2 = 0 ;
52042 int res2 = 0 ;
52043 void *argp3 = 0 ;
52044 int res3 = 0 ;
52045 PyObject * obj0 = 0 ;
52046 PyObject * obj1 = 0 ;
52047 PyObject * obj2 = 0 ;
52048 char * kwnames[] = {
52049 (char *) "self",(char *) "constraints",(char *) "win", NULL
52050 };
52051
52052 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52053 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52054 if (!SWIG_IsOK(res1)) {
52055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52056 }
52057 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52058 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52059 if (!SWIG_IsOK(res2)) {
52060 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
52061 }
52062 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
52063 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52064 if (!SWIG_IsOK(res3)) {
52065 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
52066 }
52067 arg3 = reinterpret_cast< wxWindow * >(argp3);
52068 {
52069 PyThreadState* __tstate = wxPyBeginAllowThreads();
52070 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
52071 wxPyEndAllowThreads(__tstate);
52072 if (PyErr_Occurred()) SWIG_fail;
52073 }
52074 {
52075 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52076 }
52077 return resultobj;
52078 fail:
52079 return NULL;
52080 }
52081
52082
52083 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52084 PyObject *resultobj = 0;
52085 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52086 wxEdge arg2 ;
52087 wxWindow *arg3 = (wxWindow *) 0 ;
52088 wxWindow *arg4 = (wxWindow *) 0 ;
52089 int result;
52090 void *argp1 = 0 ;
52091 int res1 = 0 ;
52092 int val2 ;
52093 int ecode2 = 0 ;
52094 void *argp3 = 0 ;
52095 int res3 = 0 ;
52096 void *argp4 = 0 ;
52097 int res4 = 0 ;
52098 PyObject * obj0 = 0 ;
52099 PyObject * obj1 = 0 ;
52100 PyObject * obj2 = 0 ;
52101 PyObject * obj3 = 0 ;
52102 char * kwnames[] = {
52103 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
52104 };
52105
52106 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52107 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52108 if (!SWIG_IsOK(res1)) {
52109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52110 }
52111 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52112 ecode2 = SWIG_AsVal_int(obj1, &val2);
52113 if (!SWIG_IsOK(ecode2)) {
52114 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
52115 }
52116 arg2 = static_cast< wxEdge >(val2);
52117 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52118 if (!SWIG_IsOK(res3)) {
52119 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
52120 }
52121 arg3 = reinterpret_cast< wxWindow * >(argp3);
52122 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
52123 if (!SWIG_IsOK(res4)) {
52124 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
52125 }
52126 arg4 = reinterpret_cast< wxWindow * >(argp4);
52127 {
52128 PyThreadState* __tstate = wxPyBeginAllowThreads();
52129 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
52130 wxPyEndAllowThreads(__tstate);
52131 if (PyErr_Occurred()) SWIG_fail;
52132 }
52133 resultobj = SWIG_From_int(static_cast< int >(result));
52134 return resultobj;
52135 fail:
52136 return NULL;
52137 }
52138
52139
52140 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52141 PyObject *obj;
52142 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52143 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
52144 return SWIG_Py_Void();
52145 }
52146
52147 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52148 PyObject *resultobj = 0;
52149 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52150 wxIndividualLayoutConstraint *result = 0 ;
52151 void *argp1 = 0 ;
52152 int res1 = 0 ;
52153 PyObject *swig_obj[1] ;
52154
52155 if (!args) SWIG_fail;
52156 swig_obj[0] = args;
52157 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52158 if (!SWIG_IsOK(res1)) {
52159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52160 }
52161 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52162 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
52163 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52164 return resultobj;
52165 fail:
52166 return NULL;
52167 }
52168
52169
52170 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52171 PyObject *resultobj = 0;
52172 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52173 wxIndividualLayoutConstraint *result = 0 ;
52174 void *argp1 = 0 ;
52175 int res1 = 0 ;
52176 PyObject *swig_obj[1] ;
52177
52178 if (!args) SWIG_fail;
52179 swig_obj[0] = args;
52180 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52181 if (!SWIG_IsOK(res1)) {
52182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52183 }
52184 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52185 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
52186 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52187 return resultobj;
52188 fail:
52189 return NULL;
52190 }
52191
52192
52193 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52194 PyObject *resultobj = 0;
52195 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52196 wxIndividualLayoutConstraint *result = 0 ;
52197 void *argp1 = 0 ;
52198 int res1 = 0 ;
52199 PyObject *swig_obj[1] ;
52200
52201 if (!args) SWIG_fail;
52202 swig_obj[0] = args;
52203 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52204 if (!SWIG_IsOK(res1)) {
52205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52206 }
52207 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52208 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
52209 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52210 return resultobj;
52211 fail:
52212 return NULL;
52213 }
52214
52215
52216 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52217 PyObject *resultobj = 0;
52218 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52219 wxIndividualLayoutConstraint *result = 0 ;
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_wxLayoutConstraints, 0 | 0 );
52227 if (!SWIG_IsOK(res1)) {
52228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52229 }
52230 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52231 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
52232 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52233 return resultobj;
52234 fail:
52235 return NULL;
52236 }
52237
52238
52239 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52240 PyObject *resultobj = 0;
52241 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52242 wxIndividualLayoutConstraint *result = 0 ;
52243 void *argp1 = 0 ;
52244 int res1 = 0 ;
52245 PyObject *swig_obj[1] ;
52246
52247 if (!args) SWIG_fail;
52248 swig_obj[0] = args;
52249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52250 if (!SWIG_IsOK(res1)) {
52251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52252 }
52253 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52254 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
52255 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52256 return resultobj;
52257 fail:
52258 return NULL;
52259 }
52260
52261
52262 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52263 PyObject *resultobj = 0;
52264 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52265 wxIndividualLayoutConstraint *result = 0 ;
52266 void *argp1 = 0 ;
52267 int res1 = 0 ;
52268 PyObject *swig_obj[1] ;
52269
52270 if (!args) SWIG_fail;
52271 swig_obj[0] = args;
52272 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52273 if (!SWIG_IsOK(res1)) {
52274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52275 }
52276 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52277 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
52278 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52279 return resultobj;
52280 fail:
52281 return NULL;
52282 }
52283
52284
52285 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52286 PyObject *resultobj = 0;
52287 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52288 wxIndividualLayoutConstraint *result = 0 ;
52289 void *argp1 = 0 ;
52290 int res1 = 0 ;
52291 PyObject *swig_obj[1] ;
52292
52293 if (!args) SWIG_fail;
52294 swig_obj[0] = args;
52295 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52296 if (!SWIG_IsOK(res1)) {
52297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52298 }
52299 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52300 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
52301 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52302 return resultobj;
52303 fail:
52304 return NULL;
52305 }
52306
52307
52308 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52309 PyObject *resultobj = 0;
52310 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52311 wxIndividualLayoutConstraint *result = 0 ;
52312 void *argp1 = 0 ;
52313 int res1 = 0 ;
52314 PyObject *swig_obj[1] ;
52315
52316 if (!args) SWIG_fail;
52317 swig_obj[0] = args;
52318 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52319 if (!SWIG_IsOK(res1)) {
52320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52321 }
52322 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52323 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
52324 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52325 return resultobj;
52326 fail:
52327 return NULL;
52328 }
52329
52330
52331 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52332 PyObject *resultobj = 0;
52333 wxLayoutConstraints *result = 0 ;
52334
52335 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
52336 {
52337 PyThreadState* __tstate = wxPyBeginAllowThreads();
52338 result = (wxLayoutConstraints *)new wxLayoutConstraints();
52339 wxPyEndAllowThreads(__tstate);
52340 if (PyErr_Occurred()) SWIG_fail;
52341 }
52342 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
52343 return resultobj;
52344 fail:
52345 return NULL;
52346 }
52347
52348
52349 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52350 PyObject *resultobj = 0;
52351 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52352 void *argp1 = 0 ;
52353 int res1 = 0 ;
52354 PyObject *swig_obj[1] ;
52355
52356 if (!args) SWIG_fail;
52357 swig_obj[0] = args;
52358 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
52359 if (!SWIG_IsOK(res1)) {
52360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52361 }
52362 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52363 {
52364 PyThreadState* __tstate = wxPyBeginAllowThreads();
52365 delete arg1;
52366
52367 wxPyEndAllowThreads(__tstate);
52368 if (PyErr_Occurred()) SWIG_fail;
52369 }
52370 resultobj = SWIG_Py_Void();
52371 return resultobj;
52372 fail:
52373 return NULL;
52374 }
52375
52376
52377 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52378 PyObject *resultobj = 0;
52379 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52380 wxWindow *arg2 = (wxWindow *) 0 ;
52381 int *arg3 = (int *) 0 ;
52382 bool result;
52383 void *argp1 = 0 ;
52384 int res1 = 0 ;
52385 void *argp2 = 0 ;
52386 int res2 = 0 ;
52387 int temp3 ;
52388 int res3 = SWIG_TMPOBJ ;
52389 PyObject * obj0 = 0 ;
52390 PyObject * obj1 = 0 ;
52391 char * kwnames[] = {
52392 (char *) "self",(char *) "win", NULL
52393 };
52394
52395 arg3 = &temp3;
52396 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
52397 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52398 if (!SWIG_IsOK(res1)) {
52399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52400 }
52401 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52402 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52403 if (!SWIG_IsOK(res2)) {
52404 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
52405 }
52406 arg2 = reinterpret_cast< wxWindow * >(argp2);
52407 {
52408 PyThreadState* __tstate = wxPyBeginAllowThreads();
52409 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
52410 wxPyEndAllowThreads(__tstate);
52411 if (PyErr_Occurred()) SWIG_fail;
52412 }
52413 {
52414 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52415 }
52416 if (SWIG_IsTmpObj(res3)) {
52417 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
52418 } else {
52419 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
52420 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
52421 }
52422 return resultobj;
52423 fail:
52424 return NULL;
52425 }
52426
52427
52428 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52429 PyObject *resultobj = 0;
52430 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52431 bool result;
52432 void *argp1 = 0 ;
52433 int res1 = 0 ;
52434 PyObject *swig_obj[1] ;
52435
52436 if (!args) SWIG_fail;
52437 swig_obj[0] = args;
52438 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52439 if (!SWIG_IsOK(res1)) {
52440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
52441 }
52442 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52443 {
52444 PyThreadState* __tstate = wxPyBeginAllowThreads();
52445 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
52446 wxPyEndAllowThreads(__tstate);
52447 if (PyErr_Occurred()) SWIG_fail;
52448 }
52449 {
52450 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52451 }
52452 return resultobj;
52453 fail:
52454 return NULL;
52455 }
52456
52457
52458 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52459 PyObject *obj;
52460 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52461 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
52462 return SWIG_Py_Void();
52463 }
52464
52465 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52466 return SWIG_Python_InitShadowInstance(args);
52467 }
52468
52469 static PyMethodDef SwigMethods[] = {
52470 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
52471 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
52472 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
52473 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
52474 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
52475 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
52476 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
52477 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
52478 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
52479 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
52480 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52481 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52482 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52483 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52484 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
52485 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
52486 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52487 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
52488 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
52489 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
52490 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
52491 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
52492 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
52493 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
52494 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
52495 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
52496 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
52497 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
52498 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
52499 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
52500 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
52501 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
52502 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52503 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52504 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52505 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52506 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52507 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
52508 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
52509 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
52510 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
52511 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
52512 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
52513 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
52514 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
52515 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
52516 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52517 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52518 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52519 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52520 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52521 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
52522 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52523 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
52524 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
52525 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
52526 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
52527 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
52528 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
52529 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
52530 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
52531 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
52532 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
52533 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
52534 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
52535 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
52536 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
52537 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
52538 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
52539 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
52540 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52541 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
52542 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
52543 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
52544 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
52545 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
52546 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
52547 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
52548 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
52549 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
52550 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
52551 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
52552 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
52553 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
52554 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
52555 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
52556 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
52557 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
52558 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
52559 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
52560 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
52561 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
52562 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52563 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52564 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52565 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52566 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
52567 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
52568 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
52569 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
52570 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
52571 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
52572 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
52573 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
52574 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
52575 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
52576 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
52577 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
52578 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52579 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
52580 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
52581 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
52582 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
52583 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
52584 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
52585 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
52586 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
52587 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
52588 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
52589 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
52590 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
52591 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
52592 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
52593 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
52594 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
52595 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
52596 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
52597 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52598 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
52599 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
52600 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
52601 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52602 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52603 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
52604 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
52605 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
52606 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
52607 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52608 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
52609 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
52610 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
52611 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
52612 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
52613 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
52614 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
52615 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
52616 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
52617 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
52618 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
52619 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
52620 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
52621 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
52622 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
52623 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
52624 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
52625 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
52626 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
52627 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
52628 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
52629 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
52630 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
52631 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
52632 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
52633 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
52634 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
52635 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
52636 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
52637 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
52638 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
52639 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
52640 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
52641 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
52642 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
52643 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
52644 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
52645 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
52646 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
52647 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52648 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52649 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52650 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
52651 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
52652 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
52653 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
52654 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
52655 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
52656 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
52657 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
52658 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
52659 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
52660 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
52661 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
52662 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52663 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52664 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
52665 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52666 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
52667 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
52668 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
52669 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
52670 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
52671 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
52672 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52673 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52674 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
52675 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
52676 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
52677 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52678 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52679 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52680 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
52681 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
52682 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
52683 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
52684 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52685 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
52686 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
52687 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
52688 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52689 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52690 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52691 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
52692 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
52693 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
52694 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
52695 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
52696 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
52697 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
52698 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
52699 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
52700 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
52701 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
52702 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
52703 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
52704 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
52705 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
52706 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
52707 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
52708 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
52709 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
52710 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
52711 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
52712 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
52713 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
52714 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
52715 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
52716 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
52717 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
52718 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
52719 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
52720 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
52721 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
52722 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
52723 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
52724 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
52725 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
52726 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
52727 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
52728 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
52729 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
52730 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
52731 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
52732 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
52733 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
52734 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
52735 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
52736 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
52737 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
52738 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
52739 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
52740 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52741 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
52742 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52743 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
52744 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
52745 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
52746 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
52747 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
52748 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
52749 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
52750 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
52751 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
52752 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
52753 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
52754 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52755 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52756 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
52757 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
52758 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
52759 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
52760 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
52761 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52762 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
52763 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
52764 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
52765 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
52766 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
52767 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
52768 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
52769 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
52770 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
52771 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
52772 { (char *)"Image_Ok", (PyCFunction)_wrap_Image_Ok, METH_O, NULL},
52773 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
52774 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
52775 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
52776 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
52777 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
52778 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
52779 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
52780 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
52781 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
52782 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
52783 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
52784 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
52785 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
52786 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
52787 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
52788 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
52789 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
52790 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
52791 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
52792 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
52793 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
52794 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
52795 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
52796 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
52797 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
52798 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
52799 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
52800 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
52801 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
52802 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
52803 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
52804 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
52805 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
52806 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
52807 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
52808 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52809 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52810 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52811 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
52812 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
52813 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52814 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52815 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
52816 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
52817 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
52818 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
52819 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
52820 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
52821 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
52822 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
52823 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
52824 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
52825 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
52826 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
52827 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
52828 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
52829 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
52830 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
52831 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
52832 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
52833 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
52834 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
52835 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
52836 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
52837 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
52838 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
52839 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
52840 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
52841 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
52842 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
52843 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
52844 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
52845 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
52846 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
52847 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
52848 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
52849 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
52850 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
52851 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
52852 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
52853 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
52854 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
52855 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
52856 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
52857 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
52858 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52859 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52860 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
52861 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
52862 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52863 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52864 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
52865 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
52866 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
52867 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
52868 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
52869 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
52870 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
52871 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
52872 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
52873 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
52874 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
52875 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
52876 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
52877 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
52878 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
52879 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
52880 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
52881 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
52882 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
52883 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
52884 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
52885 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
52886 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
52887 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
52888 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
52889 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
52890 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
52891 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
52892 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
52893 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
52894 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
52895 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
52896 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52897 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
52898 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
52899 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
52900 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
52901 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
52902 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
52903 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
52904 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
52905 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
52906 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
52907 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
52908 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
52909 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
52910 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
52911 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52912 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
52913 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
52914 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
52915 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
52916 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
52917 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52918 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
52919 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
52920 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
52921 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52922 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
52923 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
52924 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52925 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
52926 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
52927 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
52928 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52929 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
52930 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
52931 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52932 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
52933 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
52934 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
52935 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
52936 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
52937 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
52938 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
52939 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
52940 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
52941 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
52942 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
52943 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
52944 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
52945 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
52946 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
52947 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
52948 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
52949 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
52950 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
52951 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
52952 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
52953 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
52954 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
52955 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
52956 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
52957 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
52958 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
52959 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
52960 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
52961 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
52962 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52963 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
52964 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
52965 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
52966 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
52967 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
52968 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
52969 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
52970 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
52971 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
52972 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
52973 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
52974 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
52975 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
52976 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
52977 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
52978 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
52979 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
52980 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
52981 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
52982 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
52983 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
52984 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
52985 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
52986 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
52987 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
52988 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
52989 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
52990 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
52991 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
52992 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
52993 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
52994 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
52995 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52996 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
52997 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
52998 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
52999 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
53000 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
53001 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
53002 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
53003 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53004 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
53005 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
53006 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
53007 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
53008 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
53009 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
53010 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
53011 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
53012 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
53013 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
53014 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
53015 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
53016 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
53017 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
53018 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
53019 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
53020 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
53021 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
53022 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
53023 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
53024 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
53025 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
53026 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
53027 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
53028 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
53029 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
53030 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
53031 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
53032 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
53033 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
53034 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
53035 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
53036 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
53037 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
53038 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
53039 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
53040 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
53041 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53042 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
53043 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
53044 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53045 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53046 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
53047 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
53048 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
53049 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
53050 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
53051 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
53052 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53053 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
53054 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
53055 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53056 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53057 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
53058 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
53059 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53060 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
53061 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
53062 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53063 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
53064 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
53065 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53066 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
53067 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
53068 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
53069 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53070 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
53071 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53072 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
53073 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
53074 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53075 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
53076 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
53077 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
53078 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53079 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
53080 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
53081 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
53082 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53083 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
53084 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
53085 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53086 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
53087 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
53088 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
53089 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
53090 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
53091 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53092 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
53093 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
53094 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
53095 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
53096 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
53097 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
53098 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
53099 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
53100 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53101 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
53102 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
53103 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
53104 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
53105 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53106 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
53107 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
53108 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
53109 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53110 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
53111 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
53112 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
53113 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
53114 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
53115 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
53116 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53117 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
53118 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
53119 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
53120 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
53121 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
53122 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
53123 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
53124 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
53125 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53126 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53127 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53128 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
53129 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
53130 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
53131 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
53132 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
53133 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53134 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
53135 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
53136 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
53137 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
53138 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
53139 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
53140 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53141 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
53142 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
53143 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
53144 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
53145 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
53146 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
53147 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53148 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53149 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
53150 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
53151 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
53152 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53153 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
53154 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
53155 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
53156 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
53157 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
53158 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
53159 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
53160 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
53161 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
53162 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
53163 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
53164 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
53165 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
53166 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
53167 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
53168 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
53169 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53170 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
53171 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
53172 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
53173 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53174 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
53175 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
53176 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
53177 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53178 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
53179 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53180 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
53181 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
53182 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
53183 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
53184 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
53185 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53186 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
53187 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
53188 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
53189 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
53190 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53191 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
53192 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53193 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
53194 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
53195 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
53196 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53197 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
53198 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53199 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
53200 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
53201 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
53202 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53203 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
53204 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
53205 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
53206 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
53207 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
53208 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
53209 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53210 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
53211 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
53212 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
53213 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
53214 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
53215 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
53216 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
53217 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
53218 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
53219 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
53220 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
53221 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
53222 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
53223 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
53224 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
53225 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
53226 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
53227 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
53228 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
53229 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53230 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
53231 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
53232 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
53233 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
53234 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
53235 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
53236 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
53237 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
53238 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
53239 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
53240 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
53241 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
53242 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
53243 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
53244 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
53245 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53246 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53247 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53248 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
53249 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
53250 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
53251 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
53252 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
53253 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
53254 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
53255 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
53256 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
53257 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
53258 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53259 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
53260 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
53261 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
53262 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
53263 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
53264 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
53265 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
53266 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
53267 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
53268 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
53269 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
53270 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
53271 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
53272 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
53273 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
53274 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
53275 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
53276 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
53277 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
53278 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
53279 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
53280 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53281 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
53282 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
53283 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
53284 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
53285 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
53286 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53287 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
53288 { (char *)"AcceleratorTable_Ok", (PyCFunction)_wrap_AcceleratorTable_Ok, METH_O, NULL},
53289 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
53290 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
53291 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
53292 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
53293 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
53294 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
53295 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
53296 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
53297 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
53298 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
53299 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
53300 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
53301 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
53302 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
53303 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
53304 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53305 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
53306 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
53307 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
53308 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
53309 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53310 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
53311 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
53312 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
53313 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
53314 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
53315 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53316 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
53317 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
53318 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53319 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53320 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53321 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
53322 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53323 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53324 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
53325 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
53326 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
53327 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
53328 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
53329 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
53330 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53331 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
53332 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
53333 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
53334 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
53335 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
53336 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
53337 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
53338 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
53339 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
53340 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
53341 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
53342 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
53343 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
53344 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
53345 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
53346 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
53347 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
53348 { (char *)"Window_GetBestFittingSize", (PyCFunction)_wrap_Window_GetBestFittingSize, METH_O, NULL},
53349 { (char *)"Window_GetAdjustedBestSize", (PyCFunction)_wrap_Window_GetAdjustedBestSize, METH_O, NULL},
53350 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
53351 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
53352 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
53353 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
53354 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53355 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53356 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53357 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53358 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
53359 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
53360 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53361 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
53362 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
53363 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
53364 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
53365 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
53366 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
53367 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53368 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
53369 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
53370 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
53371 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53372 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
53373 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53374 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
53375 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
53376 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
53377 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53378 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
53379 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53380 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
53381 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53382 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
53383 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
53384 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53385 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
53386 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
53387 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
53388 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
53389 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
53390 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
53391 { (char *)"Window_GetDefaultItem", (PyCFunction)_wrap_Window_GetDefaultItem, METH_O, NULL},
53392 { (char *)"Window_SetDefaultItem", (PyCFunction) _wrap_Window_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
53393 { (char *)"Window_SetTmpDefaultItem", (PyCFunction) _wrap_Window_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
53394 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
53395 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53396 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53397 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
53398 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
53399 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
53400 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
53401 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
53402 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
53403 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
53404 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
53405 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
53406 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
53407 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53408 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53409 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53410 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53411 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
53412 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
53413 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
53414 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
53415 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
53416 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
53417 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53418 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
53419 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
53420 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
53421 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
53422 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
53423 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
53424 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
53425 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
53426 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
53427 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
53428 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
53429 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
53430 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
53431 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
53432 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
53433 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
53434 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
53435 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
53436 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
53437 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
53438 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
53439 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
53440 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
53441 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
53442 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53443 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
53444 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
53445 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
53446 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53447 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53448 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53449 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53450 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
53451 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
53452 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
53453 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
53454 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53455 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
53456 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
53457 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
53458 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
53459 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
53460 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
53461 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
53462 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
53463 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
53464 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
53465 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
53466 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
53467 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
53468 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
53469 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
53470 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
53471 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
53472 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
53473 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
53474 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
53475 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
53476 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
53477 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53478 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
53479 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
53480 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
53481 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
53482 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
53483 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
53484 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
53485 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
53486 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
53487 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53488 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
53489 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
53490 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
53491 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
53492 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
53493 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
53494 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
53495 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
53496 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
53497 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
53498 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
53499 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
53500 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
53501 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
53502 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
53503 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
53504 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
53505 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
53506 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
53507 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
53508 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53509 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
53510 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
53511 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53512 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
53513 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
53514 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
53515 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
53516 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
53517 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
53518 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
53519 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53520 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
53521 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
53522 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
53523 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
53524 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
53525 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
53526 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
53527 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
53528 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53529 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
53530 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
53531 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
53532 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
53533 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
53534 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53535 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
53536 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
53537 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
53538 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53539 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
53540 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53541 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53542 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53543 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53544 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
53545 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
53546 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
53547 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
53548 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53549 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
53550 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53551 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53552 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53553 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
53554 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
53555 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53556 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53557 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53558 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53559 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
53560 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
53561 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
53562 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
53563 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
53564 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
53565 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
53566 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
53567 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
53568 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
53569 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53570 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53571 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53572 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53573 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
53574 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53575 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53576 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53577 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53578 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
53579 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
53580 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53581 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
53582 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53583 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
53584 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
53585 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
53586 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
53587 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
53588 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
53589 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
53590 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
53591 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
53592 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
53593 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
53594 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
53595 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53596 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53597 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
53598 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53599 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
53600 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53601 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
53602 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
53603 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
53604 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
53605 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
53606 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
53607 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53608 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53609 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53610 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
53611 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53612 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53613 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53614 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53615 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53616 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
53617 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
53618 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
53619 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
53620 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53621 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
53622 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
53623 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
53624 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
53625 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
53626 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
53627 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53628 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53629 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
53630 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
53631 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
53632 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
53633 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
53634 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
53635 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
53636 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
53637 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
53638 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
53639 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
53640 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53641 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
53642 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53643 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
53644 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53645 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
53646 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
53647 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
53648 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
53649 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
53650 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
53651 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53652 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
53653 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
53654 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
53655 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
53656 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
53657 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53658 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
53659 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
53660 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53661 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
53662 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
53663 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
53664 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
53665 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
53666 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
53667 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
53668 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
53669 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
53670 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
53671 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
53672 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53673 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
53674 { (char *)"Control_GetLabel", (PyCFunction)_wrap_Control_GetLabel, METH_O, NULL},
53675 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
53676 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
53677 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
53678 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53679 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
53680 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53681 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
53682 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
53683 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53684 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53685 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
53686 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
53687 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
53688 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
53689 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
53690 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
53691 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
53692 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
53693 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
53694 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
53695 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
53696 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
53697 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
53698 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
53699 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
53700 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53701 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
53702 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53703 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
53704 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
53705 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
53706 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
53707 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
53708 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
53709 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
53710 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
53711 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
53712 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
53713 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
53714 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
53715 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
53716 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
53717 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
53718 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
53719 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
53720 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
53721 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53722 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
53723 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
53724 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
53725 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
53726 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53727 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
53728 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53729 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
53730 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
53731 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53732 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
53733 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
53734 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
53735 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
53736 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
53737 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
53738 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
53739 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53740 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
53741 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53742 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
53743 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53744 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
53745 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
53746 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53747 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
53748 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
53749 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
53750 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
53751 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53752 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
53753 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
53754 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
53755 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
53756 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
53757 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
53758 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
53759 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
53760 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53761 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53762 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
53763 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
53764 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
53765 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53766 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
53767 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
53768 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
53769 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
53770 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53771 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
53772 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
53773 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53774 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
53775 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
53776 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
53777 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
53778 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53779 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
53780 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
53781 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
53782 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53783 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
53784 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
53785 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
53786 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
53787 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
53788 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
53789 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
53790 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
53791 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
53792 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
53793 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53794 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
53795 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
53796 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
53797 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
53798 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
53799 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
53800 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
53801 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
53802 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
53803 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
53804 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
53805 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
53806 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
53807 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
53808 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
53809 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
53810 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
53811 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
53812 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
53813 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
53814 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
53815 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
53816 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
53817 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
53818 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
53819 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53820 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
53821 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
53822 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
53823 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
53824 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
53825 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53826 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53827 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53828 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
53829 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
53830 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
53831 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
53832 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
53833 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
53834 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
53835 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
53836 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
53837 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53838 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53839 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53840 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
53841 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
53842 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
53843 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
53844 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
53845 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53846 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53847 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
53848 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
53849 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
53850 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
53851 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
53852 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
53853 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
53854 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
53855 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
53856 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53857 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
53858 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
53859 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53860 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
53861 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
53862 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
53863 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
53864 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
53865 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
53866 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
53867 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
53868 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
53869 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
53870 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53871 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53872 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
53873 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
53874 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
53875 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
53876 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53877 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
53878 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
53879 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
53880 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
53881 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
53882 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
53883 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
53884 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
53885 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
53886 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
53887 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
53888 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
53889 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
53890 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
53891 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
53892 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
53893 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
53894 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
53895 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
53896 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
53897 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
53898 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
53899 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
53900 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
53901 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
53902 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
53903 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
53904 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
53905 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
53906 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
53907 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
53908 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
53909 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
53910 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
53911 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
53912 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
53913 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
53914 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
53915 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
53916 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
53917 { NULL, NULL, 0, NULL }
53918 };
53919
53920
53921 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
53922
53923 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
53924 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
53925 }
53926 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
53927 return (void *)((wxSizer *) ((wxBoxSizer *) x));
53928 }
53929 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
53930 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
53931 }
53932 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
53933 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
53934 }
53935 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
53936 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
53937 }
53938 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
53939 return (void *)((wxSizer *) ((wxGridSizer *) x));
53940 }
53941 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
53942 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
53943 }
53944 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
53945 return (void *)((wxSizer *) ((wxPySizer *) x));
53946 }
53947 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
53948 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
53949 }
53950 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
53951 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
53952 }
53953 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
53954 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
53955 }
53956 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
53957 return (void *)((wxEvent *) ((wxMenuEvent *) x));
53958 }
53959 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
53960 return (void *)((wxEvent *) ((wxCloseEvent *) x));
53961 }
53962 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
53963 return (void *)((wxEvent *) ((wxMouseEvent *) x));
53964 }
53965 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
53966 return (void *)((wxEvent *) ((wxEraseEvent *) x));
53967 }
53968 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
53969 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
53970 }
53971 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
53972 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
53973 }
53974 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
53975 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
53976 }
53977 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
53978 return (void *)((wxEvent *) ((wxPyEvent *) x));
53979 }
53980 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
53981 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
53982 }
53983 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
53984 return (void *)((wxEvent *) ((wxIdleEvent *) x));
53985 }
53986 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
53987 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
53988 }
53989 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
53990 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
53991 }
53992 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
53993 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
53994 }
53995 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
53996 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
53997 }
53998 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
53999 return (void *)((wxEvent *) ((wxActivateEvent *) x));
54000 }
54001 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
54002 return (void *)((wxEvent *) ((wxSizeEvent *) x));
54003 }
54004 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
54005 return (void *)((wxEvent *) ((wxMoveEvent *) x));
54006 }
54007 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
54008 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
54009 }
54010 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
54011 return (void *)((wxEvent *) ((wxPaintEvent *) x));
54012 }
54013 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
54014 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
54015 }
54016 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
54017 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
54018 }
54019 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
54020 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
54021 }
54022 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
54023 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
54024 }
54025 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
54026 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
54027 }
54028 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
54029 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
54030 }
54031 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
54032 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
54033 }
54034 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
54035 return (void *)((wxEvent *) ((wxFocusEvent *) x));
54036 }
54037 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
54038 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
54039 }
54040 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
54041 return (void *)((wxEvent *) ((wxShowEvent *) x));
54042 }
54043 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
54044 return (void *)((wxEvent *) ((wxCommandEvent *) x));
54045 }
54046 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
54047 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
54048 }
54049 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
54050 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54051 }
54052 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
54053 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
54054 }
54055 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
54056 return (void *)((wxEvent *) ((wxKeyEvent *) x));
54057 }
54058 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
54059 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
54060 }
54061 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
54062 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
54063 }
54064 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
54065 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
54066 }
54067 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
54068 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
54069 }
54070 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
54071 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
54072 }
54073 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
54074 return (void *)((wxControl *) ((wxControlWithItems *) x));
54075 }
54076 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
54077 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
54078 }
54079 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
54080 return (void *)((wxEvtHandler *) ((wxWindow *) x));
54081 }
54082 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
54083 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
54084 }
54085 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
54086 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
54087 }
54088 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
54089 return (void *)((wxEvtHandler *) ((wxValidator *) x));
54090 }
54091 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
54092 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
54093 }
54094 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
54095 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
54096 }
54097 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
54098 return (void *)((wxEvtHandler *) ((wxMenu *) x));
54099 }
54100 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
54101 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
54102 }
54103 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
54104 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
54105 }
54106 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
54107 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
54108 }
54109 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
54110 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
54111 }
54112 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
54113 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
54114 }
54115 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
54116 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54117 }
54118 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
54119 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
54120 }
54121 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
54122 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
54123 }
54124 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
54125 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
54126 }
54127 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
54128 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54129 }
54130 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
54131 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54132 }
54133 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
54134 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
54135 }
54136 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
54137 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
54138 }
54139 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
54140 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
54141 }
54142 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
54143 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
54144 }
54145 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
54146 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
54147 }
54148 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
54149 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
54150 }
54151 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
54152 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
54153 }
54154 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
54155 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
54156 }
54157 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
54158 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
54159 }
54160 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
54161 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
54162 }
54163 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
54164 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
54165 }
54166 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
54167 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
54168 }
54169 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
54170 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
54171 }
54172 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
54173 return (void *)((wxObject *) ((wxSizerItem *) x));
54174 }
54175 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
54176 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
54177 }
54178 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
54179 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
54180 }
54181 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
54182 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
54183 }
54184 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
54185 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
54186 }
54187 static void *_p_wxSizerTo_p_wxObject(void *x) {
54188 return (void *)((wxObject *) ((wxSizer *) x));
54189 }
54190 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
54191 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
54192 }
54193 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
54194 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
54195 }
54196 static void *_p_wxEventTo_p_wxObject(void *x) {
54197 return (void *)((wxObject *) ((wxEvent *) x));
54198 }
54199 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
54200 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
54201 }
54202 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
54203 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
54204 }
54205 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
54206 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
54207 }
54208 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
54209 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
54210 }
54211 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
54212 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
54213 }
54214 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
54215 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
54216 }
54217 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
54218 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
54219 }
54220 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
54221 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
54222 }
54223 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
54224 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
54225 }
54226 static void *_p_wxControlTo_p_wxObject(void *x) {
54227 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
54228 }
54229 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
54230 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
54231 }
54232 static void *_p_wxFSFileTo_p_wxObject(void *x) {
54233 return (void *)((wxObject *) ((wxFSFile *) x));
54234 }
54235 static void *_p_wxPySizerTo_p_wxObject(void *x) {
54236 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
54237 }
54238 static void *_p_wxPyEventTo_p_wxObject(void *x) {
54239 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
54240 }
54241 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
54242 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
54243 }
54244 static void *_p_wxShowEventTo_p_wxObject(void *x) {
54245 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
54246 }
54247 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
54248 return (void *)((wxObject *) ((wxMenuItem *) x));
54249 }
54250 static void *_p_wxDateEventTo_p_wxObject(void *x) {
54251 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
54252 }
54253 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
54254 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
54255 }
54256 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
54257 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
54258 }
54259 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
54260 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
54261 }
54262 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
54263 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
54264 }
54265 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
54266 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
54267 }
54268 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
54269 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
54270 }
54271 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
54272 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
54273 }
54274 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
54275 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
54276 }
54277 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
54278 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
54279 }
54280 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
54281 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
54282 }
54283 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
54284 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
54285 }
54286 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
54287 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
54288 }
54289 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
54290 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
54291 }
54292 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
54293 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54294 }
54295 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
54296 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54297 }
54298 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
54299 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
54300 }
54301 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
54302 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
54303 }
54304 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
54305 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
54306 }
54307 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
54308 return (void *)((wxObject *) ((wxImageHandler *) x));
54309 }
54310 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
54311 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
54312 }
54313 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
54314 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
54315 }
54316 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
54317 return (void *)((wxObject *) ((wxEvtHandler *) x));
54318 }
54319 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
54320 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54321 }
54322 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
54323 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
54324 }
54325 static void *_p_wxImageTo_p_wxObject(void *x) {
54326 return (void *)((wxObject *) ((wxImage *) x));
54327 }
54328 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
54329 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
54330 }
54331 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
54332 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54333 }
54334 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
54335 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
54336 }
54337 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
54338 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
54339 }
54340 static void *_p_wxWindowTo_p_wxObject(void *x) {
54341 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
54342 }
54343 static void *_p_wxMenuTo_p_wxObject(void *x) {
54344 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
54345 }
54346 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
54347 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
54348 }
54349 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
54350 return (void *)((wxObject *) ((wxFileSystem *) x));
54351 }
54352 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
54353 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
54354 }
54355 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
54356 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
54357 }
54358 static void *_p_wxPyAppTo_p_wxObject(void *x) {
54359 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
54360 }
54361 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
54362 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
54363 }
54364 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
54365 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
54366 }
54367 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
54368 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
54369 }
54370 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
54371 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
54372 }
54373 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
54374 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
54375 }
54376 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
54377 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
54378 }
54379 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
54380 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
54381 }
54382 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
54383 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
54384 }
54385 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
54386 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
54387 }
54388 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
54389 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
54390 }
54391 static void *_p_wxValidatorTo_p_wxObject(void *x) {
54392 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
54393 }
54394 static void *_p_wxControlTo_p_wxWindow(void *x) {
54395 return (void *)((wxWindow *) ((wxControl *) x));
54396 }
54397 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
54398 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
54399 }
54400 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
54401 return (void *)((wxWindow *) ((wxMenuBar *) x));
54402 }
54403 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
54404 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
54405 }
54406 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
54407 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
54408 }
54409 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
54410 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
54411 }
54412 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
54413 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
54414 }
54415 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
54416 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
54417 }
54418 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
54419 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54420 }
54421 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
54422 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
54423 }
54424 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
54425 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
54426 }
54427 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
54428 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
54429 }
54430 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
54431 return (void *)((wxValidator *) ((wxPyValidator *) x));
54432 }
54433 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
54434 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
54435 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};
54436 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
54437 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
54438 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
54439 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
54440 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
54441 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
54442 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
54443 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
54444 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
54445 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
54446 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
54447 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
54448 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
54449 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
54450 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
54451 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
54452 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
54453 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
54454 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
54455 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
54456 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
54457 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
54458 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
54459 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
54460 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
54461 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
54462 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
54463 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
54464 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
54465 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
54466 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
54467 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
54468 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
54469 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
54470 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
54471 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
54472 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
54473 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
54474 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
54475 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
54476 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
54477 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
54478 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
54479 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
54480 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
54481 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
54482 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
54483 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
54484 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
54485 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
54486 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
54487 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
54488 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
54489 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
54490 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
54491 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
54492 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
54493 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
54494 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
54495 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
54496 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
54497 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
54498 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
54499 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
54500 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
54501 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
54502 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
54503 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
54504 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
54505 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
54506 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
54507 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
54508 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
54509 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
54510 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
54511 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
54512 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
54513 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
54514 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
54515 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
54516 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
54517 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
54518 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
54519 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
54520 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
54521 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
54522 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
54523 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
54524 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
54525 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
54526 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
54527 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
54528 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
54529 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
54530 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
54531 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
54532 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
54533 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
54534 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
54535 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
54536 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
54537 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
54538 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
54539 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
54540 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
54541 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
54542 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
54543 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
54544 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
54545 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
54546 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
54547 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
54548 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
54549 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
54550 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
54551 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
54552 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
54553 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
54554 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
54555 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
54556 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
54557 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
54558 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
54559 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
54560 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
54561 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
54562
54563 static swig_type_info *swig_type_initial[] = {
54564 &_swigt__p_buffer,
54565 &_swigt__p_char,
54566 &_swigt__p_form_ops_t,
54567 &_swigt__p_int,
54568 &_swigt__p_long,
54569 &_swigt__p_unsigned_char,
54570 &_swigt__p_unsigned_int,
54571 &_swigt__p_unsigned_long,
54572 &_swigt__p_wxANIHandler,
54573 &_swigt__p_wxAcceleratorEntry,
54574 &_swigt__p_wxAcceleratorTable,
54575 &_swigt__p_wxActivateEvent,
54576 &_swigt__p_wxAppTraits,
54577 &_swigt__p_wxArrayString,
54578 &_swigt__p_wxBMPHandler,
54579 &_swigt__p_wxBitmap,
54580 &_swigt__p_wxBoxSizer,
54581 &_swigt__p_wxButton,
54582 &_swigt__p_wxCURHandler,
54583 &_swigt__p_wxCaret,
54584 &_swigt__p_wxChildFocusEvent,
54585 &_swigt__p_wxCloseEvent,
54586 &_swigt__p_wxColour,
54587 &_swigt__p_wxCommandEvent,
54588 &_swigt__p_wxContextMenuEvent,
54589 &_swigt__p_wxControl,
54590 &_swigt__p_wxControlWithItems,
54591 &_swigt__p_wxCursor,
54592 &_swigt__p_wxDC,
54593 &_swigt__p_wxDateEvent,
54594 &_swigt__p_wxDateTime,
54595 &_swigt__p_wxDisplayChangedEvent,
54596 &_swigt__p_wxDropFilesEvent,
54597 &_swigt__p_wxDuplexMode,
54598 &_swigt__p_wxEraseEvent,
54599 &_swigt__p_wxEvent,
54600 &_swigt__p_wxEventLoop,
54601 &_swigt__p_wxEventLoopActivator,
54602 &_swigt__p_wxEvtHandler,
54603 &_swigt__p_wxFSFile,
54604 &_swigt__p_wxFileSystem,
54605 &_swigt__p_wxFileSystemHandler,
54606 &_swigt__p_wxFlexGridSizer,
54607 &_swigt__p_wxFocusEvent,
54608 &_swigt__p_wxFont,
54609 &_swigt__p_wxFrame,
54610 &_swigt__p_wxGBPosition,
54611 &_swigt__p_wxGBSizerItem,
54612 &_swigt__p_wxGBSpan,
54613 &_swigt__p_wxGIFHandler,
54614 &_swigt__p_wxGridBagSizer,
54615 &_swigt__p_wxGridSizer,
54616 &_swigt__p_wxICOHandler,
54617 &_swigt__p_wxIconizeEvent,
54618 &_swigt__p_wxIdleEvent,
54619 &_swigt__p_wxImage,
54620 &_swigt__p_wxImageHandler,
54621 &_swigt__p_wxImageHistogram,
54622 &_swigt__p_wxImage_HSVValue,
54623 &_swigt__p_wxImage_RGBValue,
54624 &_swigt__p_wxIndividualLayoutConstraint,
54625 &_swigt__p_wxInitDialogEvent,
54626 &_swigt__p_wxInputStream,
54627 &_swigt__p_wxInternetFSHandler,
54628 &_swigt__p_wxItemContainer,
54629 &_swigt__p_wxJPEGHandler,
54630 &_swigt__p_wxKeyEvent,
54631 &_swigt__p_wxLayoutConstraints,
54632 &_swigt__p_wxMaximizeEvent,
54633 &_swigt__p_wxMemoryFSHandler,
54634 &_swigt__p_wxMenu,
54635 &_swigt__p_wxMenuBar,
54636 &_swigt__p_wxMenuBarBase,
54637 &_swigt__p_wxMenuEvent,
54638 &_swigt__p_wxMenuItem,
54639 &_swigt__p_wxMouseCaptureChangedEvent,
54640 &_swigt__p_wxMouseEvent,
54641 &_swigt__p_wxMoveEvent,
54642 &_swigt__p_wxNavigationKeyEvent,
54643 &_swigt__p_wxNcPaintEvent,
54644 &_swigt__p_wxNotifyEvent,
54645 &_swigt__p_wxObject,
54646 &_swigt__p_wxOutputStream,
54647 &_swigt__p_wxPCXHandler,
54648 &_swigt__p_wxPNGHandler,
54649 &_swigt__p_wxPNMHandler,
54650 &_swigt__p_wxPaintEvent,
54651 &_swigt__p_wxPaletteChangedEvent,
54652 &_swigt__p_wxPaperSize,
54653 &_swigt__p_wxPoint,
54654 &_swigt__p_wxPoint2D,
54655 &_swigt__p_wxPropagateOnce,
54656 &_swigt__p_wxPropagationDisabler,
54657 &_swigt__p_wxPyApp,
54658 &_swigt__p_wxPyCommandEvent,
54659 &_swigt__p_wxPyDropTarget,
54660 &_swigt__p_wxPyEvent,
54661 &_swigt__p_wxPyFileSystemHandler,
54662 &_swigt__p_wxPyImageHandler,
54663 &_swigt__p_wxPyInputStream,
54664 &_swigt__p_wxPySizer,
54665 &_swigt__p_wxPyValidator,
54666 &_swigt__p_wxQuantize,
54667 &_swigt__p_wxQueryNewPaletteEvent,
54668 &_swigt__p_wxRealPoint,
54669 &_swigt__p_wxRect,
54670 &_swigt__p_wxRegion,
54671 &_swigt__p_wxScrollEvent,
54672 &_swigt__p_wxScrollWinEvent,
54673 &_swigt__p_wxSetCursorEvent,
54674 &_swigt__p_wxShowEvent,
54675 &_swigt__p_wxSize,
54676 &_swigt__p_wxSizeEvent,
54677 &_swigt__p_wxSizer,
54678 &_swigt__p_wxSizerItem,
54679 &_swigt__p_wxStaticBox,
54680 &_swigt__p_wxStaticBoxSizer,
54681 &_swigt__p_wxStdDialogButtonSizer,
54682 &_swigt__p_wxSysColourChangedEvent,
54683 &_swigt__p_wxTIFFHandler,
54684 &_swigt__p_wxToolTip,
54685 &_swigt__p_wxUpdateUIEvent,
54686 &_swigt__p_wxValidator,
54687 &_swigt__p_wxVisualAttributes,
54688 &_swigt__p_wxWindow,
54689 &_swigt__p_wxWindowCreateEvent,
54690 &_swigt__p_wxWindowDestroyEvent,
54691 &_swigt__p_wxXPMHandler,
54692 &_swigt__p_wxZipFSHandler,
54693 };
54694
54695 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
54696 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
54697 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
54698 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
54699 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
54700 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
54701 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
54702 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
54703 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
54704 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
54705 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
54706 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
54707 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
54708 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
54709 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}};
54710 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
54711 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}};
54712 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
54713 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}};
54714 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
54715 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
54716 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
54717 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
54718 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_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}};
54719 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
54720 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}};
54721 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
54722 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
54723 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
54724 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
54725 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
54726 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54727 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
54728 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
54729 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
54730 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_wxPyEvent, _p_wxPyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEvent, 0, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_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_wxDateEvent, _p_wxDateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_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}};
54731 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
54732 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
54733 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}};
54734 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
54735 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
54736 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}};
54737 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}};
54738 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
54739 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
54740 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
54741 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
54742 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
54743 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
54744 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
54745 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
54746 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}};
54747 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}};
54748 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
54749 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
54750 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
54751 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}};
54752 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
54753 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
54754 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
54755 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
54756 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
54757 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
54758 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
54759 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}};
54760 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
54761 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
54762 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
54763 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
54764 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
54765 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
54766 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
54767 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
54768 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
54769 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
54770 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54771 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
54772 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
54773 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
54774 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
54775 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
54776 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_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_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_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_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_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_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_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_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_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}};
54777 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
54778 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
54779 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
54780 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
54781 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
54782 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54783 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
54784 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
54785 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
54786 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
54787 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
54788 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
54789 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
54790 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
54791 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
54792 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
54793 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
54794 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
54795 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
54796 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
54797 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
54798 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
54799 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
54800 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
54801 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
54802 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
54803 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
54804 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
54805 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
54806 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
54807 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
54808 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}};
54809 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}};
54810 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
54811 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
54812 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
54813 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54814 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
54815 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
54816 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
54817 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}};
54818 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
54819 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}};
54820 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
54821 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
54822 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
54823 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
54824
54825 static swig_cast_info *swig_cast_initial[] = {
54826 _swigc__p_buffer,
54827 _swigc__p_char,
54828 _swigc__p_form_ops_t,
54829 _swigc__p_int,
54830 _swigc__p_long,
54831 _swigc__p_unsigned_char,
54832 _swigc__p_unsigned_int,
54833 _swigc__p_unsigned_long,
54834 _swigc__p_wxANIHandler,
54835 _swigc__p_wxAcceleratorEntry,
54836 _swigc__p_wxAcceleratorTable,
54837 _swigc__p_wxActivateEvent,
54838 _swigc__p_wxAppTraits,
54839 _swigc__p_wxArrayString,
54840 _swigc__p_wxBMPHandler,
54841 _swigc__p_wxBitmap,
54842 _swigc__p_wxBoxSizer,
54843 _swigc__p_wxButton,
54844 _swigc__p_wxCURHandler,
54845 _swigc__p_wxCaret,
54846 _swigc__p_wxChildFocusEvent,
54847 _swigc__p_wxCloseEvent,
54848 _swigc__p_wxColour,
54849 _swigc__p_wxCommandEvent,
54850 _swigc__p_wxContextMenuEvent,
54851 _swigc__p_wxControl,
54852 _swigc__p_wxControlWithItems,
54853 _swigc__p_wxCursor,
54854 _swigc__p_wxDC,
54855 _swigc__p_wxDateEvent,
54856 _swigc__p_wxDateTime,
54857 _swigc__p_wxDisplayChangedEvent,
54858 _swigc__p_wxDropFilesEvent,
54859 _swigc__p_wxDuplexMode,
54860 _swigc__p_wxEraseEvent,
54861 _swigc__p_wxEvent,
54862 _swigc__p_wxEventLoop,
54863 _swigc__p_wxEventLoopActivator,
54864 _swigc__p_wxEvtHandler,
54865 _swigc__p_wxFSFile,
54866 _swigc__p_wxFileSystem,
54867 _swigc__p_wxFileSystemHandler,
54868 _swigc__p_wxFlexGridSizer,
54869 _swigc__p_wxFocusEvent,
54870 _swigc__p_wxFont,
54871 _swigc__p_wxFrame,
54872 _swigc__p_wxGBPosition,
54873 _swigc__p_wxGBSizerItem,
54874 _swigc__p_wxGBSpan,
54875 _swigc__p_wxGIFHandler,
54876 _swigc__p_wxGridBagSizer,
54877 _swigc__p_wxGridSizer,
54878 _swigc__p_wxICOHandler,
54879 _swigc__p_wxIconizeEvent,
54880 _swigc__p_wxIdleEvent,
54881 _swigc__p_wxImage,
54882 _swigc__p_wxImageHandler,
54883 _swigc__p_wxImageHistogram,
54884 _swigc__p_wxImage_HSVValue,
54885 _swigc__p_wxImage_RGBValue,
54886 _swigc__p_wxIndividualLayoutConstraint,
54887 _swigc__p_wxInitDialogEvent,
54888 _swigc__p_wxInputStream,
54889 _swigc__p_wxInternetFSHandler,
54890 _swigc__p_wxItemContainer,
54891 _swigc__p_wxJPEGHandler,
54892 _swigc__p_wxKeyEvent,
54893 _swigc__p_wxLayoutConstraints,
54894 _swigc__p_wxMaximizeEvent,
54895 _swigc__p_wxMemoryFSHandler,
54896 _swigc__p_wxMenu,
54897 _swigc__p_wxMenuBar,
54898 _swigc__p_wxMenuBarBase,
54899 _swigc__p_wxMenuEvent,
54900 _swigc__p_wxMenuItem,
54901 _swigc__p_wxMouseCaptureChangedEvent,
54902 _swigc__p_wxMouseEvent,
54903 _swigc__p_wxMoveEvent,
54904 _swigc__p_wxNavigationKeyEvent,
54905 _swigc__p_wxNcPaintEvent,
54906 _swigc__p_wxNotifyEvent,
54907 _swigc__p_wxObject,
54908 _swigc__p_wxOutputStream,
54909 _swigc__p_wxPCXHandler,
54910 _swigc__p_wxPNGHandler,
54911 _swigc__p_wxPNMHandler,
54912 _swigc__p_wxPaintEvent,
54913 _swigc__p_wxPaletteChangedEvent,
54914 _swigc__p_wxPaperSize,
54915 _swigc__p_wxPoint,
54916 _swigc__p_wxPoint2D,
54917 _swigc__p_wxPropagateOnce,
54918 _swigc__p_wxPropagationDisabler,
54919 _swigc__p_wxPyApp,
54920 _swigc__p_wxPyCommandEvent,
54921 _swigc__p_wxPyDropTarget,
54922 _swigc__p_wxPyEvent,
54923 _swigc__p_wxPyFileSystemHandler,
54924 _swigc__p_wxPyImageHandler,
54925 _swigc__p_wxPyInputStream,
54926 _swigc__p_wxPySizer,
54927 _swigc__p_wxPyValidator,
54928 _swigc__p_wxQuantize,
54929 _swigc__p_wxQueryNewPaletteEvent,
54930 _swigc__p_wxRealPoint,
54931 _swigc__p_wxRect,
54932 _swigc__p_wxRegion,
54933 _swigc__p_wxScrollEvent,
54934 _swigc__p_wxScrollWinEvent,
54935 _swigc__p_wxSetCursorEvent,
54936 _swigc__p_wxShowEvent,
54937 _swigc__p_wxSize,
54938 _swigc__p_wxSizeEvent,
54939 _swigc__p_wxSizer,
54940 _swigc__p_wxSizerItem,
54941 _swigc__p_wxStaticBox,
54942 _swigc__p_wxStaticBoxSizer,
54943 _swigc__p_wxStdDialogButtonSizer,
54944 _swigc__p_wxSysColourChangedEvent,
54945 _swigc__p_wxTIFFHandler,
54946 _swigc__p_wxToolTip,
54947 _swigc__p_wxUpdateUIEvent,
54948 _swigc__p_wxValidator,
54949 _swigc__p_wxVisualAttributes,
54950 _swigc__p_wxWindow,
54951 _swigc__p_wxWindowCreateEvent,
54952 _swigc__p_wxWindowDestroyEvent,
54953 _swigc__p_wxXPMHandler,
54954 _swigc__p_wxZipFSHandler,
54955 };
54956
54957
54958 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
54959
54960 static swig_const_info swig_const_table[] = {
54961 {0, 0, 0, 0.0, 0, 0}};
54962
54963 #ifdef __cplusplus
54964 }
54965 #endif
54966 /* -----------------------------------------------------------------------------
54967 * Type initialization:
54968 * This problem is tough by the requirement that no dynamic
54969 * memory is used. Also, since swig_type_info structures store pointers to
54970 * swig_cast_info structures and swig_cast_info structures store pointers back
54971 * to swig_type_info structures, we need some lookup code at initialization.
54972 * The idea is that swig generates all the structures that are needed.
54973 * The runtime then collects these partially filled structures.
54974 * The SWIG_InitializeModule function takes these initial arrays out of
54975 * swig_module, and does all the lookup, filling in the swig_module.types
54976 * array with the correct data and linking the correct swig_cast_info
54977 * structures together.
54978 *
54979 * The generated swig_type_info structures are assigned staticly to an initial
54980 * array. We just loop though that array, and handle each type individually.
54981 * First we lookup if this type has been already loaded, and if so, use the
54982 * loaded structure instead of the generated one. Then we have to fill in the
54983 * cast linked list. The cast data is initially stored in something like a
54984 * two-dimensional array. Each row corresponds to a type (there are the same
54985 * number of rows as there are in the swig_type_initial array). Each entry in
54986 * a column is one of the swig_cast_info structures for that type.
54987 * The cast_initial array is actually an array of arrays, because each row has
54988 * a variable number of columns. So to actually build the cast linked list,
54989 * we find the array of casts associated with the type, and loop through it
54990 * adding the casts to the list. The one last trick we need to do is making
54991 * sure the type pointer in the swig_cast_info struct is correct.
54992 *
54993 * First off, we lookup the cast->type name to see if it is already loaded.
54994 * There are three cases to handle:
54995 * 1) If the cast->type has already been loaded AND the type we are adding
54996 * casting info to has not been loaded (it is in this module), THEN we
54997 * replace the cast->type pointer with the type pointer that has already
54998 * been loaded.
54999 * 2) If BOTH types (the one we are adding casting info to, and the
55000 * cast->type) are loaded, THEN the cast info has already been loaded by
55001 * the previous module so we just ignore it.
55002 * 3) Finally, if cast->type has not already been loaded, then we add that
55003 * swig_cast_info to the linked list (because the cast->type) pointer will
55004 * be correct.
55005 * ----------------------------------------------------------------------------- */
55006
55007 #ifdef __cplusplus
55008 extern "C" {
55009 #if 0
55010 } /* c-mode */
55011 #endif
55012 #endif
55013
55014 #if 0
55015 #define SWIGRUNTIME_DEBUG
55016 #endif
55017
55018 SWIGRUNTIME void
55019 SWIG_InitializeModule(void *clientdata) {
55020 size_t i;
55021 swig_module_info *module_head;
55022 static int init_run = 0;
55023
55024 clientdata = clientdata;
55025
55026 if (init_run) return;
55027 init_run = 1;
55028
55029 /* Initialize the swig_module */
55030 swig_module.type_initial = swig_type_initial;
55031 swig_module.cast_initial = swig_cast_initial;
55032
55033 /* Try and load any already created modules */
55034 module_head = SWIG_GetModule(clientdata);
55035 if (module_head) {
55036 swig_module.next = module_head->next;
55037 module_head->next = &swig_module;
55038 } else {
55039 /* This is the first module loaded */
55040 swig_module.next = &swig_module;
55041 SWIG_SetModule(clientdata, &swig_module);
55042 }
55043
55044 /* Now work on filling in swig_module.types */
55045 #ifdef SWIGRUNTIME_DEBUG
55046 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
55047 #endif
55048 for (i = 0; i < swig_module.size; ++i) {
55049 swig_type_info *type = 0;
55050 swig_type_info *ret;
55051 swig_cast_info *cast;
55052
55053 #ifdef SWIGRUNTIME_DEBUG
55054 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
55055 #endif
55056
55057 /* if there is another module already loaded */
55058 if (swig_module.next != &swig_module) {
55059 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
55060 }
55061 if (type) {
55062 /* Overwrite clientdata field */
55063 #ifdef SWIGRUNTIME_DEBUG
55064 printf("SWIG_InitializeModule: found type %s\n", type->name);
55065 #endif
55066 if (swig_module.type_initial[i]->clientdata) {
55067 type->clientdata = swig_module.type_initial[i]->clientdata;
55068 #ifdef SWIGRUNTIME_DEBUG
55069 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
55070 #endif
55071 }
55072 } else {
55073 type = swig_module.type_initial[i];
55074 }
55075
55076 /* Insert casting types */
55077 cast = swig_module.cast_initial[i];
55078 while (cast->type) {
55079 /* Don't need to add information already in the list */
55080 ret = 0;
55081 #ifdef SWIGRUNTIME_DEBUG
55082 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
55083 #endif
55084 if (swig_module.next != &swig_module) {
55085 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
55086 #ifdef SWIGRUNTIME_DEBUG
55087 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
55088 #endif
55089 }
55090 if (ret) {
55091 if (type == swig_module.type_initial[i]) {
55092 #ifdef SWIGRUNTIME_DEBUG
55093 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
55094 #endif
55095 cast->type = ret;
55096 ret = 0;
55097 } else {
55098 /* Check for casting already in the list */
55099 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
55100 #ifdef SWIGRUNTIME_DEBUG
55101 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
55102 #endif
55103 if (!ocast) ret = 0;
55104 }
55105 }
55106
55107 if (!ret) {
55108 #ifdef SWIGRUNTIME_DEBUG
55109 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
55110 #endif
55111 if (type->cast) {
55112 type->cast->prev = cast;
55113 cast->next = type->cast;
55114 }
55115 type->cast = cast;
55116 }
55117 cast++;
55118 }
55119 /* Set entry in modules->types array equal to the type */
55120 swig_module.types[i] = type;
55121 }
55122 swig_module.types[i] = 0;
55123
55124 #ifdef SWIGRUNTIME_DEBUG
55125 printf("**** SWIG_InitializeModule: Cast List ******\n");
55126 for (i = 0; i < swig_module.size; ++i) {
55127 int j = 0;
55128 swig_cast_info *cast = swig_module.cast_initial[i];
55129 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
55130 while (cast->type) {
55131 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
55132 cast++;
55133 ++j;
55134 }
55135 printf("---- Total casts: %d\n",j);
55136 }
55137 printf("**** SWIG_InitializeModule: Cast List ******\n");
55138 #endif
55139 }
55140
55141 /* This function will propagate the clientdata field of type to
55142 * any new swig_type_info structures that have been added into the list
55143 * of equivalent types. It is like calling
55144 * SWIG_TypeClientData(type, clientdata) a second time.
55145 */
55146 SWIGRUNTIME void
55147 SWIG_PropagateClientData(void) {
55148 size_t i;
55149 swig_cast_info *equiv;
55150 static int init_run = 0;
55151
55152 if (init_run) return;
55153 init_run = 1;
55154
55155 for (i = 0; i < swig_module.size; i++) {
55156 if (swig_module.types[i]->clientdata) {
55157 equiv = swig_module.types[i]->cast;
55158 while (equiv) {
55159 if (!equiv->converter) {
55160 if (equiv->type && !equiv->type->clientdata)
55161 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
55162 }
55163 equiv = equiv->next;
55164 }
55165 }
55166 }
55167 }
55168
55169 #ifdef __cplusplus
55170 #if 0
55171 {
55172 /* c-mode */
55173 #endif
55174 }
55175 #endif
55176
55177
55178
55179 #ifdef __cplusplus
55180 extern "C" {
55181 #endif
55182
55183 /* Python-specific SWIG API */
55184 #define SWIG_newvarlink() SWIG_Python_newvarlink()
55185 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
55186 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
55187
55188 /* -----------------------------------------------------------------------------
55189 * global variable support code.
55190 * ----------------------------------------------------------------------------- */
55191
55192 typedef struct swig_globalvar {
55193 char *name; /* Name of global variable */
55194 PyObject *(*get_attr)(void); /* Return the current value */
55195 int (*set_attr)(PyObject *); /* Set the value */
55196 struct swig_globalvar *next;
55197 } swig_globalvar;
55198
55199 typedef struct swig_varlinkobject {
55200 PyObject_HEAD
55201 swig_globalvar *vars;
55202 } swig_varlinkobject;
55203
55204 SWIGINTERN PyObject *
55205 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
55206 return PyString_FromString("<Swig global variables>");
55207 }
55208
55209 SWIGINTERN PyObject *
55210 swig_varlink_str(swig_varlinkobject *v) {
55211 PyObject *str = PyString_FromString("(");
55212 swig_globalvar *var;
55213 for (var = v->vars; var; var=var->next) {
55214 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
55215 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
55216 }
55217 PyString_ConcatAndDel(&str,PyString_FromString(")"));
55218 return str;
55219 }
55220
55221 SWIGINTERN int
55222 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
55223 PyObject *str = swig_varlink_str(v);
55224 fprintf(fp,"Swig global variables ");
55225 fprintf(fp,"%s\n", PyString_AsString(str));
55226 Py_DECREF(str);
55227 return 0;
55228 }
55229
55230 SWIGINTERN void
55231 swig_varlink_dealloc(swig_varlinkobject *v) {
55232 swig_globalvar *var = v->vars;
55233 while (var) {
55234 swig_globalvar *n = var->next;
55235 free(var->name);
55236 free(var);
55237 var = n;
55238 }
55239 }
55240
55241 SWIGINTERN PyObject *
55242 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
55243 PyObject *res = NULL;
55244 swig_globalvar *var = v->vars;
55245 while (var) {
55246 if (strcmp(var->name,n) == 0) {
55247 res = (*var->get_attr)();
55248 break;
55249 }
55250 var = var->next;
55251 }
55252 if (res == NULL && !PyErr_Occurred()) {
55253 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55254 }
55255 return res;
55256 }
55257
55258 SWIGINTERN int
55259 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
55260 int res = 1;
55261 swig_globalvar *var = v->vars;
55262 while (var) {
55263 if (strcmp(var->name,n) == 0) {
55264 res = (*var->set_attr)(p);
55265 break;
55266 }
55267 var = var->next;
55268 }
55269 if (res == 1 && !PyErr_Occurred()) {
55270 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55271 }
55272 return res;
55273 }
55274
55275 SWIGINTERN PyTypeObject*
55276 swig_varlink_type(void) {
55277 static char varlink__doc__[] = "Swig var link object";
55278 static PyTypeObject varlink_type;
55279 static int type_init = 0;
55280 if (!type_init) {
55281 const PyTypeObject tmp
55282 = {
55283 PyObject_HEAD_INIT(NULL)
55284 0, /* Number of items in variable part (ob_size) */
55285 (char *)"swigvarlink", /* Type name (tp_name) */
55286 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
55287 0, /* Itemsize (tp_itemsize) */
55288 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
55289 (printfunc) swig_varlink_print, /* Print (tp_print) */
55290 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
55291 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
55292 0, /* tp_compare */
55293 (reprfunc) swig_varlink_repr, /* tp_repr */
55294 0, /* tp_as_number */
55295 0, /* tp_as_sequence */
55296 0, /* tp_as_mapping */
55297 0, /* tp_hash */
55298 0, /* tp_call */
55299 (reprfunc)swig_varlink_str, /* tp_str */
55300 0, /* tp_getattro */
55301 0, /* tp_setattro */
55302 0, /* tp_as_buffer */
55303 0, /* tp_flags */
55304 varlink__doc__, /* tp_doc */
55305 0, /* tp_traverse */
55306 0, /* tp_clear */
55307 0, /* tp_richcompare */
55308 0, /* tp_weaklistoffset */
55309 #if PY_VERSION_HEX >= 0x02020000
55310 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
55311 #endif
55312 #if PY_VERSION_HEX >= 0x02030000
55313 0, /* tp_del */
55314 #endif
55315 #ifdef COUNT_ALLOCS
55316 0,0,0,0 /* tp_alloc -> tp_next */
55317 #endif
55318 };
55319 varlink_type = tmp;
55320 varlink_type.ob_type = &PyType_Type;
55321 type_init = 1;
55322 }
55323 return &varlink_type;
55324 }
55325
55326 /* Create a variable linking object for use later */
55327 SWIGINTERN PyObject *
55328 SWIG_Python_newvarlink(void) {
55329 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
55330 if (result) {
55331 result->vars = 0;
55332 }
55333 return ((PyObject*) result);
55334 }
55335
55336 SWIGINTERN void
55337 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
55338 swig_varlinkobject *v = (swig_varlinkobject *) p;
55339 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
55340 if (gv) {
55341 size_t size = strlen(name)+1;
55342 gv->name = (char *)malloc(size);
55343 if (gv->name) {
55344 strncpy(gv->name,name,size);
55345 gv->get_attr = get_attr;
55346 gv->set_attr = set_attr;
55347 gv->next = v->vars;
55348 }
55349 }
55350 v->vars = gv;
55351 }
55352
55353 SWIGINTERN PyObject *
55354 SWIG_globals() {
55355 static PyObject *_SWIG_globals = 0;
55356 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
55357 return _SWIG_globals;
55358 }
55359
55360 /* -----------------------------------------------------------------------------
55361 * constants/methods manipulation
55362 * ----------------------------------------------------------------------------- */
55363
55364 /* Install Constants */
55365 SWIGINTERN void
55366 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
55367 PyObject *obj = 0;
55368 size_t i;
55369 for (i = 0; constants[i].type; ++i) {
55370 switch(constants[i].type) {
55371 case SWIG_PY_POINTER:
55372 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
55373 break;
55374 case SWIG_PY_BINARY:
55375 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
55376 break;
55377 default:
55378 obj = 0;
55379 break;
55380 }
55381 if (obj) {
55382 PyDict_SetItemString(d, constants[i].name, obj);
55383 Py_DECREF(obj);
55384 }
55385 }
55386 }
55387
55388 /* -----------------------------------------------------------------------------*/
55389 /* Fix SwigMethods to carry the callback ptrs when needed */
55390 /* -----------------------------------------------------------------------------*/
55391
55392 SWIGINTERN void
55393 SWIG_Python_FixMethods(PyMethodDef *methods,
55394 swig_const_info *const_table,
55395 swig_type_info **types,
55396 swig_type_info **types_initial) {
55397 size_t i;
55398 for (i = 0; methods[i].ml_name; ++i) {
55399 char *c = methods[i].ml_doc;
55400 if (c && (c = strstr(c, "swig_ptr: "))) {
55401 int j;
55402 swig_const_info *ci = 0;
55403 char *name = c + 10;
55404 for (j = 0; const_table[j].type; ++j) {
55405 if (strncmp(const_table[j].name, name,
55406 strlen(const_table[j].name)) == 0) {
55407 ci = &(const_table[j]);
55408 break;
55409 }
55410 }
55411 if (ci) {
55412 size_t shift = (ci->ptype) - types;
55413 swig_type_info *ty = types_initial[shift];
55414 size_t ldoc = (c - methods[i].ml_doc);
55415 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
55416 char *ndoc = (char*)malloc(ldoc + lptr + 10);
55417 if (ndoc) {
55418 char *buff = ndoc;
55419 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
55420 if (ptr) {
55421 strncpy(buff, methods[i].ml_doc, ldoc);
55422 buff += ldoc;
55423 strncpy(buff, "swig_ptr: ", 10);
55424 buff += 10;
55425 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
55426 methods[i].ml_doc = ndoc;
55427 }
55428 }
55429 }
55430 }
55431 }
55432 }
55433
55434 #ifdef __cplusplus
55435 }
55436 #endif
55437
55438 /* -----------------------------------------------------------------------------*
55439 * Partial Init method
55440 * -----------------------------------------------------------------------------*/
55441
55442 #ifdef __cplusplus
55443 extern "C"
55444 #endif
55445 SWIGEXPORT void SWIG_init(void) {
55446 PyObject *m, *d;
55447
55448 /* Fix SwigMethods to carry the callback ptrs when needed */
55449 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
55450
55451 m = Py_InitModule((char *) SWIG_name, SwigMethods);
55452 d = PyModule_GetDict(m);
55453
55454 SWIG_InitializeModule(0);
55455 SWIG_InstallConstants(d,swig_const_table);
55456
55457
55458
55459 #ifndef wxPyUSE_EXPORT
55460 // Make our API structure a CObject so other modules can import it
55461 // from this module.
55462 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
55463 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
55464 Py_XDECREF(cobj);
55465 #endif
55466
55467 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
55468 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
55469 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
55470 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
55471 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
55472 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
55473 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
55474 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
55475 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
55476 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
55477 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
55478 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
55479 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
55480 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
55481 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
55482 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
55483 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
55484 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
55485 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
55486 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
55487 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
55488 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
55489 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
55490 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
55491 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
55492 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
55493 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
55494 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
55495 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
55496 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
55497 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
55498 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
55499 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
55500 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
55501 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
55502 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
55503 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
55504 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
55505 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
55506 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
55507 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
55508 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
55509 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
55510 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
55511 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
55512 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
55513 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
55514 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
55515 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
55516 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
55517 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
55518 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
55519 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
55520 SWIG_Python_SetConstant(d, "ST_DOTS_MIDDLE",SWIG_From_int(static_cast< int >(wxST_DOTS_MIDDLE)));
55521 SWIG_Python_SetConstant(d, "ST_DOTS_END",SWIG_From_int(static_cast< int >(wxST_DOTS_END)));
55522 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
55523 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
55524 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
55525 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
55526 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
55527 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
55528 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
55529 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
55530 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
55531 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
55532 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
55533 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
55534 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
55535 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
55536 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
55537 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
55538 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
55539 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
55540 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
55541 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
55542 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
55543 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
55544 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
55545 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
55546 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
55547 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
55548 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
55549 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
55550 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
55551 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
55552 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
55553 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
55554 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
55555 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
55556 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
55557 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
55558 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
55559 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
55560 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
55561 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
55562 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
55563 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
55564 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
55565 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
55566 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
55567 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
55568 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
55569 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
55570 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
55571 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
55572 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
55573 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
55574 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
55575 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
55576 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
55577 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
55578 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
55579 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
55580 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
55581 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
55582 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
55583 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
55584 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
55585 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
55586 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
55587 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
55588 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
55589 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
55590 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
55591 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
55592 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
55593 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
55594 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
55595 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
55596 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
55597 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
55598 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
55599 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
55600 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
55601 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
55602 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
55603 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
55604 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
55605 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
55606 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
55607 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
55608 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
55609 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
55610 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
55611 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
55612 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
55613 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
55614 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
55615 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
55616 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
55617 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
55618 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
55619 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
55620 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
55621 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
55622 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
55623 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
55624 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
55625 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
55626 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
55627 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
55628 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
55629 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
55630 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
55631 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
55632 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
55633 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
55634 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
55635 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
55636 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
55637 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
55638 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
55639 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
55640 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
55641 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
55642 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
55643 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
55644 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
55645 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
55646 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
55647 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
55648 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
55649 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
55650 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
55651 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
55652 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
55653 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
55654 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
55655 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
55656 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
55657 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
55658 SWIG_Python_SetConstant(d, "OPEN",SWIG_From_int(static_cast< int >(wxOPEN)));
55659 SWIG_Python_SetConstant(d, "SAVE",SWIG_From_int(static_cast< int >(wxSAVE)));
55660 SWIG_Python_SetConstant(d, "HIDE_READONLY",SWIG_From_int(static_cast< int >(wxHIDE_READONLY)));
55661 SWIG_Python_SetConstant(d, "OVERWRITE_PROMPT",SWIG_From_int(static_cast< int >(wxOVERWRITE_PROMPT)));
55662 SWIG_Python_SetConstant(d, "FILE_MUST_EXIST",SWIG_From_int(static_cast< int >(wxFILE_MUST_EXIST)));
55663 SWIG_Python_SetConstant(d, "MULTIPLE",SWIG_From_int(static_cast< int >(wxMULTIPLE)));
55664 SWIG_Python_SetConstant(d, "CHANGE_DIR",SWIG_From_int(static_cast< int >(wxCHANGE_DIR)));
55665 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
55666 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
55667 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
55668 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
55669 SWIG_Python_SetConstant(d, "PD_AUTO_HIDE",SWIG_From_int(static_cast< int >(wxPD_AUTO_HIDE)));
55670 SWIG_Python_SetConstant(d, "PD_APP_MODAL",SWIG_From_int(static_cast< int >(wxPD_APP_MODAL)));
55671 SWIG_Python_SetConstant(d, "PD_CAN_ABORT",SWIG_From_int(static_cast< int >(wxPD_CAN_ABORT)));
55672 SWIG_Python_SetConstant(d, "PD_ELAPSED_TIME",SWIG_From_int(static_cast< int >(wxPD_ELAPSED_TIME)));
55673 SWIG_Python_SetConstant(d, "PD_ESTIMATED_TIME",SWIG_From_int(static_cast< int >(wxPD_ESTIMATED_TIME)));
55674 SWIG_Python_SetConstant(d, "PD_REMAINING_TIME",SWIG_From_int(static_cast< int >(wxPD_REMAINING_TIME)));
55675 SWIG_Python_SetConstant(d, "PD_SMOOTH",SWIG_From_int(static_cast< int >(wxPD_SMOOTH)));
55676 SWIG_Python_SetConstant(d, "PD_CAN_SKIP",SWIG_From_int(static_cast< int >(wxPD_CAN_SKIP)));
55677 SWIG_Python_SetConstant(d, "DD_NEW_DIR_BUTTON",SWIG_From_int(static_cast< int >(wxDD_NEW_DIR_BUTTON)));
55678 SWIG_Python_SetConstant(d, "DD_DEFAULT_STYLE",SWIG_From_int(static_cast< int >(wxDD_DEFAULT_STYLE)));
55679 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
55680 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
55681 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
55682 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
55683 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
55684 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
55685 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
55686 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
55687 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
55688 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
55689 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
55690 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
55691 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
55692 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
55693 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
55694 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
55695 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
55696 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
55697 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
55698 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
55699 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
55700 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
55701 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
55702 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
55703 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
55704 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
55705 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
55706 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
55707 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
55708 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
55709 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
55710 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
55711 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
55712 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
55713 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
55714 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
55715 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
55716 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
55717 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
55718 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
55719 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
55720 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
55721 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
55722 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
55723 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
55724 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
55725 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
55726 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
55727 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
55728 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
55729 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
55730 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
55731 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
55732 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
55733 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
55734 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
55735 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
55736 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
55737 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
55738 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
55739 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
55740 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
55741 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
55742 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
55743 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
55744 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
55745 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
55746 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
55747 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
55748 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
55749 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
55750 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
55751 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
55752 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
55753 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
55754 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
55755 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
55756 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
55757 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
55758 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
55759 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
55760 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
55761 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
55762 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
55763 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
55764 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
55765 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
55766 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
55767 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
55768 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
55769 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
55770 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
55771 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
55772 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
55773 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
55774 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
55775 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
55776 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
55777 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
55778 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
55779 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
55780 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
55781 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
55782 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
55783 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
55784 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
55785 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
55786 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
55787 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
55788 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
55789 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
55790 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
55791 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
55792 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
55793 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
55794 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
55795 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
55796 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
55797 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
55798 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
55799 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
55800 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
55801 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
55802 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
55803 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
55804 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
55805 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
55806 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
55807 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
55808 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
55809 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
55810 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
55811 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
55812 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
55813 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
55814 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
55815 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
55816 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
55817 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
55818 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
55819 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
55820 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
55821 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
55822 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
55823 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
55824 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
55825 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
55826 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
55827 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
55828 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
55829 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
55830 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
55831 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
55832 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
55833 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
55834 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
55835 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
55836 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
55837 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
55838 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
55839 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
55840 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
55841 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
55842 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
55843 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
55844 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
55845 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
55846 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
55847 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
55848 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
55849 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
55850 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
55851 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
55852 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
55853 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
55854 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
55855 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
55856 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
55857 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
55858 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
55859 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
55860 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
55861 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
55862 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
55863 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
55864 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
55865 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
55866 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
55867 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
55868 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
55869 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
55870 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
55871 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
55872 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
55873 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
55874 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
55875 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
55876 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
55877 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
55878 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
55879 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
55880 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
55881 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
55882 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
55883 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
55884 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
55885 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
55886 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
55887 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
55888 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
55889 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
55890 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
55891 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
55892 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
55893 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
55894 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
55895 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
55896 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
55897 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
55898 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
55899 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
55900 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
55901 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
55902 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
55903 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
55904 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
55905 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
55906 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
55907 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
55908 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
55909 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
55910 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
55911 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
55912 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
55913 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
55914 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
55915 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
55916 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
55917 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
55918 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
55919 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
55920 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
55921 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
55922 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
55923 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
55924 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
55925 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
55926 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
55927 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
55928 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
55929 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
55930 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
55931 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
55932 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
55933 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
55934 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
55935 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
55936 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
55937 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
55938 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
55939 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
55940 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
55941 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
55942 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
55943 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
55944 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
55945 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
55946 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
55947 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
55948 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
55949 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
55950 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
55951 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
55952 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
55953 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
55954 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
55955 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
55956 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
55957 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
55958 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
55959 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
55960 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
55961 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
55962 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
55963 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
55964 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
55965 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
55966 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
55967 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
55968 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
55969 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
55970 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
55971 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
55972 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
55973 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
55974 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
55975 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
55976 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
55977 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
55978 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
55979 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
55980 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
55981 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
55982 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
55983 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
55984 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
55985 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
55986 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
55987 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
55988 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
55989 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
55990 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
55991 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
55992 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
55993 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
55994 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
55995 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
55996 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
55997 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
55998 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
55999 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
56000 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
56001 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
56002 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
56003 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
56004 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
56005 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
56006 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
56007 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
56008 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
56009 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
56010 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
56011 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
56012 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
56013 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
56014 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
56015 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
56016 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
56017 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
56018 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
56019 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
56020 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
56021 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
56022 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
56023 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
56024 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
56025 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
56026 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
56027 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
56028 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
56029 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
56030 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
56031 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
56032 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
56033 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
56034 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
56035 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
56036 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
56037 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
56038 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
56039 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
56040 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
56041 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
56042 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
56043 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
56044 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
56045 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
56046 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
56047 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
56048 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
56049 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
56050 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
56051 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
56052 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
56053 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
56054 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
56055 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
56056 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
56057 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
56058 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
56059 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
56060 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
56061 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
56062 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
56063 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
56064 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
56065 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
56066 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
56067 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
56068 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
56069 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
56070 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
56071 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
56072 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
56073 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
56074 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
56075 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
56076 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
56077 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
56078 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
56079 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
56080 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
56081 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
56082 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
56083 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
56084 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
56085 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
56086 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
56087 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
56088 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
56089 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
56090 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
56091 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
56092 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
56093 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
56094 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
56095 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
56096 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
56097 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
56098 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
56099 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
56100 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
56101 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
56102 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
56103 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
56104 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
56105 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
56106 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
56107 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
56108 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
56109 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
56110 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
56111 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
56112 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
56113 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
56114 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
56115 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
56116 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
56117 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
56118 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
56119 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
56120 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
56121 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
56122 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
56123 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
56124 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
56125 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
56126 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
56127 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
56128 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
56129 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
56130 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
56131 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
56132 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
56133 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
56134 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
56135 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
56136 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
56137 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
56138
56139 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
56140
56141
56142 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
56143
56144 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
56145 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
56146 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
56147 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
56148 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
56149 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
56150 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
56151 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
56152 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
56153 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
56154 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
56155 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
56156 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
56157 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
56158 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
56159 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
56160 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
56161 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
56162 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
56163 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
56164 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
56165 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
56166 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
56167 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
56168 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
56169 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
56170 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
56171 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
56172 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
56173 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
56174 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
56175 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
56176 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
56177 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
56178 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
56179 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
56180 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
56181 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
56182 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
56183 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
56184 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
56185 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
56186 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
56187 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
56188 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
56189 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
56190 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
56191 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
56192 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
56193 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
56194 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
56195 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
56196 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
56197 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
56198 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
56199 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
56200 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
56201 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
56202 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
56203 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
56204 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
56205 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
56206 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
56207 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
56208 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
56209 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
56210 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
56211 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
56212 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
56213 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
56214 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
56215 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
56216 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
56217 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
56218 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
56219 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
56220 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
56221 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
56222 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
56223 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
56224 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
56225 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
56226 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
56227 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
56228 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
56229 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
56230 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
56231 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
56232 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
56233 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
56234 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
56235 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
56236 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
56237 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
56238 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
56239 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
56240 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
56241 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
56242 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
56243 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
56244 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
56245 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
56246 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
56247 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
56248 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
56249 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
56250 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
56251 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
56252 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
56253 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
56254 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
56255 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
56256 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
56257 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
56258 PyDict_SetItemString(d, "wxEVT_POWER", PyInt_FromLong(wxEVT_POWER));
56259 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
56260 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
56261 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
56262 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
56263 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
56264 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
56265 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
56266 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
56267 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
56268 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
56269 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
56270 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
56271 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
56272 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
56273 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
56274 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
56275 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
56276 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
56277 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
56278 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
56279 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
56280 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
56281 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
56282 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
56283 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
56284 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
56285 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
56286 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
56287 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
56288 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
56289 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
56290 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
56291 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
56292 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
56293 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
56294 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
56295 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
56296 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
56297 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
56298 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
56299 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
56300 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
56301 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
56302 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
56303 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
56304 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
56305 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
56306 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
56307 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
56308 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
56309 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
56310 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
56311 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
56312 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
56313 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
56314 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
56315 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
56316 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
56317 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
56318 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
56319 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
56320 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
56321 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
56322 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
56323 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
56324 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
56325 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
56326 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
56327 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
56328 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
56329 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
56330 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
56331 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
56332 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
56333 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
56334 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
56335 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
56336 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
56337 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
56338 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
56339 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
56340 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
56341 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
56342 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
56343 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
56344 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
56345 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
56346 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
56347 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
56348
56349 // Initialize threading, some globals and such
56350 __wxPyPreStart(d);
56351
56352
56353 // Although these are defined in __version__ they need to be here too so
56354 // that an assert can be done to ensure that the wxPython and the wxWindows
56355 // versions match.
56356 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
56357 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
56358 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
56359
56360 }
56361
wxWidgets (Impactor)