]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/gtk/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
add some properties
[wxWidgets.git] / wxPython / src / gtk / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 #if PY_VERSION_HEX < 0x02050000
989 typedef int Py_ssize_t;
990 #endif
991
992 /* for raw pointers */
993 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
994 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
995 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
996 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
997 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
998 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
999 #define swig_owntype int
1000
1001 /* for raw packed data */
1002 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1003 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1004
1005 /* for class or struct pointers */
1006 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1007 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1008
1009 /* for C or C++ function pointers */
1010 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1011 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1012
1013 /* for C++ member pointers, ie, member methods */
1014 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1015 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1016
1017
1018 /* Runtime API */
1019
1020 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1021 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1022 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1023
1024 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1025 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1026 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1027 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1028 #define SWIG_fail goto fail
1029
1030
1031 /* Runtime API implementation */
1032
1033 /* Error manipulation */
1034
1035 SWIGINTERN void
1036 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1037 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1038 PyErr_SetObject(errtype, obj);
1039 Py_DECREF(obj);
1040 SWIG_PYTHON_THREAD_END_BLOCK;
1041 }
1042
1043 SWIGINTERN void
1044 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1045 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1046 PyErr_SetString(errtype, (char *) msg);
1047 SWIG_PYTHON_THREAD_END_BLOCK;
1048 }
1049
1050 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1051
1052 /* Set a constant value */
1053
1054 SWIGINTERN void
1055 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1056 PyDict_SetItemString(d, (char*) name, obj);
1057 Py_DECREF(obj);
1058 }
1059
1060 /* Append a value to the result obj */
1061
1062 SWIGINTERN PyObject*
1063 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1064 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1065 if (!result) {
1066 result = obj;
1067 } else if (result == Py_None) {
1068 Py_DECREF(result);
1069 result = obj;
1070 } else {
1071 if (!PyList_Check(result)) {
1072 PyObject *o2 = result;
1073 result = PyList_New(1);
1074 PyList_SetItem(result, 0, o2);
1075 }
1076 PyList_Append(result,obj);
1077 Py_DECREF(obj);
1078 }
1079 return result;
1080 #else
1081 PyObject* o2;
1082 PyObject* o3;
1083 if (!result) {
1084 result = obj;
1085 } else if (result == Py_None) {
1086 Py_DECREF(result);
1087 result = obj;
1088 } else {
1089 if (!PyTuple_Check(result)) {
1090 o2 = result;
1091 result = PyTuple_New(1);
1092 PyTuple_SET_ITEM(result, 0, o2);
1093 }
1094 o3 = PyTuple_New(1);
1095 PyTuple_SET_ITEM(o3, 0, obj);
1096 o2 = result;
1097 result = PySequence_Concat(o2, o3);
1098 Py_DECREF(o2);
1099 Py_DECREF(o3);
1100 }
1101 return result;
1102 #endif
1103 }
1104
1105 /* Unpack the argument tuple */
1106
1107 SWIGINTERN int
1108 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1109 {
1110 if (!args) {
1111 if (!min && !max) {
1112 return 1;
1113 } else {
1114 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1115 name, (min == max ? "" : "at least "), min);
1116 return 0;
1117 }
1118 }
1119 if (!PyTuple_Check(args)) {
1120 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1121 return 0;
1122 } else {
1123 register int l = PyTuple_GET_SIZE(args);
1124 if (l < min) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at least "), min, l);
1127 return 0;
1128 } else if (l > max) {
1129 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1130 name, (min == max ? "" : "at most "), max, l);
1131 return 0;
1132 } else {
1133 register int i;
1134 for (i = 0; i < l; ++i) {
1135 objs[i] = PyTuple_GET_ITEM(args, i);
1136 }
1137 for (; l < max; ++l) {
1138 objs[l] = 0;
1139 }
1140 return i + 1;
1141 }
1142 }
1143 }
1144
1145 /* A functor is a function object with one single object argument */
1146 #if PY_VERSION_HEX >= 0x02020000
1147 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1148 #else
1149 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1150 #endif
1151
1152 /*
1153 Helper for static pointer initialization for both C and C++ code, for example
1154 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1155 */
1156 #ifdef __cplusplus
1157 #define SWIG_STATIC_POINTER(var) var
1158 #else
1159 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1160 #endif
1161
1162 /* -----------------------------------------------------------------------------
1163 * Pointer declarations
1164 * ----------------------------------------------------------------------------- */
1165
1166 /* Flags for new pointer objects */
1167 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1168 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1169
1170 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1171
1172 #ifdef __cplusplus
1173 extern "C" {
1174 #if 0
1175 } /* cc-mode */
1176 #endif
1177 #endif
1178
1179 /* How to access Py_None */
1180 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1181 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1182 # ifndef SWIG_PYTHON_BUILD_NONE
1183 # define SWIG_PYTHON_BUILD_NONE
1184 # endif
1185 # endif
1186 #endif
1187
1188 #ifdef SWIG_PYTHON_BUILD_NONE
1189 # ifdef Py_None
1190 # undef Py_None
1191 # define Py_None SWIG_Py_None()
1192 # endif
1193 SWIGRUNTIMEINLINE PyObject *
1194 _SWIG_Py_None(void)
1195 {
1196 PyObject *none = Py_BuildValue("");
1197 Py_DECREF(none);
1198 return none;
1199 }
1200 SWIGRUNTIME PyObject *
1201 SWIG_Py_None(void)
1202 {
1203 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1204 return none;
1205 }
1206 #endif
1207
1208 /* The python void return value */
1209
1210 SWIGRUNTIMEINLINE PyObject *
1211 SWIG_Py_Void(void)
1212 {
1213 PyObject *none = Py_None;
1214 Py_INCREF(none);
1215 return none;
1216 }
1217
1218 /* PySwigClientData */
1219
1220 typedef struct {
1221 PyObject *klass;
1222 PyObject *newraw;
1223 PyObject *newargs;
1224 PyObject *destroy;
1225 int delargs;
1226 int implicitconv;
1227 } PySwigClientData;
1228
1229 SWIGRUNTIMEINLINE int
1230 SWIG_Python_CheckImplicit(swig_type_info *ty)
1231 {
1232 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1233 return data ? data->implicitconv : 0;
1234 }
1235
1236 SWIGRUNTIMEINLINE PyObject *
1237 SWIG_Python_ExceptionType(swig_type_info *desc) {
1238 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1239 PyObject *klass = data ? data->klass : 0;
1240 return (klass ? klass : PyExc_RuntimeError);
1241 }
1242
1243
1244 SWIGRUNTIME PySwigClientData *
1245 PySwigClientData_New(PyObject* obj)
1246 {
1247 if (!obj) {
1248 return 0;
1249 } else {
1250 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1251 /* the klass element */
1252 data->klass = obj;
1253 Py_INCREF(data->klass);
1254 /* the newraw method and newargs arguments used to create a new raw instance */
1255 if (PyClass_Check(obj)) {
1256 data->newraw = 0;
1257 data->newargs = obj;
1258 Py_INCREF(obj);
1259 } else {
1260 #if (PY_VERSION_HEX < 0x02020000)
1261 data->newraw = 0;
1262 #else
1263 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1264 #endif
1265 if (data->newraw) {
1266 Py_INCREF(data->newraw);
1267 data->newargs = PyTuple_New(1);
1268 PyTuple_SetItem(data->newargs, 0, obj);
1269 } else {
1270 data->newargs = obj;
1271 }
1272 Py_INCREF(data->newargs);
1273 }
1274 /* the destroy method, aka as the C++ delete method */
1275 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1276 if (PyErr_Occurred()) {
1277 PyErr_Clear();
1278 data->destroy = 0;
1279 }
1280 if (data->destroy) {
1281 int flags;
1282 Py_INCREF(data->destroy);
1283 flags = PyCFunction_GET_FLAGS(data->destroy);
1284 #ifdef METH_O
1285 data->delargs = !(flags & (METH_O));
1286 #else
1287 data->delargs = 0;
1288 #endif
1289 } else {
1290 data->delargs = 0;
1291 }
1292 data->implicitconv = 0;
1293 return data;
1294 }
1295 }
1296
1297 SWIGRUNTIME void
1298 PySwigClientData_Del(PySwigClientData* data)
1299 {
1300 Py_XDECREF(data->newraw);
1301 Py_XDECREF(data->newargs);
1302 Py_XDECREF(data->destroy);
1303 }
1304
1305 /* =============== PySwigObject =====================*/
1306
1307 typedef struct {
1308 PyObject_HEAD
1309 void *ptr;
1310 swig_type_info *ty;
1311 int own;
1312 PyObject *next;
1313 } PySwigObject;
1314
1315 SWIGRUNTIME PyObject *
1316 PySwigObject_long(PySwigObject *v)
1317 {
1318 return PyLong_FromVoidPtr(v->ptr);
1319 }
1320
1321 SWIGRUNTIME PyObject *
1322 PySwigObject_format(const char* fmt, PySwigObject *v)
1323 {
1324 PyObject *res = NULL;
1325 PyObject *args = PyTuple_New(1);
1326 if (args) {
1327 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1328 PyObject *ofmt = PyString_FromString(fmt);
1329 if (ofmt) {
1330 res = PyString_Format(ofmt,args);
1331 Py_DECREF(ofmt);
1332 }
1333 Py_DECREF(args);
1334 }
1335 }
1336 return res;
1337 }
1338
1339 SWIGRUNTIME PyObject *
1340 PySwigObject_oct(PySwigObject *v)
1341 {
1342 return PySwigObject_format("%o",v);
1343 }
1344
1345 SWIGRUNTIME PyObject *
1346 PySwigObject_hex(PySwigObject *v)
1347 {
1348 return PySwigObject_format("%x",v);
1349 }
1350
1351 SWIGRUNTIME PyObject *
1352 #ifdef METH_NOARGS
1353 PySwigObject_repr(PySwigObject *v)
1354 #else
1355 PySwigObject_repr(PySwigObject *v, PyObject *args)
1356 #endif
1357 {
1358 const char *name = SWIG_TypePrettyName(v->ty);
1359 PyObject *hex = PySwigObject_hex(v);
1360 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1361 Py_DECREF(hex);
1362 if (v->next) {
1363 #ifdef METH_NOARGS
1364 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1365 #else
1366 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1367 #endif
1368 PyString_ConcatAndDel(&repr,nrep);
1369 }
1370 return repr;
1371 }
1372
1373 SWIGRUNTIME int
1374 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1375 {
1376 #ifdef METH_NOARGS
1377 PyObject *repr = PySwigObject_repr(v);
1378 #else
1379 PyObject *repr = PySwigObject_repr(v, NULL);
1380 #endif
1381 if (repr) {
1382 fputs(PyString_AsString(repr), fp);
1383 Py_DECREF(repr);
1384 return 0;
1385 } else {
1386 return 1;
1387 }
1388 }
1389
1390 SWIGRUNTIME PyObject *
1391 PySwigObject_str(PySwigObject *v)
1392 {
1393 char result[SWIG_BUFFER_SIZE];
1394 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1395 PyString_FromString(result) : 0;
1396 }
1397
1398 SWIGRUNTIME int
1399 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1400 {
1401 void *i = v->ptr;
1402 void *j = w->ptr;
1403 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1404 }
1405
1406 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1407
1408 SWIGRUNTIME PyTypeObject*
1409 PySwigObject_type(void) {
1410 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1411 return type;
1412 }
1413
1414 SWIGRUNTIMEINLINE int
1415 PySwigObject_Check(PyObject *op) {
1416 return ((op)->ob_type == PySwigObject_type())
1417 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1418 }
1419
1420 SWIGRUNTIME PyObject *
1421 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1422
1423 SWIGRUNTIME void
1424 PySwigObject_dealloc(PyObject *v)
1425 {
1426 PySwigObject *sobj = (PySwigObject *) v;
1427 PyObject *next = sobj->next;
1428 if (sobj->own) {
1429 swig_type_info *ty = sobj->ty;
1430 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1431 PyObject *destroy = data ? data->destroy : 0;
1432 if (destroy) {
1433 /* destroy is always a VARARGS method */
1434 PyObject *res;
1435 if (data->delargs) {
1436 /* we need to create a temporal object to carry the destroy operation */
1437 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1438 res = SWIG_Python_CallFunctor(destroy, tmp);
1439 Py_DECREF(tmp);
1440 } else {
1441 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1442 PyObject *mself = PyCFunction_GET_SELF(destroy);
1443 res = ((*meth)(mself, v));
1444 }
1445 Py_XDECREF(res);
1446 } else {
1447 const char *name = SWIG_TypePrettyName(ty);
1448 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1449 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1450 #endif
1451 }
1452 }
1453 Py_XDECREF(next);
1454 PyObject_DEL(v);
1455 }
1456
1457 SWIGRUNTIME PyObject*
1458 PySwigObject_append(PyObject* v, PyObject* next)
1459 {
1460 PySwigObject *sobj = (PySwigObject *) v;
1461 #ifndef METH_O
1462 PyObject *tmp = 0;
1463 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1464 next = tmp;
1465 #endif
1466 if (!PySwigObject_Check(next)) {
1467 return NULL;
1468 }
1469 sobj->next = next;
1470 Py_INCREF(next);
1471 return SWIG_Py_Void();
1472 }
1473
1474 SWIGRUNTIME PyObject*
1475 #ifdef METH_NOARGS
1476 PySwigObject_next(PyObject* v)
1477 #else
1478 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1479 #endif
1480 {
1481 PySwigObject *sobj = (PySwigObject *) v;
1482 if (sobj->next) {
1483 Py_INCREF(sobj->next);
1484 return sobj->next;
1485 } else {
1486 return SWIG_Py_Void();
1487 }
1488 }
1489
1490 SWIGINTERN PyObject*
1491 #ifdef METH_NOARGS
1492 PySwigObject_disown(PyObject *v)
1493 #else
1494 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1495 #endif
1496 {
1497 PySwigObject *sobj = (PySwigObject *)v;
1498 sobj->own = 0;
1499 return SWIG_Py_Void();
1500 }
1501
1502 SWIGINTERN PyObject*
1503 #ifdef METH_NOARGS
1504 PySwigObject_acquire(PyObject *v)
1505 #else
1506 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1507 #endif
1508 {
1509 PySwigObject *sobj = (PySwigObject *)v;
1510 sobj->own = SWIG_POINTER_OWN;
1511 return SWIG_Py_Void();
1512 }
1513
1514 SWIGINTERN PyObject*
1515 PySwigObject_own(PyObject *v, PyObject *args)
1516 {
1517 PyObject *val = 0;
1518 #if (PY_VERSION_HEX < 0x02020000)
1519 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1520 #else
1521 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1522 #endif
1523 {
1524 return NULL;
1525 }
1526 else
1527 {
1528 PySwigObject *sobj = (PySwigObject *)v;
1529 PyObject *obj = PyBool_FromLong(sobj->own);
1530 if (val) {
1531 #ifdef METH_NOARGS
1532 if (PyObject_IsTrue(val)) {
1533 PySwigObject_acquire(v);
1534 } else {
1535 PySwigObject_disown(v);
1536 }
1537 #else
1538 if (PyObject_IsTrue(val)) {
1539 PySwigObject_acquire(v,args);
1540 } else {
1541 PySwigObject_disown(v,args);
1542 }
1543 #endif
1544 }
1545 return obj;
1546 }
1547 }
1548
1549 #ifdef METH_O
1550 static PyMethodDef
1551 swigobject_methods[] = {
1552 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1553 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1554 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1555 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1556 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1557 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1558 {0, 0, 0, 0}
1559 };
1560 #else
1561 static PyMethodDef
1562 swigobject_methods[] = {
1563 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1564 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1565 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1566 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1567 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1568 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1569 {0, 0, 0, 0}
1570 };
1571 #endif
1572
1573 #if PY_VERSION_HEX < 0x02020000
1574 SWIGINTERN PyObject *
1575 PySwigObject_getattr(PySwigObject *sobj,char *name)
1576 {
1577 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1578 }
1579 #endif
1580
1581 SWIGRUNTIME PyTypeObject*
1582 _PySwigObject_type(void) {
1583 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1584
1585 static PyNumberMethods PySwigObject_as_number = {
1586 (binaryfunc)0, /*nb_add*/
1587 (binaryfunc)0, /*nb_subtract*/
1588 (binaryfunc)0, /*nb_multiply*/
1589 (binaryfunc)0, /*nb_divide*/
1590 (binaryfunc)0, /*nb_remainder*/
1591 (binaryfunc)0, /*nb_divmod*/
1592 (ternaryfunc)0,/*nb_power*/
1593 (unaryfunc)0, /*nb_negative*/
1594 (unaryfunc)0, /*nb_positive*/
1595 (unaryfunc)0, /*nb_absolute*/
1596 (inquiry)0, /*nb_nonzero*/
1597 0, /*nb_invert*/
1598 0, /*nb_lshift*/
1599 0, /*nb_rshift*/
1600 0, /*nb_and*/
1601 0, /*nb_xor*/
1602 0, /*nb_or*/
1603 (coercion)0, /*nb_coerce*/
1604 (unaryfunc)PySwigObject_long, /*nb_int*/
1605 (unaryfunc)PySwigObject_long, /*nb_long*/
1606 (unaryfunc)0, /*nb_float*/
1607 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1608 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1609 #if PY_VERSION_HEX >= 0x02020000
1610 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1611 #elif PY_VERSION_HEX >= 0x02000000
1612 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1613 #endif
1614 };
1615
1616 static PyTypeObject pyswigobject_type;
1617 static int type_init = 0;
1618 if (!type_init) {
1619 const PyTypeObject tmp
1620 = {
1621 PyObject_HEAD_INIT(NULL)
1622 0, /* ob_size */
1623 (char *)"PySwigObject", /* tp_name */
1624 sizeof(PySwigObject), /* tp_basicsize */
1625 0, /* tp_itemsize */
1626 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1627 (printfunc)PySwigObject_print, /* tp_print */
1628 #if PY_VERSION_HEX < 0x02020000
1629 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1630 #else
1631 (getattrfunc)0, /* tp_getattr */
1632 #endif
1633 (setattrfunc)0, /* tp_setattr */
1634 (cmpfunc)PySwigObject_compare, /* tp_compare */
1635 (reprfunc)PySwigObject_repr, /* tp_repr */
1636 &PySwigObject_as_number, /* tp_as_number */
1637 0, /* tp_as_sequence */
1638 0, /* tp_as_mapping */
1639 (hashfunc)0, /* tp_hash */
1640 (ternaryfunc)0, /* tp_call */
1641 (reprfunc)PySwigObject_str, /* tp_str */
1642 PyObject_GenericGetAttr, /* tp_getattro */
1643 0, /* tp_setattro */
1644 0, /* tp_as_buffer */
1645 Py_TPFLAGS_DEFAULT, /* tp_flags */
1646 swigobject_doc, /* tp_doc */
1647 0, /* tp_traverse */
1648 0, /* tp_clear */
1649 0, /* tp_richcompare */
1650 0, /* tp_weaklistoffset */
1651 #if PY_VERSION_HEX >= 0x02020000
1652 0, /* tp_iter */
1653 0, /* tp_iternext */
1654 swigobject_methods, /* tp_methods */
1655 0, /* tp_members */
1656 0, /* tp_getset */
1657 0, /* tp_base */
1658 0, /* tp_dict */
1659 0, /* tp_descr_get */
1660 0, /* tp_descr_set */
1661 0, /* tp_dictoffset */
1662 0, /* tp_init */
1663 0, /* tp_alloc */
1664 0, /* tp_new */
1665 0, /* tp_free */
1666 0, /* tp_is_gc */
1667 0, /* tp_bases */
1668 0, /* tp_mro */
1669 0, /* tp_cache */
1670 0, /* tp_subclasses */
1671 0, /* tp_weaklist */
1672 #endif
1673 #if PY_VERSION_HEX >= 0x02030000
1674 0, /* tp_del */
1675 #endif
1676 #ifdef COUNT_ALLOCS
1677 0,0,0,0 /* tp_alloc -> tp_next */
1678 #endif
1679 };
1680 pyswigobject_type = tmp;
1681 pyswigobject_type.ob_type = &PyType_Type;
1682 type_init = 1;
1683 }
1684 return &pyswigobject_type;
1685 }
1686
1687 SWIGRUNTIME PyObject *
1688 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1689 {
1690 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1691 if (sobj) {
1692 sobj->ptr = ptr;
1693 sobj->ty = ty;
1694 sobj->own = own;
1695 sobj->next = 0;
1696 }
1697 return (PyObject *)sobj;
1698 }
1699
1700 /* -----------------------------------------------------------------------------
1701 * Implements a simple Swig Packed type, and use it instead of string
1702 * ----------------------------------------------------------------------------- */
1703
1704 typedef struct {
1705 PyObject_HEAD
1706 void *pack;
1707 swig_type_info *ty;
1708 size_t size;
1709 } PySwigPacked;
1710
1711 SWIGRUNTIME int
1712 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1713 {
1714 char result[SWIG_BUFFER_SIZE];
1715 fputs("<Swig Packed ", fp);
1716 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1717 fputs("at ", fp);
1718 fputs(result, fp);
1719 }
1720 fputs(v->ty->name,fp);
1721 fputs(">", fp);
1722 return 0;
1723 }
1724
1725 SWIGRUNTIME PyObject *
1726 PySwigPacked_repr(PySwigPacked *v)
1727 {
1728 char result[SWIG_BUFFER_SIZE];
1729 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1730 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1731 } else {
1732 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1733 }
1734 }
1735
1736 SWIGRUNTIME PyObject *
1737 PySwigPacked_str(PySwigPacked *v)
1738 {
1739 char result[SWIG_BUFFER_SIZE];
1740 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1741 return PyString_FromFormat("%s%s", result, v->ty->name);
1742 } else {
1743 return PyString_FromString(v->ty->name);
1744 }
1745 }
1746
1747 SWIGRUNTIME int
1748 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1749 {
1750 size_t i = v->size;
1751 size_t j = w->size;
1752 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1753 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1754 }
1755
1756 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1757
1758 SWIGRUNTIME PyTypeObject*
1759 PySwigPacked_type(void) {
1760 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1761 return type;
1762 }
1763
1764 SWIGRUNTIMEINLINE int
1765 PySwigPacked_Check(PyObject *op) {
1766 return ((op)->ob_type == _PySwigPacked_type())
1767 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1768 }
1769
1770 SWIGRUNTIME void
1771 PySwigPacked_dealloc(PyObject *v)
1772 {
1773 if (PySwigPacked_Check(v)) {
1774 PySwigPacked *sobj = (PySwigPacked *) v;
1775 free(sobj->pack);
1776 }
1777 PyObject_DEL(v);
1778 }
1779
1780 SWIGRUNTIME PyTypeObject*
1781 _PySwigPacked_type(void) {
1782 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1783 static PyTypeObject pyswigpacked_type;
1784 static int type_init = 0;
1785 if (!type_init) {
1786 const PyTypeObject tmp
1787 = {
1788 PyObject_HEAD_INIT(NULL)
1789 0, /* ob_size */
1790 (char *)"PySwigPacked", /* tp_name */
1791 sizeof(PySwigPacked), /* tp_basicsize */
1792 0, /* tp_itemsize */
1793 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1794 (printfunc)PySwigPacked_print, /* tp_print */
1795 (getattrfunc)0, /* tp_getattr */
1796 (setattrfunc)0, /* tp_setattr */
1797 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1798 (reprfunc)PySwigPacked_repr, /* tp_repr */
1799 0, /* tp_as_number */
1800 0, /* tp_as_sequence */
1801 0, /* tp_as_mapping */
1802 (hashfunc)0, /* tp_hash */
1803 (ternaryfunc)0, /* tp_call */
1804 (reprfunc)PySwigPacked_str, /* tp_str */
1805 PyObject_GenericGetAttr, /* tp_getattro */
1806 0, /* tp_setattro */
1807 0, /* tp_as_buffer */
1808 Py_TPFLAGS_DEFAULT, /* tp_flags */
1809 swigpacked_doc, /* tp_doc */
1810 0, /* tp_traverse */
1811 0, /* tp_clear */
1812 0, /* tp_richcompare */
1813 0, /* tp_weaklistoffset */
1814 #if PY_VERSION_HEX >= 0x02020000
1815 0, /* tp_iter */
1816 0, /* tp_iternext */
1817 0, /* tp_methods */
1818 0, /* tp_members */
1819 0, /* tp_getset */
1820 0, /* tp_base */
1821 0, /* tp_dict */
1822 0, /* tp_descr_get */
1823 0, /* tp_descr_set */
1824 0, /* tp_dictoffset */
1825 0, /* tp_init */
1826 0, /* tp_alloc */
1827 0, /* tp_new */
1828 0, /* tp_free */
1829 0, /* tp_is_gc */
1830 0, /* tp_bases */
1831 0, /* tp_mro */
1832 0, /* tp_cache */
1833 0, /* tp_subclasses */
1834 0, /* tp_weaklist */
1835 #endif
1836 #if PY_VERSION_HEX >= 0x02030000
1837 0, /* tp_del */
1838 #endif
1839 #ifdef COUNT_ALLOCS
1840 0,0,0,0 /* tp_alloc -> tp_next */
1841 #endif
1842 };
1843 pyswigpacked_type = tmp;
1844 pyswigpacked_type.ob_type = &PyType_Type;
1845 type_init = 1;
1846 }
1847 return &pyswigpacked_type;
1848 }
1849
1850 SWIGRUNTIME PyObject *
1851 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1852 {
1853 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1854 if (sobj) {
1855 void *pack = malloc(size);
1856 if (pack) {
1857 memcpy(pack, ptr, size);
1858 sobj->pack = pack;
1859 sobj->ty = ty;
1860 sobj->size = size;
1861 } else {
1862 PyObject_DEL((PyObject *) sobj);
1863 sobj = 0;
1864 }
1865 }
1866 return (PyObject *) sobj;
1867 }
1868
1869 SWIGRUNTIME swig_type_info *
1870 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1871 {
1872 if (PySwigPacked_Check(obj)) {
1873 PySwigPacked *sobj = (PySwigPacked *)obj;
1874 if (sobj->size != size) return 0;
1875 memcpy(ptr, sobj->pack, size);
1876 return sobj->ty;
1877 } else {
1878 return 0;
1879 }
1880 }
1881
1882 /* -----------------------------------------------------------------------------
1883 * pointers/data manipulation
1884 * ----------------------------------------------------------------------------- */
1885
1886 SWIGRUNTIMEINLINE PyObject *
1887 _SWIG_This(void)
1888 {
1889 return PyString_FromString("this");
1890 }
1891
1892 SWIGRUNTIME PyObject *
1893 SWIG_This(void)
1894 {
1895 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1896 return swig_this;
1897 }
1898
1899 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1900
1901 SWIGRUNTIME PySwigObject *
1902 SWIG_Python_GetSwigThis(PyObject *pyobj)
1903 {
1904 if (PySwigObject_Check(pyobj)) {
1905 return (PySwigObject *) pyobj;
1906 } else {
1907 PyObject *obj = 0;
1908 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1909 if (PyInstance_Check(pyobj)) {
1910 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1911 } else {
1912 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1913 if (dictptr != NULL) {
1914 PyObject *dict = *dictptr;
1915 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1916 } else {
1917 #ifdef PyWeakref_CheckProxy
1918 if (PyWeakref_CheckProxy(pyobj)) {
1919 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1920 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1921 }
1922 #endif
1923 obj = PyObject_GetAttr(pyobj,SWIG_This());
1924 if (obj) {
1925 Py_DECREF(obj);
1926 } else {
1927 if (PyErr_Occurred()) PyErr_Clear();
1928 return 0;
1929 }
1930 }
1931 }
1932 #else
1933 obj = PyObject_GetAttr(pyobj,SWIG_This());
1934 if (obj) {
1935 Py_DECREF(obj);
1936 } else {
1937 if (PyErr_Occurred()) PyErr_Clear();
1938 return 0;
1939 }
1940 #endif
1941 if (obj && !PySwigObject_Check(obj)) {
1942 /* a PyObject is called 'this', try to get the 'real this'
1943 PySwigObject from it */
1944 return SWIG_Python_GetSwigThis(obj);
1945 }
1946 return (PySwigObject *)obj;
1947 }
1948 }
1949
1950 /* Acquire a pointer value */
1951
1952 SWIGRUNTIME int
1953 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1954 if (own) {
1955 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1956 if (sobj) {
1957 int oldown = sobj->own;
1958 sobj->own = own;
1959 return oldown;
1960 }
1961 }
1962 return 0;
1963 }
1964
1965 /* Convert a pointer value */
1966
1967 SWIGRUNTIME int
1968 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1969 if (!obj) return SWIG_ERROR;
1970 if (obj == Py_None) {
1971 if (ptr) *ptr = 0;
1972 return SWIG_OK;
1973 } else {
1974 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1975 while (sobj) {
1976 void *vptr = sobj->ptr;
1977 if (ty) {
1978 swig_type_info *to = sobj->ty;
1979 if (to == ty) {
1980 /* no type cast needed */
1981 if (ptr) *ptr = vptr;
1982 break;
1983 } else {
1984 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1985 if (!tc) {
1986 sobj = (PySwigObject *)sobj->next;
1987 } else {
1988 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1989 break;
1990 }
1991 }
1992 } else {
1993 if (ptr) *ptr = vptr;
1994 break;
1995 }
1996 }
1997 if (sobj) {
1998 if (own) *own = sobj->own;
1999 if (flags & SWIG_POINTER_DISOWN) {
2000 sobj->own = 0;
2001 }
2002 return SWIG_OK;
2003 } else {
2004 int res = SWIG_ERROR;
2005 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2006 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2007 if (data && !data->implicitconv) {
2008 PyObject *klass = data->klass;
2009 if (klass) {
2010 PyObject *impconv;
2011 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2012 impconv = SWIG_Python_CallFunctor(klass, obj);
2013 data->implicitconv = 0;
2014 if (PyErr_Occurred()) {
2015 PyErr_Clear();
2016 impconv = 0;
2017 }
2018 if (impconv) {
2019 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2020 if (iobj) {
2021 void *vptr;
2022 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2023 if (SWIG_IsOK(res)) {
2024 if (ptr) {
2025 *ptr = vptr;
2026 /* transfer the ownership to 'ptr' */
2027 iobj->own = 0;
2028 res = SWIG_AddCast(res);
2029 res = SWIG_AddNewMask(res);
2030 } else {
2031 res = SWIG_AddCast(res);
2032 }
2033 }
2034 }
2035 Py_DECREF(impconv);
2036 }
2037 }
2038 }
2039 }
2040 return res;
2041 }
2042 }
2043 }
2044
2045 /* Convert a function ptr value */
2046
2047 SWIGRUNTIME int
2048 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2049 if (!PyCFunction_Check(obj)) {
2050 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2051 } else {
2052 void *vptr = 0;
2053
2054 /* here we get the method pointer for callbacks */
2055 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2056 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2057 if (desc) {
2058 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2059 if (!desc) return SWIG_ERROR;
2060 }
2061 if (ty) {
2062 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2063 if (!tc) return SWIG_ERROR;
2064 *ptr = SWIG_TypeCast(tc,vptr);
2065 } else {
2066 *ptr = vptr;
2067 }
2068 return SWIG_OK;
2069 }
2070 }
2071
2072 /* Convert a packed value value */
2073
2074 SWIGRUNTIME int
2075 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2076 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2077 if (!to) return SWIG_ERROR;
2078 if (ty) {
2079 if (to != ty) {
2080 /* check type cast? */
2081 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2082 if (!tc) return SWIG_ERROR;
2083 }
2084 }
2085 return SWIG_OK;
2086 }
2087
2088 /* -----------------------------------------------------------------------------
2089 * Create a new pointer object
2090 * ----------------------------------------------------------------------------- */
2091
2092 /*
2093 Create a new instance object, whitout calling __init__, and set the
2094 'this' attribute.
2095 */
2096
2097 SWIGRUNTIME PyObject*
2098 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2099 {
2100 #if (PY_VERSION_HEX >= 0x02020000)
2101 PyObject *inst = 0;
2102 PyObject *newraw = data->newraw;
2103 if (newraw) {
2104 inst = PyObject_Call(newraw, data->newargs, NULL);
2105 if (inst) {
2106 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2107 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2108 if (dictptr != NULL) {
2109 PyObject *dict = *dictptr;
2110 if (dict == NULL) {
2111 dict = PyDict_New();
2112 *dictptr = dict;
2113 PyDict_SetItem(dict, SWIG_This(), swig_this);
2114 }
2115 }
2116 #else
2117 PyObject *key = SWIG_This();
2118 PyObject_SetAttr(inst, key, swig_this);
2119 #endif
2120 }
2121 } else {
2122 PyObject *dict = PyDict_New();
2123 PyDict_SetItem(dict, SWIG_This(), swig_this);
2124 inst = PyInstance_NewRaw(data->newargs, dict);
2125 Py_DECREF(dict);
2126 }
2127 return inst;
2128 #else
2129 #if (PY_VERSION_HEX >= 0x02010000)
2130 PyObject *inst;
2131 PyObject *dict = PyDict_New();
2132 PyDict_SetItem(dict, SWIG_This(), swig_this);
2133 inst = PyInstance_NewRaw(data->newargs, dict);
2134 Py_DECREF(dict);
2135 return (PyObject *) inst;
2136 #else
2137 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2138 if (inst == NULL) {
2139 return NULL;
2140 }
2141 inst->in_class = (PyClassObject *)data->newargs;
2142 Py_INCREF(inst->in_class);
2143 inst->in_dict = PyDict_New();
2144 if (inst->in_dict == NULL) {
2145 Py_DECREF(inst);
2146 return NULL;
2147 }
2148 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2149 inst->in_weakreflist = NULL;
2150 #endif
2151 #ifdef Py_TPFLAGS_GC
2152 PyObject_GC_Init(inst);
2153 #endif
2154 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2155 return (PyObject *) inst;
2156 #endif
2157 #endif
2158 }
2159
2160 SWIGRUNTIME void
2161 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2162 {
2163 PyObject *dict;
2164 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2165 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2166 if (dictptr != NULL) {
2167 dict = *dictptr;
2168 if (dict == NULL) {
2169 dict = PyDict_New();
2170 *dictptr = dict;
2171 }
2172 PyDict_SetItem(dict, SWIG_This(), swig_this);
2173 return;
2174 }
2175 #endif
2176 dict = PyObject_GetAttrString(inst, "__dict__");
2177 PyDict_SetItem(dict, SWIG_This(), swig_this);
2178 Py_DECREF(dict);
2179 }
2180
2181
2182 SWIGINTERN PyObject *
2183 SWIG_Python_InitShadowInstance(PyObject *args) {
2184 PyObject *obj[2];
2185 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2186 return NULL;
2187 } else {
2188 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2189 if (sthis) {
2190 PySwigObject_append((PyObject*) sthis, obj[1]);
2191 } else {
2192 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2193 }
2194 return SWIG_Py_Void();
2195 }
2196 }
2197
2198 /* Create a new pointer object */
2199
2200 SWIGRUNTIME PyObject *
2201 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2202 if (!ptr) {
2203 return SWIG_Py_Void();
2204 } else {
2205 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2206 PyObject *robj = PySwigObject_New(ptr, type, own);
2207 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2208 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2209 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2210 if (inst) {
2211 Py_DECREF(robj);
2212 robj = inst;
2213 }
2214 }
2215 return robj;
2216 }
2217 }
2218
2219 /* Create a new packed object */
2220
2221 SWIGRUNTIMEINLINE PyObject *
2222 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2223 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2224 }
2225
2226 /* -----------------------------------------------------------------------------*
2227 * Get type list
2228 * -----------------------------------------------------------------------------*/
2229
2230 #ifdef SWIG_LINK_RUNTIME
2231 void *SWIG_ReturnGlobalTypeList(void *);
2232 #endif
2233
2234 SWIGRUNTIME swig_module_info *
2235 SWIG_Python_GetModule(void) {
2236 static void *type_pointer = (void *)0;
2237 /* first check if module already created */
2238 if (!type_pointer) {
2239 #ifdef SWIG_LINK_RUNTIME
2240 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2241 #else
2242 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2243 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2244 if (PyErr_Occurred()) {
2245 PyErr_Clear();
2246 type_pointer = (void *)0;
2247 }
2248 #endif
2249 }
2250 return (swig_module_info *) type_pointer;
2251 }
2252
2253 #if PY_MAJOR_VERSION < 2
2254 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2255 is copied out of Python/modsupport.c in python version 2.3.4 */
2256 SWIGINTERN int
2257 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2258 {
2259 PyObject *dict;
2260 if (!PyModule_Check(m)) {
2261 PyErr_SetString(PyExc_TypeError,
2262 "PyModule_AddObject() needs module as first arg");
2263 return SWIG_ERROR;
2264 }
2265 if (!o) {
2266 PyErr_SetString(PyExc_TypeError,
2267 "PyModule_AddObject() needs non-NULL value");
2268 return SWIG_ERROR;
2269 }
2270
2271 dict = PyModule_GetDict(m);
2272 if (dict == NULL) {
2273 /* Internal error -- modules must have a dict! */
2274 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2275 PyModule_GetName(m));
2276 return SWIG_ERROR;
2277 }
2278 if (PyDict_SetItemString(dict, name, o))
2279 return SWIG_ERROR;
2280 Py_DECREF(o);
2281 return SWIG_OK;
2282 }
2283 #endif
2284
2285 SWIGRUNTIME void
2286 SWIG_Python_DestroyModule(void *vptr)
2287 {
2288 swig_module_info *swig_module = (swig_module_info *) vptr;
2289 swig_type_info **types = swig_module->types;
2290 size_t i;
2291 for (i =0; i < swig_module->size; ++i) {
2292 swig_type_info *ty = types[i];
2293 if (ty->owndata) {
2294 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2295 if (data) PySwigClientData_Del(data);
2296 }
2297 }
2298 Py_DECREF(SWIG_This());
2299 }
2300
2301 SWIGRUNTIME void
2302 SWIG_Python_SetModule(swig_module_info *swig_module) {
2303 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2304
2305 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2306 swig_empty_runtime_method_table);
2307 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2308 if (pointer && module) {
2309 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2310 } else {
2311 Py_XDECREF(pointer);
2312 }
2313 }
2314
2315 /* The python cached type query */
2316 SWIGRUNTIME PyObject *
2317 SWIG_Python_TypeCache() {
2318 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2319 return cache;
2320 }
2321
2322 SWIGRUNTIME swig_type_info *
2323 SWIG_Python_TypeQuery(const char *type)
2324 {
2325 PyObject *cache = SWIG_Python_TypeCache();
2326 PyObject *key = PyString_FromString(type);
2327 PyObject *obj = PyDict_GetItem(cache, key);
2328 swig_type_info *descriptor;
2329 if (obj) {
2330 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2331 } else {
2332 swig_module_info *swig_module = SWIG_Python_GetModule();
2333 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2334 if (descriptor) {
2335 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2336 PyDict_SetItem(cache, key, obj);
2337 Py_DECREF(obj);
2338 }
2339 }
2340 Py_DECREF(key);
2341 return descriptor;
2342 }
2343
2344 /*
2345 For backward compatibility only
2346 */
2347 #define SWIG_POINTER_EXCEPTION 0
2348 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2349 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2350
2351 SWIGRUNTIME int
2352 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2353 {
2354 if (PyErr_Occurred()) {
2355 PyObject *type = 0;
2356 PyObject *value = 0;
2357 PyObject *traceback = 0;
2358 PyErr_Fetch(&type, &value, &traceback);
2359 if (value) {
2360 PyObject *old_str = PyObject_Str(value);
2361 Py_XINCREF(type);
2362 PyErr_Clear();
2363 if (infront) {
2364 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2365 } else {
2366 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2367 }
2368 Py_DECREF(old_str);
2369 }
2370 return 1;
2371 } else {
2372 return 0;
2373 }
2374 }
2375
2376 SWIGRUNTIME int
2377 SWIG_Python_ArgFail(int argnum)
2378 {
2379 if (PyErr_Occurred()) {
2380 /* add information about failing argument */
2381 char mesg[256];
2382 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2383 return SWIG_Python_AddErrMesg(mesg, 1);
2384 } else {
2385 return 0;
2386 }
2387 }
2388
2389 SWIGRUNTIMEINLINE const char *
2390 PySwigObject_GetDesc(PyObject *self)
2391 {
2392 PySwigObject *v = (PySwigObject *)self;
2393 swig_type_info *ty = v ? v->ty : 0;
2394 return ty ? ty->str : (char*)"";
2395 }
2396
2397 SWIGRUNTIME void
2398 SWIG_Python_TypeError(const char *type, PyObject *obj)
2399 {
2400 if (type) {
2401 #if defined(SWIG_COBJECT_TYPES)
2402 if (obj && PySwigObject_Check(obj)) {
2403 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2404 if (otype) {
2405 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2406 type, otype);
2407 return;
2408 }
2409 } else
2410 #endif
2411 {
2412 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2413 if (otype) {
2414 PyObject *str = PyObject_Str(obj);
2415 const char *cstr = str ? PyString_AsString(str) : 0;
2416 if (cstr) {
2417 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2418 type, otype, cstr);
2419 } else {
2420 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2421 type, otype);
2422 }
2423 Py_XDECREF(str);
2424 return;
2425 }
2426 }
2427 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2428 } else {
2429 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2430 }
2431 }
2432
2433
2434 /* Convert a pointer value, signal an exception on a type mismatch */
2435 SWIGRUNTIME void *
2436 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2437 void *result;
2438 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2439 PyErr_Clear();
2440 if (flags & SWIG_POINTER_EXCEPTION) {
2441 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2442 SWIG_Python_ArgFail(argnum);
2443 }
2444 }
2445 return result;
2446 }
2447
2448
2449 #ifdef __cplusplus
2450 #if 0
2451 { /* cc-mode */
2452 #endif
2453 }
2454 #endif
2455
2456
2457
2458 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2459
2460 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2461
2462
2463
2464 /* -------- TYPES TABLE (BEGIN) -------- */
2465
2466 #define SWIGTYPE_p_buffer swig_types[0]
2467 #define SWIGTYPE_p_char swig_types[1]
2468 #define SWIGTYPE_p_form_ops_t swig_types[2]
2469 #define SWIGTYPE_p_int swig_types[3]
2470 #define SWIGTYPE_p_long swig_types[4]
2471 #define SWIGTYPE_p_unsigned_char swig_types[5]
2472 #define SWIGTYPE_p_unsigned_int swig_types[6]
2473 #define SWIGTYPE_p_unsigned_long swig_types[7]
2474 #define SWIGTYPE_p_wxANIHandler swig_types[8]
2475 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[9]
2476 #define SWIGTYPE_p_wxAcceleratorTable swig_types[10]
2477 #define SWIGTYPE_p_wxActivateEvent swig_types[11]
2478 #define SWIGTYPE_p_wxAppTraits swig_types[12]
2479 #define SWIGTYPE_p_wxArrayString swig_types[13]
2480 #define SWIGTYPE_p_wxBMPHandler swig_types[14]
2481 #define SWIGTYPE_p_wxBitmap swig_types[15]
2482 #define SWIGTYPE_p_wxBoxSizer swig_types[16]
2483 #define SWIGTYPE_p_wxButton swig_types[17]
2484 #define SWIGTYPE_p_wxCURHandler swig_types[18]
2485 #define SWIGTYPE_p_wxCaret swig_types[19]
2486 #define SWIGTYPE_p_wxChildFocusEvent swig_types[20]
2487 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[21]
2488 #define SWIGTYPE_p_wxCloseEvent swig_types[22]
2489 #define SWIGTYPE_p_wxColour swig_types[23]
2490 #define SWIGTYPE_p_wxCommandEvent swig_types[24]
2491 #define SWIGTYPE_p_wxContextMenuEvent swig_types[25]
2492 #define SWIGTYPE_p_wxControl swig_types[26]
2493 #define SWIGTYPE_p_wxControlWithItems swig_types[27]
2494 #define SWIGTYPE_p_wxCursor swig_types[28]
2495 #define SWIGTYPE_p_wxDC swig_types[29]
2496 #define SWIGTYPE_p_wxDateEvent swig_types[30]
2497 #define SWIGTYPE_p_wxDateTime swig_types[31]
2498 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[32]
2499 #define SWIGTYPE_p_wxDropFilesEvent swig_types[33]
2500 #define SWIGTYPE_p_wxDuplexMode swig_types[34]
2501 #define SWIGTYPE_p_wxEraseEvent swig_types[35]
2502 #define SWIGTYPE_p_wxEvent swig_types[36]
2503 #define SWIGTYPE_p_wxEventLoop swig_types[37]
2504 #define SWIGTYPE_p_wxEventLoopActivator swig_types[38]
2505 #define SWIGTYPE_p_wxEvtHandler swig_types[39]
2506 #define SWIGTYPE_p_wxFSFile swig_types[40]
2507 #define SWIGTYPE_p_wxFileSystem swig_types[41]
2508 #define SWIGTYPE_p_wxFileSystemHandler swig_types[42]
2509 #define SWIGTYPE_p_wxFlexGridSizer swig_types[43]
2510 #define SWIGTYPE_p_wxFocusEvent swig_types[44]
2511 #define SWIGTYPE_p_wxFont swig_types[45]
2512 #define SWIGTYPE_p_wxFrame swig_types[46]
2513 #define SWIGTYPE_p_wxGBPosition swig_types[47]
2514 #define SWIGTYPE_p_wxGBSizerItem swig_types[48]
2515 #define SWIGTYPE_p_wxGBSpan swig_types[49]
2516 #define SWIGTYPE_p_wxGIFHandler swig_types[50]
2517 #define SWIGTYPE_p_wxGridBagSizer swig_types[51]
2518 #define SWIGTYPE_p_wxGridSizer swig_types[52]
2519 #define SWIGTYPE_p_wxHelpEvent__Origin swig_types[53]
2520 #define SWIGTYPE_p_wxICOHandler swig_types[54]
2521 #define SWIGTYPE_p_wxIconizeEvent swig_types[55]
2522 #define SWIGTYPE_p_wxIdleEvent swig_types[56]
2523 #define SWIGTYPE_p_wxImage swig_types[57]
2524 #define SWIGTYPE_p_wxImageHandler swig_types[58]
2525 #define SWIGTYPE_p_wxImageHistogram swig_types[59]
2526 #define SWIGTYPE_p_wxImage_HSVValue swig_types[60]
2527 #define SWIGTYPE_p_wxImage_RGBValue swig_types[61]
2528 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[62]
2529 #define SWIGTYPE_p_wxInitDialogEvent swig_types[63]
2530 #define SWIGTYPE_p_wxInputStream swig_types[64]
2531 #define SWIGTYPE_p_wxInternetFSHandler swig_types[65]
2532 #define SWIGTYPE_p_wxItemContainer swig_types[66]
2533 #define SWIGTYPE_p_wxJPEGHandler swig_types[67]
2534 #define SWIGTYPE_p_wxKeyEvent swig_types[68]
2535 #define SWIGTYPE_p_wxLayoutConstraints swig_types[69]
2536 #define SWIGTYPE_p_wxMaximizeEvent swig_types[70]
2537 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[71]
2538 #define SWIGTYPE_p_wxMenu swig_types[72]
2539 #define SWIGTYPE_p_wxMenuBar swig_types[73]
2540 #define SWIGTYPE_p_wxMenuBarBase swig_types[74]
2541 #define SWIGTYPE_p_wxMenuEvent swig_types[75]
2542 #define SWIGTYPE_p_wxMenuItem swig_types[76]
2543 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[77]
2544 #define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[78]
2545 #define SWIGTYPE_p_wxMouseEvent swig_types[79]
2546 #define SWIGTYPE_p_wxMoveEvent swig_types[80]
2547 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[81]
2548 #define SWIGTYPE_p_wxNcPaintEvent swig_types[82]
2549 #define SWIGTYPE_p_wxNotifyEvent swig_types[83]
2550 #define SWIGTYPE_p_wxObject swig_types[84]
2551 #define SWIGTYPE_p_wxOutputStream swig_types[85]
2552 #define SWIGTYPE_p_wxPCXHandler swig_types[86]
2553 #define SWIGTYPE_p_wxPNGHandler swig_types[87]
2554 #define SWIGTYPE_p_wxPNMHandler swig_types[88]
2555 #define SWIGTYPE_p_wxPaintEvent swig_types[89]
2556 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[90]
2557 #define SWIGTYPE_p_wxPaperSize swig_types[91]
2558 #define SWIGTYPE_p_wxPoint swig_types[92]
2559 #define SWIGTYPE_p_wxPoint2D swig_types[93]
2560 #define SWIGTYPE_p_wxPropagateOnce swig_types[94]
2561 #define SWIGTYPE_p_wxPropagationDisabler swig_types[95]
2562 #define SWIGTYPE_p_wxPyApp swig_types[96]
2563 #define SWIGTYPE_p_wxPyCommandEvent swig_types[97]
2564 #define SWIGTYPE_p_wxPyDropTarget swig_types[98]
2565 #define SWIGTYPE_p_wxPyEvent swig_types[99]
2566 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[100]
2567 #define SWIGTYPE_p_wxPyImageHandler swig_types[101]
2568 #define SWIGTYPE_p_wxPyInputStream swig_types[102]
2569 #define SWIGTYPE_p_wxPySizer swig_types[103]
2570 #define SWIGTYPE_p_wxPyValidator swig_types[104]
2571 #define SWIGTYPE_p_wxQuantize swig_types[105]
2572 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[106]
2573 #define SWIGTYPE_p_wxRealPoint swig_types[107]
2574 #define SWIGTYPE_p_wxRect swig_types[108]
2575 #define SWIGTYPE_p_wxRegion swig_types[109]
2576 #define SWIGTYPE_p_wxScrollEvent swig_types[110]
2577 #define SWIGTYPE_p_wxScrollWinEvent swig_types[111]
2578 #define SWIGTYPE_p_wxSetCursorEvent swig_types[112]
2579 #define SWIGTYPE_p_wxShowEvent swig_types[113]
2580 #define SWIGTYPE_p_wxSize swig_types[114]
2581 #define SWIGTYPE_p_wxSizeEvent swig_types[115]
2582 #define SWIGTYPE_p_wxSizer swig_types[116]
2583 #define SWIGTYPE_p_wxSizerItem swig_types[117]
2584 #define SWIGTYPE_p_wxStaticBox swig_types[118]
2585 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[119]
2586 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[120]
2587 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[121]
2588 #define SWIGTYPE_p_wxTIFFHandler swig_types[122]
2589 #define SWIGTYPE_p_wxToolTip swig_types[123]
2590 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[124]
2591 #define SWIGTYPE_p_wxValidator swig_types[125]
2592 #define SWIGTYPE_p_wxVisualAttributes swig_types[126]
2593 #define SWIGTYPE_p_wxWindow swig_types[127]
2594 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[128]
2595 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[129]
2596 #define SWIGTYPE_p_wxXPMHandler swig_types[130]
2597 #define SWIGTYPE_p_wxZipFSHandler swig_types[131]
2598 static swig_type_info *swig_types[133];
2599 static swig_module_info swig_module = {swig_types, 132, 0, 0, 0, 0};
2600 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2601 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2602
2603 /* -------- TYPES TABLE (END) -------- */
2604
2605 #if (PY_VERSION_HEX <= 0x02000000)
2606 # if !defined(SWIG_PYTHON_CLASSIC)
2607 # error "This python version requires to use swig with the '-classic' option"
2608 # endif
2609 #endif
2610 #if (PY_VERSION_HEX <= 0x02020000)
2611 # error "This python version requires to use swig with the '-nomodern' option"
2612 #endif
2613 #if (PY_VERSION_HEX <= 0x02020000)
2614 # error "This python version requires to use swig with the '-nomodernargs' option"
2615 #endif
2616 #ifndef METH_O
2617 # error "This python version requires to use swig with the '-nofastunpack' option"
2618 #endif
2619
2620 /*-----------------------------------------------
2621 @(target):= _core_.so
2622 ------------------------------------------------*/
2623 #define SWIG_init init_core_
2624
2625 #define SWIG_name "_core_"
2626
2627 #define SWIGVERSION 0x010329
2628
2629
2630 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2631 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2632
2633
2634 #include <stdexcept>
2635
2636
2637 namespace swig {
2638 class PyObject_ptr {
2639 protected:
2640 PyObject *_obj;
2641
2642 public:
2643 PyObject_ptr() :_obj(0)
2644 {
2645 }
2646
2647 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2648 {
2649 Py_XINCREF(_obj);
2650 }
2651
2652 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2653 {
2654 if (initial_ref) Py_XINCREF(_obj);
2655 }
2656
2657 PyObject_ptr & operator=(const PyObject_ptr& item)
2658 {
2659 Py_XINCREF(item._obj);
2660 Py_XDECREF(_obj);
2661 _obj = item._obj;
2662 return *this;
2663 }
2664
2665 ~PyObject_ptr()
2666 {
2667 Py_XDECREF(_obj);
2668 }
2669
2670 operator PyObject *() const
2671 {
2672 return _obj;
2673 }
2674
2675 PyObject *operator->() const
2676 {
2677 return _obj;
2678 }
2679 };
2680 }
2681
2682
2683 namespace swig {
2684 struct PyObject_var : PyObject_ptr {
2685 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2686
2687 PyObject_var & operator = (PyObject* obj)
2688 {
2689 Py_XDECREF(_obj);
2690 _obj = obj;
2691 return *this;
2692 }
2693 };
2694 }
2695
2696
2697 #include "wx/wxPython/wxPython_int.h"
2698 #include "wx/wxPython/pyclasses.h"
2699 #include "wx/wxPython/twoitem.h"
2700
2701
2702 #ifndef wxPyUSE_EXPORT
2703 // Helper functions for dealing with SWIG objects and such. These are
2704 // located here so they know about the SWIG types and functions declared
2705 // in the wrapper code.
2706
2707 #include <wx/hashmap.h>
2708 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
2709
2710
2711 // Maintains a hashmap of className to swig_type_info pointers. Given the
2712 // name of a class either looks up the type info in the cache, or scans the
2713 // SWIG tables for it.
2714 extern PyObject* wxPyPtrTypeMap;
2715 static
2716 swig_type_info* wxPyFindSwigType(const wxChar* className) {
2717
2718 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
2719
2720 if (typeInfoCache == NULL)
2721 typeInfoCache = new wxPyTypeInfoHashMap;
2722
2723 wxString name(className);
2724 swig_type_info* swigType = (*typeInfoCache)[name];
2725
2726 if (! swigType) {
2727 // it wasn't in the cache, so look it up from SWIG
2728 name.Append(wxT(" *"));
2729 swigType = SWIG_TypeQuery(name.mb_str());
2730
2731 // if it still wasn't found, try looking for a mapped name
2732 if (!swigType) {
2733 PyObject* item;
2734 name = className;
2735
2736 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
2737 (char*)(const char*)name.mbc_str())) != NULL) {
2738 name = wxString(PyString_AsString(item), *wxConvCurrent);
2739 name.Append(wxT(" *"));
2740 swigType = SWIG_TypeQuery(name.mb_str());
2741 }
2742 }
2743 if (swigType) {
2744 // and add it to the map if found
2745 (*typeInfoCache)[className] = swigType;
2746 }
2747 }
2748 return swigType;
2749 }
2750
2751
2752 // Check if a class name is a type known to SWIG
2753 bool wxPyCheckSwigType(const wxChar* className) {
2754
2755 swig_type_info* swigType = wxPyFindSwigType(className);
2756 return swigType != NULL;
2757 }
2758
2759
2760 // Given a pointer to a C++ object and a class name, construct a Python proxy
2761 // object for it.
2762 PyObject* wxPyConstructObject(void* ptr,
2763 const wxChar* className,
2764 int setThisOwn) {
2765
2766 swig_type_info* swigType = wxPyFindSwigType(className);
2767 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
2768
2769 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
2770 }
2771
2772
2773 // Extract a pointer to the wrapped C++ object from a Python proxy object.
2774 // Ensures that the proxy object is of the specified (or derived) type. If
2775 // not able to perform the conversion then a Python exception is set and the
2776 // error should be handled properly in the caller. Returns True on success.
2777 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
2778 const wxChar* className) {
2779
2780 swig_type_info* swigType = wxPyFindSwigType(className);
2781 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
2782
2783 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
2784 }
2785
2786
2787
2788 // Make a SWIGified pointer object suitable for a .this attribute
2789 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
2790
2791 PyObject* robj = NULL;
2792
2793 swig_type_info* swigType = wxPyFindSwigType(className);
2794 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyMakeSwigPtr"));
2795
2796 robj = PySwigObject_New(ptr, swigType, 0);
2797 return robj;
2798 }
2799
2800
2801 // Python's PyInstance_Check does not return True for instances of new-style
2802 // classes. This should get close enough for both new and old classes but I
2803 // should re-evaluate the need for doing instance checks...
2804 bool wxPyInstance_Check(PyObject* obj) {
2805 return PyObject_HasAttrString(obj, "__class__") != 0;
2806 }
2807
2808
2809 // This one checks if the object is an instance of a SWIG proxy class (it has
2810 // a .this attribute, and the .this attribute is a PySwigObject.)
2811 bool wxPySwigInstance_Check(PyObject* obj) {
2812 static PyObject* this_str = NULL;
2813 if (this_str == NULL)
2814 this_str = PyString_FromString("this");
2815
2816 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
2817 if (this_attr) {
2818 bool retval = (PySwigObject_Check(this_attr) != 0);
2819 Py_DECREF(this_attr);
2820 return retval;
2821 }
2822
2823 PyErr_Clear();
2824 return false;
2825 }
2826
2827
2828 // Export a C API in a struct. Other modules will be able to load this from
2829 // the wx._core_ module and will then have safe access to these functions,
2830 // even if they are located in another shared library.
2831 static wxPyCoreAPI API = {
2832
2833 wxPyCheckSwigType,
2834 wxPyConstructObject,
2835 wxPyConvertSwigPtr,
2836 wxPyMakeSwigPtr,
2837
2838 wxPyBeginAllowThreads,
2839 wxPyEndAllowThreads,
2840 wxPyBeginBlockThreads,
2841 wxPyEndBlockThreads,
2842
2843 wxPy_ConvertList,
2844
2845 wxString_in_helper,
2846 Py2wxString,
2847 wx2PyString,
2848
2849 byte_LIST_helper,
2850 int_LIST_helper,
2851 long_LIST_helper,
2852 string_LIST_helper,
2853 wxPoint_LIST_helper,
2854 wxBitmap_LIST_helper,
2855 wxString_LIST_helper,
2856 wxAcceleratorEntry_LIST_helper,
2857
2858 wxSize_helper,
2859 wxPoint_helper,
2860 wxRealPoint_helper,
2861 wxRect_helper,
2862 wxColour_helper,
2863 wxPoint2D_helper,
2864
2865 wxPySimple_typecheck,
2866 wxColour_typecheck,
2867
2868 wxPyCBH_setCallbackInfo,
2869 wxPyCBH_findCallback,
2870 wxPyCBH_callCallback,
2871 wxPyCBH_callCallbackObj,
2872 wxPyCBH_delete,
2873
2874 wxPyMake_wxObject,
2875 wxPyMake_wxSizer,
2876 wxPyPtrTypeMap_Add,
2877 wxPy2int_seq_helper,
2878 wxPy4int_seq_helper,
2879 wxArrayString2PyList_helper,
2880 wxArrayInt2PyList_helper,
2881
2882 wxPyClientData_dtor,
2883 wxPyUserData_dtor,
2884 wxPyOORClientData_dtor,
2885
2886 wxPyCBInputStream_create,
2887 wxPyCBInputStream_copy,
2888
2889 wxPyInstance_Check,
2890 wxPySwigInstance_Check,
2891
2892 wxPyCheckForApp
2893
2894 };
2895
2896 #endif
2897
2898
2899 #if !WXWIN_COMPATIBILITY_2_4
2900 #define wxHIDE_READONLY 0
2901 #endif
2902
2903
2904 #define SWIG_From_long PyInt_FromLong
2905
2906
2907 SWIGINTERNINLINE PyObject *
2908 SWIG_From_int (int value)
2909 {
2910 return SWIG_From_long (value);
2911 }
2912
2913 static const wxString wxPyEmptyString(wxEmptyString);
2914 SWIGINTERN wxString wxObject_GetClassName(wxObject *self){
2915 return self->GetClassInfo()->GetClassName();
2916 }
2917 SWIGINTERN void wxObject_Destroy(wxObject *self){
2918 delete self;
2919 }
2920
2921 #ifndef __WXMAC__
2922 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
2923 #endif
2924
2925
2926 #include <limits.h>
2927 #ifndef LLONG_MIN
2928 # define LLONG_MIN LONG_LONG_MIN
2929 #endif
2930 #ifndef LLONG_MAX
2931 # define LLONG_MAX LONG_LONG_MAX
2932 #endif
2933 #ifndef ULLONG_MAX
2934 # define ULLONG_MAX ULONG_LONG_MAX
2935 #endif
2936
2937
2938 SWIGINTERN int
2939 SWIG_AsVal_long (PyObject* obj, long* val)
2940 {
2941 if (PyNumber_Check(obj)) {
2942 if (val) *val = PyInt_AsLong(obj);
2943 return SWIG_OK;
2944 }
2945 return SWIG_TypeError;
2946 }
2947
2948
2949 SWIGINTERN int
2950 SWIG_AsVal_int (PyObject * obj, int *val)
2951 {
2952 long v;
2953 int res = SWIG_AsVal_long (obj, &v);
2954 if (SWIG_IsOK(res)) {
2955 if ((v < INT_MIN || v > INT_MAX)) {
2956 return SWIG_OverflowError;
2957 } else {
2958 if (val) *val = static_cast< int >(v);
2959 }
2960 }
2961 return res;
2962 }
2963
2964 SWIGINTERN bool wxSize___eq__(wxSize *self,PyObject *other){
2965 wxSize temp, *obj = &temp;
2966 if ( other == Py_None ) return false;
2967 if ( ! wxSize_helper(other, &obj) ) {
2968 PyErr_Clear();
2969 return false;
2970 }
2971 return self->operator==(*obj);
2972 }
2973 SWIGINTERN bool wxSize___ne__(wxSize *self,PyObject *other){
2974 wxSize temp, *obj = &temp;
2975 if ( other == Py_None ) return true;
2976 if ( ! wxSize_helper(other, &obj)) {
2977 PyErr_Clear();
2978 return true;
2979 }
2980 return self->operator!=(*obj);
2981 }
2982
2983 #include <float.h>
2984
2985
2986 SWIGINTERN int
2987 SWIG_AsVal_double (PyObject *obj, double* val)
2988 {
2989 if (PyNumber_Check(obj)) {
2990 if (val) *val = PyFloat_AsDouble(obj);
2991 return SWIG_OK;
2992 }
2993 return SWIG_TypeError;
2994 }
2995
2996
2997 SWIGINTERN int
2998 SWIG_AsVal_float (PyObject * obj, float *val)
2999 {
3000 double v;
3001 int res = SWIG_AsVal_double (obj, &v);
3002 if (SWIG_IsOK(res)) {
3003 if ((v < -FLT_MAX || v > FLT_MAX)) {
3004 return SWIG_OverflowError;
3005 } else {
3006 if (val) *val = static_cast< float >(v);
3007 }
3008 }
3009 return res;
3010 }
3011
3012 SWIGINTERN PyObject *wxSize_Get(wxSize *self){
3013 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3014 PyObject* tup = PyTuple_New(2);
3015 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3016 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3017 wxPyEndBlockThreads(blocked);
3018 return tup;
3019 }
3020
3021 #define SWIG_From_double PyFloat_FromDouble
3022
3023 SWIGINTERN bool wxRealPoint___eq__(wxRealPoint *self,PyObject *other){
3024 wxRealPoint temp, *obj = &temp;
3025 if ( other == Py_None ) return false;
3026 if ( ! wxRealPoint_helper(other, &obj) ) {
3027 PyErr_Clear();
3028 return false;
3029 }
3030 return self->operator==(*obj);
3031 }
3032 SWIGINTERN bool wxRealPoint___ne__(wxRealPoint *self,PyObject *other){
3033 wxRealPoint temp, *obj = &temp;
3034 if ( other == Py_None ) return true;
3035 if ( ! wxRealPoint_helper(other, &obj)) {
3036 PyErr_Clear();
3037 return true;
3038 }
3039 return self->operator!=(*obj);
3040 }
3041 SWIGINTERN void wxRealPoint_Set(wxRealPoint *self,double x,double y){
3042 self->x = x;
3043 self->y = y;
3044 }
3045 SWIGINTERN PyObject *wxRealPoint_Get(wxRealPoint *self){
3046 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3047 PyObject* tup = PyTuple_New(2);
3048 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
3049 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
3050 wxPyEndBlockThreads(blocked);
3051 return tup;
3052 }
3053 SWIGINTERN bool wxPoint___eq__(wxPoint *self,PyObject *other){
3054 wxPoint temp, *obj = &temp;
3055 if ( other == Py_None ) return false;
3056 if ( ! wxPoint_helper(other, &obj) ) {
3057 PyErr_Clear();
3058 return false;
3059 }
3060 return self->operator==(*obj);
3061 }
3062 SWIGINTERN bool wxPoint___ne__(wxPoint *self,PyObject *other){
3063 wxPoint temp, *obj = &temp;
3064 if ( other == Py_None ) return true;
3065 if ( ! wxPoint_helper(other, &obj)) {
3066 PyErr_Clear();
3067 return true;
3068 }
3069 return self->operator!=(*obj);
3070 }
3071 SWIGINTERN void wxPoint_Set(wxPoint *self,long x,long y){
3072 self->x = x;
3073 self->y = y;
3074 }
3075 SWIGINTERN PyObject *wxPoint_Get(wxPoint *self){
3076 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3077 PyObject* tup = PyTuple_New(2);
3078 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3079 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3080 wxPyEndBlockThreads(blocked);
3081 return tup;
3082 }
3083 SWIGINTERN bool wxRect___eq__(wxRect *self,PyObject *other){
3084 wxRect temp, *obj = &temp;
3085 if ( other == Py_None ) return false;
3086 if ( ! wxRect_helper(other, &obj) ) {
3087 PyErr_Clear();
3088 return false;
3089 }
3090 return self->operator==(*obj);
3091 }
3092 SWIGINTERN bool wxRect___ne__(wxRect *self,PyObject *other){
3093 wxRect temp, *obj = &temp;
3094 if ( other == Py_None ) return true;
3095 if ( ! wxRect_helper(other, &obj)) {
3096 PyErr_Clear();
3097 return true;
3098 }
3099 return self->operator!=(*obj);
3100 }
3101 SWIGINTERN void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
3102 self->x = x;
3103 self->y = y;
3104 self->width = width;
3105 self->height = height;
3106 }
3107 SWIGINTERN PyObject *wxRect_Get(wxRect *self){
3108 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3109 PyObject* tup = PyTuple_New(4);
3110 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3111 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3112 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
3113 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
3114 wxPyEndBlockThreads(blocked);
3115 return tup;
3116 }
3117
3118 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
3119 wxRegion reg1(*r1);
3120 wxRegion reg2(*r2);
3121 wxRect dest(0,0,0,0);
3122 PyObject* obj;
3123
3124 reg1.Intersect(reg2);
3125 dest = reg1.GetBox();
3126
3127 if (dest != wxRect(0,0,0,0)) {
3128 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3129 wxRect* newRect = new wxRect(dest);
3130 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
3131 wxPyEndBlockThreads(blocked);
3132 return obj;
3133 }
3134 Py_INCREF(Py_None);
3135 return Py_None;
3136 }
3137
3138 SWIGINTERN bool wxPoint2D___eq__(wxPoint2D *self,PyObject *other){
3139 wxPoint2D temp, *obj = &temp;
3140 if ( other == Py_None ) return false;
3141 if ( ! wxPoint2D_helper(other, &obj) ) {
3142 PyErr_Clear();
3143 return false;
3144 }
3145 return self->operator==(*obj);
3146 }
3147 SWIGINTERN bool wxPoint2D___ne__(wxPoint2D *self,PyObject *other){
3148 wxPoint2D temp, *obj = &temp;
3149 if ( other == Py_None ) return true;
3150 if ( ! wxPoint2D_helper(other, &obj)) {
3151 PyErr_Clear();
3152 return true;
3153 }
3154 return self->operator!=(*obj);
3155 }
3156 SWIGINTERN void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
3157 self->m_x = x;
3158 self->m_y = y;
3159 }
3160 SWIGINTERN PyObject *wxPoint2D_Get(wxPoint2D *self){
3161 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3162 PyObject* tup = PyTuple_New(2);
3163 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3164 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3165 wxPyEndBlockThreads(blocked);
3166 return tup;
3167 }
3168
3169 #include "wx/wxPython/pyistream.h"
3170
3171 SWIGINTERN wxPyInputStream *new_wxPyInputStream(PyObject *p){
3172 wxInputStream* wxis = wxPyCBInputStream::create(p);
3173 if (wxis)
3174 return new wxPyInputStream(wxis);
3175 else
3176 return NULL;
3177 }
3178
3179 SWIGINTERN swig_type_info*
3180 SWIG_pchar_descriptor()
3181 {
3182 static int init = 0;
3183 static swig_type_info* info = 0;
3184 if (!init) {
3185 info = SWIG_TypeQuery("_p_char");
3186 init = 1;
3187 }
3188 return info;
3189 }
3190
3191
3192 SWIGINTERNINLINE PyObject *
3193 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3194 {
3195 if (carray) {
3196 if (size > INT_MAX) {
3197 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3198 return pchar_descriptor ?
3199 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3200 } else {
3201 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3202 }
3203 } else {
3204 return SWIG_Py_Void();
3205 }
3206 }
3207
3208
3209 SWIGINTERNINLINE PyObject *
3210 SWIG_From_char (char c)
3211 {
3212 return SWIG_FromCharPtrAndSize(&c,1);
3213 }
3214
3215
3216 SWIGINTERNINLINE PyObject*
3217 SWIG_From_unsigned_SS_long (unsigned long value)
3218 {
3219 return (value > LONG_MAX) ?
3220 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3221 }
3222
3223
3224 SWIGINTERNINLINE PyObject *
3225 SWIG_From_size_t (size_t value)
3226 {
3227 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3228 }
3229
3230
3231 SWIGINTERN int
3232 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3233 {
3234 if (PyString_Check(obj)) {
3235 char *cstr; Py_ssize_t len;
3236 PyString_AsStringAndSize(obj, &cstr, &len);
3237 if (cptr) {
3238 if (alloc) {
3239 /*
3240 In python the user should not be able to modify the inner
3241 string representation. To warranty that, if you define
3242 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3243 buffer is always returned.
3244
3245 The default behavior is just to return the pointer value,
3246 so, be careful.
3247 */
3248 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3249 if (*alloc != SWIG_OLDOBJ)
3250 #else
3251 if (*alloc == SWIG_NEWOBJ)
3252 #endif
3253 {
3254 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3255 *alloc = SWIG_NEWOBJ;
3256 }
3257 else {
3258 *cptr = cstr;
3259 *alloc = SWIG_OLDOBJ;
3260 }
3261 } else {
3262 *cptr = PyString_AsString(obj);
3263 }
3264 }
3265 if (psize) *psize = len + 1;
3266 return SWIG_OK;
3267 } else {
3268 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3269 if (pchar_descriptor) {
3270 void* vptr = 0;
3271 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3272 if (cptr) *cptr = (char *) vptr;
3273 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3274 if (alloc) *alloc = SWIG_OLDOBJ;
3275 return SWIG_OK;
3276 }
3277 }
3278 }
3279 return SWIG_TypeError;
3280 }
3281
3282
3283 SWIGINTERN int
3284 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3285 {
3286 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3287 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3288 if (SWIG_IsOK(res)) {
3289 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3290 if (csize <= size) {
3291 if (val) {
3292 if (csize) memcpy(val, cptr, csize*sizeof(char));
3293 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3294 }
3295 if (alloc == SWIG_NEWOBJ) {
3296 delete[] cptr;
3297 res = SWIG_DelNewMask(res);
3298 }
3299 return res;
3300 }
3301 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3302 }
3303 return SWIG_TypeError;
3304 }
3305
3306
3307 SWIGINTERN int
3308 SWIG_AsVal_char (PyObject * obj, char *val)
3309 {
3310 int res = SWIG_AsCharArray(obj, val, 1);
3311 if (!SWIG_IsOK(res)) {
3312 long v;
3313 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3314 if (SWIG_IsOK(res)) {
3315 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3316 if (val) *val = static_cast< char >(v);
3317 } else {
3318 res = SWIG_OverflowError;
3319 }
3320 }
3321 }
3322 return res;
3323 }
3324
3325 SWIGINTERN void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
3326 // We use only strings for the streams, not unicode
3327 PyObject* str = PyObject_Str(obj);
3328 if (! str) {
3329 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
3330 return;
3331 }
3332 self->Write(PyString_AS_STRING(str),
3333 PyString_GET_SIZE(str));
3334 Py_DECREF(str);
3335 }
3336
3337 #include "wx/wxPython/pyistream.h"
3338
3339
3340 class wxPyFileSystemHandler : public wxFileSystemHandler
3341 {
3342 public:
3343 wxPyFileSystemHandler() : wxFileSystemHandler() {}
3344
3345 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
3346 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
3347 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
3348 DEC_PYCALLBACK_STRING__pure(FindNext);
3349
3350 wxString GetProtocol(const wxString& location) {
3351 return wxFileSystemHandler::GetProtocol(location);
3352 }
3353
3354 wxString GetLeftLocation(const wxString& location) {
3355 return wxFileSystemHandler::GetLeftLocation(location);
3356 }
3357
3358 wxString GetAnchor(const wxString& location) {
3359 return wxFileSystemHandler::GetAnchor(location);
3360 }
3361
3362 wxString GetRightLocation(const wxString& location) {
3363 return wxFileSystemHandler::GetRightLocation(location);
3364 }
3365
3366 wxString GetMimeTypeFromExt(const wxString& location) {
3367 return wxFileSystemHandler::GetMimeTypeFromExt(location);
3368 }
3369
3370 PYPRIVATE;
3371 };
3372
3373
3374 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
3375 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
3376 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
3377 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
3378
3379
3380 SWIGINTERN int
3381 SWIG_AsVal_bool (PyObject *obj, bool *val)
3382 {
3383 if (obj == Py_True) {
3384 if (val) *val = true;
3385 return SWIG_OK;
3386 } else if (obj == Py_False) {
3387 if (val) *val = false;
3388 return SWIG_OK;
3389 } else {
3390 long v = 0;
3391 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3392 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3393 return res;
3394 }
3395 }
3396
3397 SWIGINTERN wxString wxFileSystem_URLToFileName(wxString const &url){
3398 wxFileName fname = wxFileSystem::URLToFileName(url);
3399 return fname.GetFullPath();
3400 }
3401
3402 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
3403 wxImage& image,
3404 long type) {
3405 wxMemoryFSHandler::AddFile(filename, image, type);
3406 }
3407
3408 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
3409 const wxBitmap& bitmap,
3410 long type) {
3411 wxMemoryFSHandler::AddFile(filename, bitmap, type);
3412 }
3413
3414 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
3415 PyObject* data) {
3416 if (! PyString_Check(data)) {
3417 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
3418 "Expected string object"));
3419 return;
3420 }
3421
3422 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3423 void* ptr = (void*)PyString_AsString(data);
3424 size_t size = PyString_Size(data);
3425 wxPyEndBlockThreads(blocked);
3426
3427 wxMemoryFSHandler::AddFile(filename, ptr, size);
3428 }
3429
3430
3431 #include "wx/wxPython/pyistream.h"
3432
3433
3434 SWIGINTERN int
3435 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3436 {
3437 long v = 0;
3438 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3439 return SWIG_TypeError;
3440 }
3441 else if (val)
3442 *val = (unsigned long)v;
3443 return SWIG_OK;
3444 }
3445
3446
3447 SWIGINTERN int
3448 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
3449 {
3450 unsigned long v;
3451 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3452 if (SWIG_IsOK(res)) {
3453 if ((v > UCHAR_MAX)) {
3454 return SWIG_OverflowError;
3455 } else {
3456 if (val) *val = static_cast< unsigned char >(v);
3457 }
3458 }
3459 return res;
3460 }
3461
3462
3463 SWIGINTERNINLINE PyObject *
3464 SWIG_From_unsigned_SS_char (unsigned char value)
3465 {
3466 return SWIG_From_unsigned_SS_long (value);
3467 }
3468
3469 SWIGINTERN unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
3470 wxImageHistogramEntry e = (*self)[key];
3471 return e.value;
3472 }
3473 SWIGINTERN unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
3474 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
3475 wxImageHistogramEntry e = (*self)[key];
3476 return e.value;
3477 }
3478 SWIGINTERN unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
3479 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
3480 colour.Green(),
3481 colour.Blue());
3482 wxImageHistogramEntry e = (*self)[key];
3483 return e.value;
3484 }
3485
3486 // Pull the nested class out to the top level for SWIG's sake
3487 #define wxImage_RGBValue wxImage::RGBValue
3488 #define wxImage_HSVValue wxImage::HSVValue
3489
3490 SWIGINTERN wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
3491 if (width > 0 && height > 0)
3492 return new wxImage(width, height, clear);
3493 else
3494 return new wxImage;
3495 }
3496 SWIGINTERN wxImage *new_wxImage(wxBitmap const &bitmap){
3497 return new wxImage(bitmap.ConvertToImage());
3498 }
3499 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
3500 if (DATASIZE != width*height*3) {
3501 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3502 return NULL;
3503 }
3504
3505 // Copy the source data so the wxImage can clean it up later
3506 buffer copy = (buffer)malloc(DATASIZE);
3507 if (copy == NULL) {
3508 wxPyBLOCK_THREADS(PyErr_NoMemory());
3509 return NULL;
3510 }
3511 memcpy(copy, data, DATASIZE);
3512 return new wxImage(width, height, copy, false);
3513 }
3514 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
3515 if (DATASIZE != width*height*3) {
3516 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3517 return NULL;
3518 }
3519 if (ALPHASIZE != width*height) {
3520 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3521 return NULL;
3522 }
3523
3524 // Copy the source data so the wxImage can clean it up later
3525 buffer dcopy = (buffer)malloc(DATASIZE);
3526 if (dcopy == NULL) {
3527 wxPyBLOCK_THREADS(PyErr_NoMemory());
3528 return NULL;
3529 }
3530 memcpy(dcopy, data, DATASIZE);
3531
3532 buffer acopy = (buffer)malloc(ALPHASIZE);
3533 if (acopy == NULL) {
3534 wxPyBLOCK_THREADS(PyErr_NoMemory());
3535 return NULL;
3536 }
3537 memcpy(acopy, alpha, ALPHASIZE);
3538
3539 return new wxImage(width, height, dcopy, acopy, false);
3540 }
3541 SWIGINTERN wxSize wxImage_GetSize(wxImage *self){
3542 wxSize size(self->GetWidth(), self->GetHeight());
3543 return size;
3544 }
3545 SWIGINTERN PyObject *wxImage_GetData(wxImage *self){
3546 buffer data = self->GetData();
3547 int len = self->GetWidth() * self->GetHeight() * 3;
3548 PyObject* rv;
3549 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
3550 return rv;
3551 }
3552 SWIGINTERN void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
3553 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3554 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3555 return;
3556 }
3557 buffer copy = (buffer)malloc(DATASIZE);
3558 if (copy == NULL) {
3559 wxPyBLOCK_THREADS(PyErr_NoMemory());
3560 return;
3561 }
3562 memcpy(copy, data, DATASIZE);
3563 self->SetData(copy, false);
3564 // wxImage takes ownership of copy...
3565 }
3566 SWIGINTERN PyObject *wxImage_GetDataBuffer(wxImage *self){
3567 buffer data = self->GetData();
3568 int len = self->GetWidth() * self->GetHeight() * 3;
3569 PyObject* rv;
3570 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3571 return rv;
3572 }
3573 SWIGINTERN void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
3574 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3575 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3576 return;
3577 }
3578 self->SetData(data, true);
3579 }
3580 SWIGINTERN PyObject *wxImage_GetAlphaData(wxImage *self){
3581 buffer data = self->GetAlpha();
3582 if (! data) {
3583 RETURN_NONE();
3584 } else {
3585 int len = self->GetWidth() * self->GetHeight();
3586 PyObject* rv;
3587 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
3588 return rv;
3589 }
3590 }
3591 SWIGINTERN void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
3592 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3593 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3594 return;
3595 }
3596 buffer acopy = (buffer)malloc(ALPHASIZE);
3597 if (acopy == NULL) {
3598 wxPyBLOCK_THREADS(PyErr_NoMemory());
3599 return;
3600 }
3601 memcpy(acopy, alpha, ALPHASIZE);
3602 self->SetAlpha(acopy, false);
3603 // wxImage takes ownership of acopy...
3604 }
3605 SWIGINTERN PyObject *wxImage_GetAlphaBuffer(wxImage *self){
3606 buffer data = self->GetAlpha();
3607 int len = self->GetWidth() * self->GetHeight();
3608 PyObject* rv;
3609 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3610 return rv;
3611 }
3612 SWIGINTERN void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
3613 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3614 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3615 return;
3616 }
3617 self->SetAlpha(alpha, true);
3618 }
3619 SWIGINTERN PyObject *wxImage_GetHandlers(){
3620 wxList& list = wxImage::GetHandlers();
3621 return wxPy_ConvertList(&list);
3622 }
3623 SWIGINTERN wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
3624 wxBitmap bitmap(*self, depth);
3625 return bitmap;
3626 }
3627 SWIGINTERN wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
3628 wxImage mono = self->ConvertToMono( red, green, blue );
3629 wxBitmap bitmap( mono, 1 );
3630 return bitmap;
3631 }
3632
3633 wxImage* _ImageFromBuffer(int width, int height,
3634 buffer data, int DATASIZE,
3635 buffer alpha=NULL, int ALPHASIZE=0)
3636 {
3637 if (DATASIZE != width*height*3) {
3638 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3639 return NULL;
3640 }
3641 if (alpha != NULL) {
3642 if (ALPHASIZE != width*height) {
3643 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3644 return NULL;
3645 }
3646 return new wxImage(width, height, data, alpha, true);
3647 }
3648 return new wxImage(width, height, data, true);
3649 }
3650
3651 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
3652 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3653 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3654 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3655 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
3656 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3657 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
3658 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
3659 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
3660 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3661 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3662 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3663 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
3664 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3665 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
3666
3667 #include <wx/quantize.h>
3668
3669 SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
3670 return wxQuantize::Quantize(src, dest,
3671 //NULL, // palette
3672 desiredNoColours,
3673 NULL, // eightBitData
3674 flags);
3675 }
3676 SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
3677 if (PyCallable_Check(func)) {
3678 self->Connect(id, lastId, eventType,
3679 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3680 new wxPyCallback(func));
3681 }
3682 else if (func == Py_None) {
3683 self->Disconnect(id, lastId, eventType,
3684 (wxObjectEventFunction)
3685 &wxPyCallback::EventThunker);
3686 }
3687 else {
3688 wxPyBLOCK_THREADS(
3689 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3690 }
3691 }
3692 SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
3693 return self->Disconnect(id, lastId, eventType,
3694 (wxObjectEventFunction)
3695 &wxPyCallback::EventThunker);
3696 }
3697 SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
3698 if (_self && _self != Py_None) {
3699 self->SetClientObject(new wxPyOORClientData(_self, incref));
3700 }
3701 else {
3702 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3703 if (data) {
3704 self->SetClientObject(NULL); // This will delete it too
3705 }
3706 }
3707 }
3708
3709 #if ! wxUSE_HOTKEY
3710 #define wxEVT_HOTKEY -9999
3711 #endif
3712
3713 SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3714 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3715 if (data) {
3716 Py_INCREF(data->m_obj);
3717 return data->m_obj;
3718 } else {
3719 Py_INCREF(Py_None);
3720 return Py_None;
3721 }
3722 }
3723 SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3724 wxPyClientData* data = new wxPyClientData(clientData);
3725 self->SetClientObject(data);
3726 }
3727 SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
3728 #if wxUSE_UNICODE
3729 return self->GetUnicodeKey();
3730 #else
3731 return 0;
3732 #endif
3733 }
3734 SWIGINTERN void wxKeyEvent_SetUnicodeKey(wxKeyEvent *self,int uniChar){
3735 #if wxUSE_UNICODE
3736 self->m_uniChar = uniChar;
3737 #endif
3738 }
3739
3740 SWIGINTERNINLINE PyObject *
3741 SWIG_From_unsigned_SS_int (unsigned int value)
3742 {
3743 return SWIG_From_unsigned_SS_long (value);
3744 }
3745
3746
3747 SWIGINTERN int
3748 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3749 {
3750 unsigned long v;
3751 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3752 if (SWIG_IsOK(res)) {
3753 if ((v > UINT_MAX)) {
3754 return SWIG_OverflowError;
3755 } else {
3756 if (val) *val = static_cast< unsigned int >(v);
3757 }
3758 }
3759 return res;
3760 }
3761
3762 SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
3763 self->m_size = size;
3764 }
3765 SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
3766 int count = self->GetNumberOfFiles();
3767 wxString* files = self->GetFiles();
3768 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3769 PyObject* list = PyList_New(count);
3770
3771 if (!list) {
3772 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
3773 wxPyEndBlockThreads(blocked);
3774 return NULL;
3775 }
3776
3777 for (int i=0; i<count; i++) {
3778 PyList_SetItem(list, i, wx2PyString(files[i]));
3779 }
3780 wxPyEndBlockThreads(blocked);
3781 return list;
3782 }
3783
3784
3785 SWIGINTERN wxPyApp *new_wxPyApp(){
3786 wxPythonApp = new wxPyApp();
3787 return wxPythonApp;
3788 }
3789 SWIGINTERN int wxPyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
3790 SWIGINTERN bool wxPyApp_IsDisplayAvailable(){
3791 return wxPyTestDisplayAvailable();
3792 }
3793
3794 void wxApp_CleanUp() {
3795 __wxPyCleanup();
3796 }
3797
3798
3799 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
3800
3801
3802
3803
3804
3805 SWIGINTERNINLINE PyObject *
3806 SWIG_FromCharPtr(const char *cptr)
3807 {
3808 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3809 }
3810
3811
3812 #if 0 // #ifdef __WXMAC__
3813
3814 // A dummy class that raises an exception if used...
3815 class wxEventLoop
3816 {
3817 public:
3818 wxEventLoop() { wxPyRaiseNotImplemented(); }
3819 int Run() { return 0; }
3820 void Exit(int rc = 0) {}
3821 bool Pending() const { return false; }
3822 bool Dispatch() { return false; }
3823 bool IsRunning() const { return false; }
3824 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3825 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3826 };
3827
3828 #else
3829
3830 #include <wx/evtloop.h>
3831
3832 #endif
3833
3834
3835
3836 static const wxString wxPyPanelNameStr(wxPanelNameStr);
3837 SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3838 SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3839 SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
3840 wxWindowList& list = self->GetChildren();
3841 return wxPy_ConvertList(&list);
3842 }
3843 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3844 #if wxUSE_HOTKEY
3845 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3846 #else
3847 return false;
3848 #endif
3849 }
3850 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3851
3852
3853
3854 return false;
3855
3856 }
3857 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3858 return wxPyGetWinHandle(self);
3859 }
3860 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3861 self->AssociateHandle((WXWidget)handle);
3862 }
3863 SWIGINTERN void wxWindow_DragAcceptFiles(wxWindow *self,bool accept){}
3864
3865 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3866 return wxWindow::FindWindowById(id, parent);
3867 }
3868
3869 wxWindow* wxFindWindowByName( const wxString& name,
3870 const wxWindow *parent = NULL ) {
3871 return wxWindow::FindWindowByName(name, parent);
3872 }
3873
3874 wxWindow* wxFindWindowByLabel( const wxString& label,
3875 const wxWindow *parent = NULL ) {
3876 return wxWindow::FindWindowByLabel(label, parent);
3877 }
3878
3879
3880 #ifdef __WXMSW__
3881 #include <wx/msw/private.h> // to get wxGetWindowId
3882 #endif
3883
3884
3885 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3886 #ifdef __WXMSW__
3887 WXHWND hWnd = (WXHWND)_hWnd;
3888 long id = wxGetWindowId(hWnd);
3889 wxWindow* win = new wxWindow;
3890 if (parent)
3891 parent->AddChild(win);
3892 win->SetEventHandler(win);
3893 win->SetHWND(hWnd);
3894 win->SetId(id);
3895 win->SubclassWin(hWnd);
3896 win->AdoptAttributesFromHWND();
3897 win->SetupColours();
3898 return win;
3899 #else
3900 wxPyRaiseNotImplemented();
3901 return NULL;
3902 #endif
3903 }
3904
3905
3906 PyObject* GetTopLevelWindows() {
3907 return wxPy_ConvertList(&wxTopLevelWindows);
3908 }
3909
3910
3911 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3912 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3913 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3914
3915 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3916
3917
3918 SWIGINTERNINLINE int
3919 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3920 {
3921 unsigned long v;
3922 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3923 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3924 return res;
3925 }
3926
3927 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3928 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3929 wxMenuItemList& list = self->GetMenuItems();
3930 return wxPy_ConvertList(&list);
3931 }
3932 SWIGINTERN void wxMenuBar_SetAutoWindowMenu(bool enable){}
3933 SWIGINTERN bool wxMenuBar_GetAutoWindowMenu(){ return false; }
3934 SWIGINTERN void wxMenuItem_SetFont(wxMenuItem *self,wxFont const &font){}
3935 SWIGINTERN wxFont wxMenuItem_GetFont(wxMenuItem *self){ return wxNullFont; }
3936 SWIGINTERN void wxMenuItem_SetTextColour(wxMenuItem *self,wxColour const &colText){}
3937 SWIGINTERN wxColour wxMenuItem_GetTextColour(wxMenuItem *self){ return wxNullColour; }
3938 SWIGINTERN void wxMenuItem_SetBackgroundColour(wxMenuItem *self,wxColour const &colBack){}
3939 SWIGINTERN wxColour wxMenuItem_GetBackgroundColour(wxMenuItem *self){ return wxNullColour; }
3940 SWIGINTERN void wxMenuItem_SetBitmaps(wxMenuItem *self,wxBitmap const &bmpChecked,wxBitmap const &bmpUnchecked=wxNullBitmap){ self->SetBitmap( bmpChecked ); }
3941 SWIGINTERN void wxMenuItem_SetDisabledBitmap(wxMenuItem *self,wxBitmap const &bmpDisabled){}
3942 SWIGINTERN wxBitmap const &wxMenuItem_GetDisabledBitmap(wxMenuItem const *self){ return wxNullBitmap; }
3943 SWIGINTERN void wxMenuItem_SetMarginWidth(wxMenuItem *self,int nWidth){}
3944 SWIGINTERN int wxMenuItem_GetMarginWidth(wxMenuItem *self){ return 0; }
3945 SWIGINTERN int wxMenuItem_GetDefaultMarginWidth(){ return 0; }
3946 SWIGINTERN bool wxMenuItem_IsOwnerDrawn(wxMenuItem *self){ return false; }
3947 SWIGINTERN void wxMenuItem_SetOwnerDrawn(wxMenuItem *self,bool ownerDrawn=true){}
3948 SWIGINTERN void wxMenuItem_ResetOwnerDrawn(wxMenuItem *self){}
3949 static const wxString wxPyControlNameStr(wxControlNameStr);
3950 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
3951 if (clientData) {
3952 wxPyClientData* data = new wxPyClientData(clientData);
3953 return self->Append(item, data);
3954 } else
3955 return self->Append(item);
3956 }
3957 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,unsigned int pos,PyObject *clientData=NULL){
3958 if (clientData) {
3959 wxPyClientData* data = new wxPyClientData(clientData);
3960 return self->Insert(item, pos, data);
3961 } else
3962 return self->Insert(item, pos);
3963 }
3964 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,unsigned int n){
3965 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
3966 if (data) {
3967 Py_INCREF(data->m_obj);
3968 return data->m_obj;
3969 } else {
3970 Py_INCREF(Py_None);
3971 return Py_None;
3972 }
3973 }
3974 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,unsigned int n,PyObject *clientData){
3975 wxPyClientData* data = new wxPyClientData(clientData);
3976 self->SetClientObject(n, data);
3977 }
3978
3979
3980 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
3981 wxPyUserData* data = NULL;
3982 if ( userData ) {
3983 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3984 data = new wxPyUserData(userData);
3985 wxPyEndBlockThreads(blocked);
3986 }
3987 return new wxSizerItem(window, proportion, flag, border, data);
3988 }
3989 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
3990 wxPyUserData* data = NULL;
3991 if ( userData ) {
3992 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3993 data = new wxPyUserData(userData);
3994 wxPyEndBlockThreads(blocked);
3995 }
3996 return new wxSizerItem(width, height, proportion, flag, border, data);
3997 }
3998 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
3999 wxPyUserData* data = NULL;
4000 if ( userData ) {
4001 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4002 data = new wxPyUserData(userData);
4003 wxPyEndBlockThreads(blocked);
4004 }
4005 return new wxSizerItem(sizer, proportion, flag, border, data);
4006 }
4007
4008 SWIGINTERNINLINE PyObject *
4009 SWIG_From_float (float value)
4010 {
4011 return SWIG_From_double (value);
4012 }
4013
4014 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
4015 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
4016 if (data) {
4017 Py_INCREF(data->m_obj);
4018 return data->m_obj;
4019 } else {
4020 Py_INCREF(Py_None);
4021 return Py_None;
4022 }
4023 }
4024 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
4025 wxPyUserData* data = NULL;
4026 if ( userData ) {
4027 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4028 data = new wxPyUserData(userData);
4029 wxPyEndBlockThreads(blocked);
4030 }
4031 self->SetUserData(data);
4032 }
4033
4034 // Figure out the type of the sizer item
4035
4036 struct wxPySizerItemInfo {
4037 wxPySizerItemInfo()
4038 : window(NULL), sizer(NULL), gotSize(false),
4039 size(wxDefaultSize), gotPos(false), pos(-1)
4040 {}
4041
4042 wxWindow* window;
4043 wxSizer* sizer;
4044 bool gotSize;
4045 wxSize size;
4046 bool gotPos;
4047 int pos;
4048 };
4049
4050 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
4051
4052 wxPySizerItemInfo info;
4053 wxSize size;
4054 wxSize* sizePtr = &size;
4055
4056 // Find out what the type of the item is
4057 // try wxWindow
4058 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
4059 PyErr_Clear();
4060 info.window = NULL;
4061
4062 // try wxSizer
4063 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
4064 PyErr_Clear();
4065 info.sizer = NULL;
4066
4067 // try wxSize or (w,h)
4068 if ( checkSize && wxSize_helper(item, &sizePtr)) {
4069 info.size = *sizePtr;
4070 info.gotSize = true;
4071 }
4072
4073 // or a single int
4074 if (checkIdx && PyInt_Check(item)) {
4075 info.pos = PyInt_AsLong(item);
4076 info.gotPos = true;
4077 }
4078 }
4079 }
4080
4081 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
4082 // no expected type, figure out what kind of error message to generate
4083 if ( !checkSize && !checkIdx )
4084 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
4085 else if ( checkSize && !checkIdx )
4086 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
4087 else if ( !checkSize && checkIdx)
4088 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
4089 else
4090 // can this one happen?
4091 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
4092 }
4093
4094 return info;
4095 }
4096
4097 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
4098 if (!self->GetClientObject())
4099 self->SetClientObject(new wxPyOORClientData(_self));
4100 }
4101 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4102
4103 wxPyUserData* data = NULL;
4104 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4105 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4106 if ( userData && (info.window || info.sizer || info.gotSize) )
4107 data = new wxPyUserData(userData);
4108 if ( info.sizer )
4109 PyObject_SetAttrString(item,"thisown",Py_False);
4110 wxPyEndBlockThreads(blocked);
4111
4112 // Now call the real Add method if a valid item type was found
4113 if ( info.window )
4114 return self->Add(info.window, proportion, flag, border, data);
4115 else if ( info.sizer )
4116 return self->Add(info.sizer, proportion, flag, border, data);
4117 else if (info.gotSize)
4118 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4119 proportion, flag, border, data);
4120 else
4121 return NULL;
4122 }
4123 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4124
4125 wxPyUserData* data = NULL;
4126 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4127 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4128 if ( userData && (info.window || info.sizer || info.gotSize) )
4129 data = new wxPyUserData(userData);
4130 if ( info.sizer )
4131 PyObject_SetAttrString(item,"thisown",Py_False);
4132 wxPyEndBlockThreads(blocked);
4133
4134 // Now call the real Insert method if a valid item type was found
4135 if ( info.window )
4136 return self->Insert(before, info.window, proportion, flag, border, data);
4137 else if ( info.sizer )
4138 return self->Insert(before, info.sizer, proportion, flag, border, data);
4139 else if (info.gotSize)
4140 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4141 proportion, flag, border, data);
4142 else
4143 return NULL;
4144 }
4145 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4146
4147 wxPyUserData* data = NULL;
4148 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4149 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4150 if ( userData && (info.window || info.sizer || info.gotSize) )
4151 data = new wxPyUserData(userData);
4152 if ( info.sizer )
4153 PyObject_SetAttrString(item,"thisown",Py_False);
4154 wxPyEndBlockThreads(blocked);
4155
4156 // Now call the real Prepend method if a valid item type was found
4157 if ( info.window )
4158 return self->Prepend(info.window, proportion, flag, border, data);
4159 else if ( info.sizer )
4160 return self->Prepend(info.sizer, proportion, flag, border, data);
4161 else if (info.gotSize)
4162 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4163 proportion, flag, border, data);
4164 else
4165 return NULL;
4166 }
4167 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4168 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4169 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4170 wxPyEndBlockThreads(blocked);
4171 if ( info.window )
4172 return self->Remove(info.window);
4173 else if ( info.sizer )
4174 return self->Remove(info.sizer);
4175 else if ( info.gotPos )
4176 return self->Remove(info.pos);
4177 else
4178 return false;
4179 }
4180 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4181 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4182 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4183 wxPyEndBlockThreads(blocked);
4184 if ( info.window )
4185 return self->Detach(info.window);
4186 else if ( info.sizer )
4187 return self->Detach(info.sizer);
4188 else if ( info.gotPos )
4189 return self->Detach(info.pos);
4190 else
4191 return false;
4192 }
4193 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
4194 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4195 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4196 wxPyEndBlockThreads(blocked);
4197 if ( info.window )
4198 return self->GetItem(info.window);
4199 else if ( info.sizer )
4200 return self->GetItem(info.sizer);
4201 else if ( info.gotPos )
4202 return self->GetItem(info.pos);
4203 else
4204 return NULL;
4205 }
4206 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4207 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4208 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4209 wxPyEndBlockThreads(blocked);
4210 if ( info.window )
4211 self->SetItemMinSize(info.window, size);
4212 else if ( info.sizer )
4213 self->SetItemMinSize(info.sizer, size);
4214 else if ( info.gotPos )
4215 self->SetItemMinSize(info.pos, size);
4216 }
4217 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4218 wxSizerItemList& list = self->GetChildren();
4219 return wxPy_ConvertList(&list);
4220 }
4221 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4222 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4223 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4224 wxPyEndBlockThreads(blocked);
4225 if ( info.window )
4226 return self->Show(info.window, show, recursive);
4227 else if ( info.sizer )
4228 return self->Show(info.sizer, show, recursive);
4229 else if ( info.gotPos )
4230 return self->Show(info.pos, show);
4231 else
4232 return false;
4233 }
4234 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4235 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4236 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4237 wxPyEndBlockThreads(blocked);
4238 if ( info.window )
4239 return self->IsShown(info.window);
4240 else if ( info.sizer )
4241 return self->IsShown(info.sizer);
4242 else if ( info.gotPos )
4243 return self->IsShown(info.pos);
4244 else
4245 return false;
4246 }
4247
4248 // See pyclasses.h
4249 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4250 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4251 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4252
4253
4254
4255
4256 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4257 {
4258 if (source == Py_None) {
4259 **obj = wxGBPosition(-1,-1);
4260 return true;
4261 }
4262 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4263 }
4264
4265 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4266 {
4267 if (source == Py_None) {
4268 **obj = wxGBSpan(-1,-1);
4269 return true;
4270 }
4271 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4272 }
4273
4274
4275 SWIGINTERN bool wxGBPosition___eq__(wxGBPosition *self,PyObject *other){
4276 wxGBPosition temp, *obj = &temp;
4277 if ( other == Py_None ) return false;
4278 if ( ! wxGBPosition_helper(other, &obj) ) {
4279 PyErr_Clear();
4280 return false;
4281 }
4282 return self->operator==(*obj);
4283 }
4284 SWIGINTERN bool wxGBPosition___ne__(wxGBPosition *self,PyObject *other){
4285 wxGBPosition temp, *obj = &temp;
4286 if ( other == Py_None ) return true;
4287 if ( ! wxGBPosition_helper(other, &obj)) {
4288 PyErr_Clear();
4289 return true;
4290 }
4291 return self->operator!=(*obj);
4292 }
4293 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4294 self->SetRow(row);
4295 self->SetCol(col);
4296 }
4297 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4298 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4299 PyObject* tup = PyTuple_New(2);
4300 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4301 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4302 wxPyEndBlockThreads(blocked);
4303 return tup;
4304 }
4305 SWIGINTERN bool wxGBSpan___eq__(wxGBSpan *self,PyObject *other){
4306 wxGBSpan temp, *obj = &temp;
4307 if ( other == Py_None ) return false;
4308 if ( ! wxGBSpan_helper(other, &obj) ) {
4309 PyErr_Clear();
4310 return false;
4311 }
4312 return self->operator==(*obj);
4313 }
4314 SWIGINTERN bool wxGBSpan___ne__(wxGBSpan *self,PyObject *other){
4315 wxGBSpan temp, *obj = &temp;
4316 if ( other == Py_None ) return true;
4317 if ( ! wxGBSpan_helper(other, &obj)) {
4318 PyErr_Clear();
4319 return true;
4320 }
4321 return self->operator!=(*obj);
4322 }
4323 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4324 self->SetRowspan(rowspan);
4325 self->SetColspan(colspan);
4326 }
4327 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4328 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4329 PyObject* tup = PyTuple_New(2);
4330 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4331 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4332 wxPyEndBlockThreads(blocked);
4333 return tup;
4334 }
4335 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4336 wxPyUserData* data = NULL;
4337 if ( userData ) {
4338 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4339 data = new wxPyUserData(userData);
4340 wxPyEndBlockThreads(blocked);
4341 }
4342 return new wxGBSizerItem(window, pos, span, flag, border, data);
4343 }
4344 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4345 wxPyUserData* data = NULL;
4346 if ( userData ) {
4347 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4348 data = new wxPyUserData(userData);
4349 wxPyEndBlockThreads(blocked);
4350 }
4351 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4352 }
4353 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4354 wxPyUserData* data = NULL;
4355 if ( userData ) {
4356 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4357 data = new wxPyUserData(userData);
4358 wxPyEndBlockThreads(blocked);
4359 }
4360 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4361 }
4362 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4363 int row, col;
4364 self->GetEndPos(row, col);
4365 return wxGBPosition(row, col);
4366 }
4367 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4368
4369 wxPyUserData* data = NULL;
4370 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4371 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4372 if ( userData && (info.window || info.sizer || info.gotSize) )
4373 data = new wxPyUserData(userData);
4374 if ( info.sizer )
4375 PyObject_SetAttrString(item,"thisown",Py_False);
4376 wxPyEndBlockThreads(blocked);
4377
4378 // Now call the real Add method if a valid item type was found
4379 if ( info.window )
4380 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4381 else if ( info.sizer )
4382 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4383 else if (info.gotSize)
4384 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4385 pos, span, flag, border, data);
4386 return NULL;
4387 }
4388
4389
4390 #ifdef __cplusplus
4391 extern "C" {
4392 #endif
4393 SWIGINTERN int EmptyString_set(PyObject *) {
4394 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4395 return 1;
4396 }
4397
4398
4399 SWIGINTERN PyObject *EmptyString_get(void) {
4400 PyObject *pyobj = 0;
4401
4402 {
4403 #if wxUSE_UNICODE
4404 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4405 #else
4406 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4407 #endif
4408 }
4409 return pyobj;
4410 }
4411
4412
4413 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4414 PyObject *resultobj = 0;
4415 wxObject *arg1 = (wxObject *) 0 ;
4416 wxString result;
4417 void *argp1 = 0 ;
4418 int res1 = 0 ;
4419 PyObject *swig_obj[1] ;
4420
4421 if (!args) SWIG_fail;
4422 swig_obj[0] = args;
4423 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4424 if (!SWIG_IsOK(res1)) {
4425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4426 }
4427 arg1 = reinterpret_cast< wxObject * >(argp1);
4428 {
4429 PyThreadState* __tstate = wxPyBeginAllowThreads();
4430 result = wxObject_GetClassName(arg1);
4431 wxPyEndAllowThreads(__tstate);
4432 if (PyErr_Occurred()) SWIG_fail;
4433 }
4434 {
4435 #if wxUSE_UNICODE
4436 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4437 #else
4438 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4439 #endif
4440 }
4441 return resultobj;
4442 fail:
4443 return NULL;
4444 }
4445
4446
4447 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4448 PyObject *resultobj = 0;
4449 wxObject *arg1 = (wxObject *) 0 ;
4450 void *argp1 = 0 ;
4451 int res1 = 0 ;
4452 PyObject *swig_obj[1] ;
4453
4454 if (!args) SWIG_fail;
4455 swig_obj[0] = args;
4456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4457 if (!SWIG_IsOK(res1)) {
4458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4459 }
4460 arg1 = reinterpret_cast< wxObject * >(argp1);
4461 {
4462 PyThreadState* __tstate = wxPyBeginAllowThreads();
4463 wxObject_Destroy(arg1);
4464 wxPyEndAllowThreads(__tstate);
4465 if (PyErr_Occurred()) SWIG_fail;
4466 }
4467 resultobj = SWIG_Py_Void();
4468 return resultobj;
4469 fail:
4470 return NULL;
4471 }
4472
4473
4474 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4475 PyObject *obj;
4476 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4477 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4478 return SWIG_Py_Void();
4479 }
4480
4481 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4482 PyObject *resultobj = 0;
4483 wxSize *arg1 = (wxSize *) 0 ;
4484 int arg2 ;
4485 void *argp1 = 0 ;
4486 int res1 = 0 ;
4487 int val2 ;
4488 int ecode2 = 0 ;
4489 PyObject *swig_obj[2] ;
4490
4491 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4493 if (!SWIG_IsOK(res1)) {
4494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4495 }
4496 arg1 = reinterpret_cast< wxSize * >(argp1);
4497 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4498 if (!SWIG_IsOK(ecode2)) {
4499 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4500 }
4501 arg2 = static_cast< int >(val2);
4502 if (arg1) (arg1)->x = arg2;
4503
4504 resultobj = SWIG_Py_Void();
4505 return resultobj;
4506 fail:
4507 return NULL;
4508 }
4509
4510
4511 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4512 PyObject *resultobj = 0;
4513 wxSize *arg1 = (wxSize *) 0 ;
4514 int result;
4515 void *argp1 = 0 ;
4516 int res1 = 0 ;
4517 PyObject *swig_obj[1] ;
4518
4519 if (!args) SWIG_fail;
4520 swig_obj[0] = args;
4521 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4522 if (!SWIG_IsOK(res1)) {
4523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4524 }
4525 arg1 = reinterpret_cast< wxSize * >(argp1);
4526 result = (int) ((arg1)->x);
4527 resultobj = SWIG_From_int(static_cast< int >(result));
4528 return resultobj;
4529 fail:
4530 return NULL;
4531 }
4532
4533
4534 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4535 PyObject *resultobj = 0;
4536 wxSize *arg1 = (wxSize *) 0 ;
4537 int arg2 ;
4538 void *argp1 = 0 ;
4539 int res1 = 0 ;
4540 int val2 ;
4541 int ecode2 = 0 ;
4542 PyObject *swig_obj[2] ;
4543
4544 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4545 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4546 if (!SWIG_IsOK(res1)) {
4547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4548 }
4549 arg1 = reinterpret_cast< wxSize * >(argp1);
4550 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4551 if (!SWIG_IsOK(ecode2)) {
4552 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4553 }
4554 arg2 = static_cast< int >(val2);
4555 if (arg1) (arg1)->y = arg2;
4556
4557 resultobj = SWIG_Py_Void();
4558 return resultobj;
4559 fail:
4560 return NULL;
4561 }
4562
4563
4564 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4565 PyObject *resultobj = 0;
4566 wxSize *arg1 = (wxSize *) 0 ;
4567 int result;
4568 void *argp1 = 0 ;
4569 int res1 = 0 ;
4570 PyObject *swig_obj[1] ;
4571
4572 if (!args) SWIG_fail;
4573 swig_obj[0] = args;
4574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4575 if (!SWIG_IsOK(res1)) {
4576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4577 }
4578 arg1 = reinterpret_cast< wxSize * >(argp1);
4579 result = (int) ((arg1)->y);
4580 resultobj = SWIG_From_int(static_cast< int >(result));
4581 return resultobj;
4582 fail:
4583 return NULL;
4584 }
4585
4586
4587 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4588 PyObject *resultobj = 0;
4589 int arg1 = (int) 0 ;
4590 int arg2 = (int) 0 ;
4591 wxSize *result = 0 ;
4592 int val1 ;
4593 int ecode1 = 0 ;
4594 int val2 ;
4595 int ecode2 = 0 ;
4596 PyObject * obj0 = 0 ;
4597 PyObject * obj1 = 0 ;
4598 char * kwnames[] = {
4599 (char *) "w",(char *) "h", NULL
4600 };
4601
4602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4603 if (obj0) {
4604 ecode1 = SWIG_AsVal_int(obj0, &val1);
4605 if (!SWIG_IsOK(ecode1)) {
4606 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4607 }
4608 arg1 = static_cast< int >(val1);
4609 }
4610 if (obj1) {
4611 ecode2 = SWIG_AsVal_int(obj1, &val2);
4612 if (!SWIG_IsOK(ecode2)) {
4613 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4614 }
4615 arg2 = static_cast< int >(val2);
4616 }
4617 {
4618 PyThreadState* __tstate = wxPyBeginAllowThreads();
4619 result = (wxSize *)new wxSize(arg1,arg2);
4620 wxPyEndAllowThreads(__tstate);
4621 if (PyErr_Occurred()) SWIG_fail;
4622 }
4623 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4624 return resultobj;
4625 fail:
4626 return NULL;
4627 }
4628
4629
4630 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4631 PyObject *resultobj = 0;
4632 wxSize *arg1 = (wxSize *) 0 ;
4633 void *argp1 = 0 ;
4634 int res1 = 0 ;
4635 PyObject *swig_obj[1] ;
4636
4637 if (!args) SWIG_fail;
4638 swig_obj[0] = args;
4639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4640 if (!SWIG_IsOK(res1)) {
4641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4642 }
4643 arg1 = reinterpret_cast< wxSize * >(argp1);
4644 {
4645 PyThreadState* __tstate = wxPyBeginAllowThreads();
4646 delete arg1;
4647
4648 wxPyEndAllowThreads(__tstate);
4649 if (PyErr_Occurred()) SWIG_fail;
4650 }
4651 resultobj = SWIG_Py_Void();
4652 return resultobj;
4653 fail:
4654 return NULL;
4655 }
4656
4657
4658 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4659 PyObject *resultobj = 0;
4660 wxSize *arg1 = (wxSize *) 0 ;
4661 PyObject *arg2 = (PyObject *) 0 ;
4662 bool result;
4663 void *argp1 = 0 ;
4664 int res1 = 0 ;
4665 PyObject * obj0 = 0 ;
4666 PyObject * obj1 = 0 ;
4667 char * kwnames[] = {
4668 (char *) "self",(char *) "other", NULL
4669 };
4670
4671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4673 if (!SWIG_IsOK(res1)) {
4674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4675 }
4676 arg1 = reinterpret_cast< wxSize * >(argp1);
4677 arg2 = obj1;
4678 {
4679 result = (bool)wxSize___eq__(arg1,arg2);
4680 if (PyErr_Occurred()) SWIG_fail;
4681 }
4682 {
4683 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4684 }
4685 return resultobj;
4686 fail:
4687 return NULL;
4688 }
4689
4690
4691 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4692 PyObject *resultobj = 0;
4693 wxSize *arg1 = (wxSize *) 0 ;
4694 PyObject *arg2 = (PyObject *) 0 ;
4695 bool result;
4696 void *argp1 = 0 ;
4697 int res1 = 0 ;
4698 PyObject * obj0 = 0 ;
4699 PyObject * obj1 = 0 ;
4700 char * kwnames[] = {
4701 (char *) "self",(char *) "other", NULL
4702 };
4703
4704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",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___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4708 }
4709 arg1 = reinterpret_cast< wxSize * >(argp1);
4710 arg2 = obj1;
4711 {
4712 result = (bool)wxSize___ne__(arg1,arg2);
4713 if (PyErr_Occurred()) SWIG_fail;
4714 }
4715 {
4716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4717 }
4718 return resultobj;
4719 fail:
4720 return NULL;
4721 }
4722
4723
4724 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4725 PyObject *resultobj = 0;
4726 wxSize *arg1 = (wxSize *) 0 ;
4727 wxSize *arg2 = 0 ;
4728 wxSize result;
4729 void *argp1 = 0 ;
4730 int res1 = 0 ;
4731 wxSize temp2 ;
4732 PyObject * obj0 = 0 ;
4733 PyObject * obj1 = 0 ;
4734 char * kwnames[] = {
4735 (char *) "self",(char *) "sz", NULL
4736 };
4737
4738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4740 if (!SWIG_IsOK(res1)) {
4741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4742 }
4743 arg1 = reinterpret_cast< wxSize * >(argp1);
4744 {
4745 arg2 = &temp2;
4746 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4747 }
4748 {
4749 PyThreadState* __tstate = wxPyBeginAllowThreads();
4750 result = (arg1)->operator +((wxSize const &)*arg2);
4751 wxPyEndAllowThreads(__tstate);
4752 if (PyErr_Occurred()) SWIG_fail;
4753 }
4754 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4755 return resultobj;
4756 fail:
4757 return NULL;
4758 }
4759
4760
4761 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4762 PyObject *resultobj = 0;
4763 wxSize *arg1 = (wxSize *) 0 ;
4764 wxSize *arg2 = 0 ;
4765 wxSize result;
4766 void *argp1 = 0 ;
4767 int res1 = 0 ;
4768 wxSize temp2 ;
4769 PyObject * obj0 = 0 ;
4770 PyObject * obj1 = 0 ;
4771 char * kwnames[] = {
4772 (char *) "self",(char *) "sz", NULL
4773 };
4774
4775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4776 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4777 if (!SWIG_IsOK(res1)) {
4778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4779 }
4780 arg1 = reinterpret_cast< wxSize * >(argp1);
4781 {
4782 arg2 = &temp2;
4783 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4784 }
4785 {
4786 PyThreadState* __tstate = wxPyBeginAllowThreads();
4787 result = (arg1)->operator -((wxSize const &)*arg2);
4788 wxPyEndAllowThreads(__tstate);
4789 if (PyErr_Occurred()) SWIG_fail;
4790 }
4791 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4792 return resultobj;
4793 fail:
4794 return NULL;
4795 }
4796
4797
4798 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4799 PyObject *resultobj = 0;
4800 wxSize *arg1 = (wxSize *) 0 ;
4801 wxSize *arg2 = 0 ;
4802 void *argp1 = 0 ;
4803 int res1 = 0 ;
4804 wxSize temp2 ;
4805 PyObject * obj0 = 0 ;
4806 PyObject * obj1 = 0 ;
4807 char * kwnames[] = {
4808 (char *) "self",(char *) "sz", NULL
4809 };
4810
4811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4812 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4813 if (!SWIG_IsOK(res1)) {
4814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4815 }
4816 arg1 = reinterpret_cast< wxSize * >(argp1);
4817 {
4818 arg2 = &temp2;
4819 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4820 }
4821 {
4822 PyThreadState* __tstate = wxPyBeginAllowThreads();
4823 (arg1)->IncTo((wxSize const &)*arg2);
4824 wxPyEndAllowThreads(__tstate);
4825 if (PyErr_Occurred()) SWIG_fail;
4826 }
4827 resultobj = SWIG_Py_Void();
4828 return resultobj;
4829 fail:
4830 return NULL;
4831 }
4832
4833
4834 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4835 PyObject *resultobj = 0;
4836 wxSize *arg1 = (wxSize *) 0 ;
4837 wxSize *arg2 = 0 ;
4838 void *argp1 = 0 ;
4839 int res1 = 0 ;
4840 wxSize temp2 ;
4841 PyObject * obj0 = 0 ;
4842 PyObject * obj1 = 0 ;
4843 char * kwnames[] = {
4844 (char *) "self",(char *) "sz", NULL
4845 };
4846
4847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
4848 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4849 if (!SWIG_IsOK(res1)) {
4850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
4851 }
4852 arg1 = reinterpret_cast< wxSize * >(argp1);
4853 {
4854 arg2 = &temp2;
4855 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4856 }
4857 {
4858 PyThreadState* __tstate = wxPyBeginAllowThreads();
4859 (arg1)->DecTo((wxSize const &)*arg2);
4860 wxPyEndAllowThreads(__tstate);
4861 if (PyErr_Occurred()) SWIG_fail;
4862 }
4863 resultobj = SWIG_Py_Void();
4864 return resultobj;
4865 fail:
4866 return NULL;
4867 }
4868
4869
4870 SWIGINTERN PyObject *_wrap_Size_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4871 PyObject *resultobj = 0;
4872 wxSize *arg1 = (wxSize *) 0 ;
4873 float arg2 ;
4874 float arg3 ;
4875 void *argp1 = 0 ;
4876 int res1 = 0 ;
4877 float val2 ;
4878 int ecode2 = 0 ;
4879 float val3 ;
4880 int ecode3 = 0 ;
4881 PyObject * obj0 = 0 ;
4882 PyObject * obj1 = 0 ;
4883 PyObject * obj2 = 0 ;
4884 char * kwnames[] = {
4885 (char *) "self",(char *) "xscale",(char *) "yscale", NULL
4886 };
4887
4888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4889 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4890 if (!SWIG_IsOK(res1)) {
4891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Scale" "', expected argument " "1"" of type '" "wxSize *""'");
4892 }
4893 arg1 = reinterpret_cast< wxSize * >(argp1);
4894 ecode2 = SWIG_AsVal_float(obj1, &val2);
4895 if (!SWIG_IsOK(ecode2)) {
4896 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Scale" "', expected argument " "2"" of type '" "float""'");
4897 }
4898 arg2 = static_cast< float >(val2);
4899 ecode3 = SWIG_AsVal_float(obj2, &val3);
4900 if (!SWIG_IsOK(ecode3)) {
4901 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Scale" "', expected argument " "3"" of type '" "float""'");
4902 }
4903 arg3 = static_cast< float >(val3);
4904 {
4905 PyThreadState* __tstate = wxPyBeginAllowThreads();
4906 (arg1)->Scale(arg2,arg3);
4907 wxPyEndAllowThreads(__tstate);
4908 if (PyErr_Occurred()) SWIG_fail;
4909 }
4910 resultobj = SWIG_Py_Void();
4911 return resultobj;
4912 fail:
4913 return NULL;
4914 }
4915
4916
4917 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4918 PyObject *resultobj = 0;
4919 wxSize *arg1 = (wxSize *) 0 ;
4920 int arg2 ;
4921 int arg3 ;
4922 void *argp1 = 0 ;
4923 int res1 = 0 ;
4924 int val2 ;
4925 int ecode2 = 0 ;
4926 int val3 ;
4927 int ecode3 = 0 ;
4928 PyObject * obj0 = 0 ;
4929 PyObject * obj1 = 0 ;
4930 PyObject * obj2 = 0 ;
4931 char * kwnames[] = {
4932 (char *) "self",(char *) "w",(char *) "h", NULL
4933 };
4934
4935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) 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_Set" "', 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_Set" "', expected argument " "2"" of type '" "int""'");
4944 }
4945 arg2 = static_cast< int >(val2);
4946 ecode3 = SWIG_AsVal_int(obj2, &val3);
4947 if (!SWIG_IsOK(ecode3)) {
4948 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
4949 }
4950 arg3 = static_cast< int >(val3);
4951 {
4952 PyThreadState* __tstate = wxPyBeginAllowThreads();
4953 (arg1)->Set(arg2,arg3);
4954 wxPyEndAllowThreads(__tstate);
4955 if (PyErr_Occurred()) SWIG_fail;
4956 }
4957 resultobj = SWIG_Py_Void();
4958 return resultobj;
4959 fail:
4960 return NULL;
4961 }
4962
4963
4964 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4965 PyObject *resultobj = 0;
4966 wxSize *arg1 = (wxSize *) 0 ;
4967 int arg2 ;
4968 void *argp1 = 0 ;
4969 int res1 = 0 ;
4970 int val2 ;
4971 int ecode2 = 0 ;
4972 PyObject * obj0 = 0 ;
4973 PyObject * obj1 = 0 ;
4974 char * kwnames[] = {
4975 (char *) "self",(char *) "w", NULL
4976 };
4977
4978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
4979 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4980 if (!SWIG_IsOK(res1)) {
4981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
4982 }
4983 arg1 = reinterpret_cast< wxSize * >(argp1);
4984 ecode2 = SWIG_AsVal_int(obj1, &val2);
4985 if (!SWIG_IsOK(ecode2)) {
4986 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
4987 }
4988 arg2 = static_cast< int >(val2);
4989 {
4990 PyThreadState* __tstate = wxPyBeginAllowThreads();
4991 (arg1)->SetWidth(arg2);
4992 wxPyEndAllowThreads(__tstate);
4993 if (PyErr_Occurred()) SWIG_fail;
4994 }
4995 resultobj = SWIG_Py_Void();
4996 return resultobj;
4997 fail:
4998 return NULL;
4999 }
5000
5001
5002 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5003 PyObject *resultobj = 0;
5004 wxSize *arg1 = (wxSize *) 0 ;
5005 int arg2 ;
5006 void *argp1 = 0 ;
5007 int res1 = 0 ;
5008 int val2 ;
5009 int ecode2 = 0 ;
5010 PyObject * obj0 = 0 ;
5011 PyObject * obj1 = 0 ;
5012 char * kwnames[] = {
5013 (char *) "self",(char *) "h", NULL
5014 };
5015
5016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
5017 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5018 if (!SWIG_IsOK(res1)) {
5019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
5020 }
5021 arg1 = reinterpret_cast< wxSize * >(argp1);
5022 ecode2 = SWIG_AsVal_int(obj1, &val2);
5023 if (!SWIG_IsOK(ecode2)) {
5024 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
5025 }
5026 arg2 = static_cast< int >(val2);
5027 {
5028 PyThreadState* __tstate = wxPyBeginAllowThreads();
5029 (arg1)->SetHeight(arg2);
5030 wxPyEndAllowThreads(__tstate);
5031 if (PyErr_Occurred()) SWIG_fail;
5032 }
5033 resultobj = SWIG_Py_Void();
5034 return resultobj;
5035 fail:
5036 return NULL;
5037 }
5038
5039
5040 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5041 PyObject *resultobj = 0;
5042 wxSize *arg1 = (wxSize *) 0 ;
5043 int result;
5044 void *argp1 = 0 ;
5045 int res1 = 0 ;
5046 PyObject *swig_obj[1] ;
5047
5048 if (!args) SWIG_fail;
5049 swig_obj[0] = args;
5050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5051 if (!SWIG_IsOK(res1)) {
5052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
5053 }
5054 arg1 = reinterpret_cast< wxSize * >(argp1);
5055 {
5056 PyThreadState* __tstate = wxPyBeginAllowThreads();
5057 result = (int)((wxSize const *)arg1)->GetWidth();
5058 wxPyEndAllowThreads(__tstate);
5059 if (PyErr_Occurred()) SWIG_fail;
5060 }
5061 resultobj = SWIG_From_int(static_cast< int >(result));
5062 return resultobj;
5063 fail:
5064 return NULL;
5065 }
5066
5067
5068 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5069 PyObject *resultobj = 0;
5070 wxSize *arg1 = (wxSize *) 0 ;
5071 int result;
5072 void *argp1 = 0 ;
5073 int res1 = 0 ;
5074 PyObject *swig_obj[1] ;
5075
5076 if (!args) SWIG_fail;
5077 swig_obj[0] = args;
5078 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5079 if (!SWIG_IsOK(res1)) {
5080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
5081 }
5082 arg1 = reinterpret_cast< wxSize * >(argp1);
5083 {
5084 PyThreadState* __tstate = wxPyBeginAllowThreads();
5085 result = (int)((wxSize const *)arg1)->GetHeight();
5086 wxPyEndAllowThreads(__tstate);
5087 if (PyErr_Occurred()) SWIG_fail;
5088 }
5089 resultobj = SWIG_From_int(static_cast< int >(result));
5090 return resultobj;
5091 fail:
5092 return NULL;
5093 }
5094
5095
5096 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5097 PyObject *resultobj = 0;
5098 wxSize *arg1 = (wxSize *) 0 ;
5099 bool result;
5100 void *argp1 = 0 ;
5101 int res1 = 0 ;
5102 PyObject *swig_obj[1] ;
5103
5104 if (!args) SWIG_fail;
5105 swig_obj[0] = args;
5106 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5107 if (!SWIG_IsOK(res1)) {
5108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
5109 }
5110 arg1 = reinterpret_cast< wxSize * >(argp1);
5111 {
5112 PyThreadState* __tstate = wxPyBeginAllowThreads();
5113 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
5114 wxPyEndAllowThreads(__tstate);
5115 if (PyErr_Occurred()) SWIG_fail;
5116 }
5117 {
5118 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5119 }
5120 return resultobj;
5121 fail:
5122 return NULL;
5123 }
5124
5125
5126 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5127 PyObject *resultobj = 0;
5128 wxSize *arg1 = (wxSize *) 0 ;
5129 wxSize *arg2 = 0 ;
5130 void *argp1 = 0 ;
5131 int res1 = 0 ;
5132 wxSize temp2 ;
5133 PyObject * obj0 = 0 ;
5134 PyObject * obj1 = 0 ;
5135 char * kwnames[] = {
5136 (char *) "self",(char *) "size", NULL
5137 };
5138
5139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
5140 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5141 if (!SWIG_IsOK(res1)) {
5142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
5143 }
5144 arg1 = reinterpret_cast< wxSize * >(argp1);
5145 {
5146 arg2 = &temp2;
5147 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5148 }
5149 {
5150 PyThreadState* __tstate = wxPyBeginAllowThreads();
5151 (arg1)->SetDefaults((wxSize const &)*arg2);
5152 wxPyEndAllowThreads(__tstate);
5153 if (PyErr_Occurred()) SWIG_fail;
5154 }
5155 resultobj = SWIG_Py_Void();
5156 return resultobj;
5157 fail:
5158 return NULL;
5159 }
5160
5161
5162 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5163 PyObject *resultobj = 0;
5164 wxSize *arg1 = (wxSize *) 0 ;
5165 PyObject *result = 0 ;
5166 void *argp1 = 0 ;
5167 int res1 = 0 ;
5168 PyObject *swig_obj[1] ;
5169
5170 if (!args) SWIG_fail;
5171 swig_obj[0] = args;
5172 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5173 if (!SWIG_IsOK(res1)) {
5174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
5175 }
5176 arg1 = reinterpret_cast< wxSize * >(argp1);
5177 {
5178 PyThreadState* __tstate = wxPyBeginAllowThreads();
5179 result = (PyObject *)wxSize_Get(arg1);
5180 wxPyEndAllowThreads(__tstate);
5181 if (PyErr_Occurred()) SWIG_fail;
5182 }
5183 resultobj = result;
5184 return resultobj;
5185 fail:
5186 return NULL;
5187 }
5188
5189
5190 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5191 PyObject *obj;
5192 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5193 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5194 return SWIG_Py_Void();
5195 }
5196
5197 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5198 return SWIG_Python_InitShadowInstance(args);
5199 }
5200
5201 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5202 PyObject *resultobj = 0;
5203 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5204 double arg2 ;
5205 void *argp1 = 0 ;
5206 int res1 = 0 ;
5207 double val2 ;
5208 int ecode2 = 0 ;
5209 PyObject *swig_obj[2] ;
5210
5211 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5213 if (!SWIG_IsOK(res1)) {
5214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5215 }
5216 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5217 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5218 if (!SWIG_IsOK(ecode2)) {
5219 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5220 }
5221 arg2 = static_cast< double >(val2);
5222 if (arg1) (arg1)->x = arg2;
5223
5224 resultobj = SWIG_Py_Void();
5225 return resultobj;
5226 fail:
5227 return NULL;
5228 }
5229
5230
5231 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5232 PyObject *resultobj = 0;
5233 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5234 double result;
5235 void *argp1 = 0 ;
5236 int res1 = 0 ;
5237 PyObject *swig_obj[1] ;
5238
5239 if (!args) SWIG_fail;
5240 swig_obj[0] = args;
5241 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5242 if (!SWIG_IsOK(res1)) {
5243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5244 }
5245 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5246 result = (double) ((arg1)->x);
5247 resultobj = SWIG_From_double(static_cast< double >(result));
5248 return resultobj;
5249 fail:
5250 return NULL;
5251 }
5252
5253
5254 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5255 PyObject *resultobj = 0;
5256 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5257 double arg2 ;
5258 void *argp1 = 0 ;
5259 int res1 = 0 ;
5260 double val2 ;
5261 int ecode2 = 0 ;
5262 PyObject *swig_obj[2] ;
5263
5264 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5265 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5266 if (!SWIG_IsOK(res1)) {
5267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5268 }
5269 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5270 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5271 if (!SWIG_IsOK(ecode2)) {
5272 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5273 }
5274 arg2 = static_cast< double >(val2);
5275 if (arg1) (arg1)->y = arg2;
5276
5277 resultobj = SWIG_Py_Void();
5278 return resultobj;
5279 fail:
5280 return NULL;
5281 }
5282
5283
5284 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5285 PyObject *resultobj = 0;
5286 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5287 double result;
5288 void *argp1 = 0 ;
5289 int res1 = 0 ;
5290 PyObject *swig_obj[1] ;
5291
5292 if (!args) SWIG_fail;
5293 swig_obj[0] = args;
5294 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5295 if (!SWIG_IsOK(res1)) {
5296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5297 }
5298 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5299 result = (double) ((arg1)->y);
5300 resultobj = SWIG_From_double(static_cast< double >(result));
5301 return resultobj;
5302 fail:
5303 return NULL;
5304 }
5305
5306
5307 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5308 PyObject *resultobj = 0;
5309 double arg1 = (double) 0.0 ;
5310 double arg2 = (double) 0.0 ;
5311 wxRealPoint *result = 0 ;
5312 double val1 ;
5313 int ecode1 = 0 ;
5314 double val2 ;
5315 int ecode2 = 0 ;
5316 PyObject * obj0 = 0 ;
5317 PyObject * obj1 = 0 ;
5318 char * kwnames[] = {
5319 (char *) "x",(char *) "y", NULL
5320 };
5321
5322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5323 if (obj0) {
5324 ecode1 = SWIG_AsVal_double(obj0, &val1);
5325 if (!SWIG_IsOK(ecode1)) {
5326 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5327 }
5328 arg1 = static_cast< double >(val1);
5329 }
5330 if (obj1) {
5331 ecode2 = SWIG_AsVal_double(obj1, &val2);
5332 if (!SWIG_IsOK(ecode2)) {
5333 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5334 }
5335 arg2 = static_cast< double >(val2);
5336 }
5337 {
5338 PyThreadState* __tstate = wxPyBeginAllowThreads();
5339 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5340 wxPyEndAllowThreads(__tstate);
5341 if (PyErr_Occurred()) SWIG_fail;
5342 }
5343 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5344 return resultobj;
5345 fail:
5346 return NULL;
5347 }
5348
5349
5350 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5351 PyObject *resultobj = 0;
5352 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5353 void *argp1 = 0 ;
5354 int res1 = 0 ;
5355 PyObject *swig_obj[1] ;
5356
5357 if (!args) SWIG_fail;
5358 swig_obj[0] = args;
5359 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5360 if (!SWIG_IsOK(res1)) {
5361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5362 }
5363 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5364 {
5365 PyThreadState* __tstate = wxPyBeginAllowThreads();
5366 delete arg1;
5367
5368 wxPyEndAllowThreads(__tstate);
5369 if (PyErr_Occurred()) SWIG_fail;
5370 }
5371 resultobj = SWIG_Py_Void();
5372 return resultobj;
5373 fail:
5374 return NULL;
5375 }
5376
5377
5378 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5379 PyObject *resultobj = 0;
5380 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5381 PyObject *arg2 = (PyObject *) 0 ;
5382 bool result;
5383 void *argp1 = 0 ;
5384 int res1 = 0 ;
5385 PyObject * obj0 = 0 ;
5386 PyObject * obj1 = 0 ;
5387 char * kwnames[] = {
5388 (char *) "self",(char *) "other", NULL
5389 };
5390
5391 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5392 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5393 if (!SWIG_IsOK(res1)) {
5394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5395 }
5396 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5397 arg2 = obj1;
5398 {
5399 result = (bool)wxRealPoint___eq__(arg1,arg2);
5400 if (PyErr_Occurred()) SWIG_fail;
5401 }
5402 {
5403 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5404 }
5405 return resultobj;
5406 fail:
5407 return NULL;
5408 }
5409
5410
5411 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5412 PyObject *resultobj = 0;
5413 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5414 PyObject *arg2 = (PyObject *) 0 ;
5415 bool result;
5416 void *argp1 = 0 ;
5417 int res1 = 0 ;
5418 PyObject * obj0 = 0 ;
5419 PyObject * obj1 = 0 ;
5420 char * kwnames[] = {
5421 (char *) "self",(char *) "other", NULL
5422 };
5423
5424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5426 if (!SWIG_IsOK(res1)) {
5427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5428 }
5429 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5430 arg2 = obj1;
5431 {
5432 result = (bool)wxRealPoint___ne__(arg1,arg2);
5433 if (PyErr_Occurred()) SWIG_fail;
5434 }
5435 {
5436 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5437 }
5438 return resultobj;
5439 fail:
5440 return NULL;
5441 }
5442
5443
5444 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5445 PyObject *resultobj = 0;
5446 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5447 wxRealPoint *arg2 = 0 ;
5448 wxRealPoint result;
5449 void *argp1 = 0 ;
5450 int res1 = 0 ;
5451 wxRealPoint temp2 ;
5452 PyObject * obj0 = 0 ;
5453 PyObject * obj1 = 0 ;
5454 char * kwnames[] = {
5455 (char *) "self",(char *) "pt", NULL
5456 };
5457
5458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5460 if (!SWIG_IsOK(res1)) {
5461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5462 }
5463 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5464 {
5465 arg2 = &temp2;
5466 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5467 }
5468 {
5469 PyThreadState* __tstate = wxPyBeginAllowThreads();
5470 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5471 wxPyEndAllowThreads(__tstate);
5472 if (PyErr_Occurred()) SWIG_fail;
5473 }
5474 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5475 return resultobj;
5476 fail:
5477 return NULL;
5478 }
5479
5480
5481 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5482 PyObject *resultobj = 0;
5483 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5484 wxRealPoint *arg2 = 0 ;
5485 wxRealPoint result;
5486 void *argp1 = 0 ;
5487 int res1 = 0 ;
5488 wxRealPoint temp2 ;
5489 PyObject * obj0 = 0 ;
5490 PyObject * obj1 = 0 ;
5491 char * kwnames[] = {
5492 (char *) "self",(char *) "pt", NULL
5493 };
5494
5495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5496 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5497 if (!SWIG_IsOK(res1)) {
5498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5499 }
5500 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5501 {
5502 arg2 = &temp2;
5503 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5504 }
5505 {
5506 PyThreadState* __tstate = wxPyBeginAllowThreads();
5507 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5508 wxPyEndAllowThreads(__tstate);
5509 if (PyErr_Occurred()) SWIG_fail;
5510 }
5511 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5512 return resultobj;
5513 fail:
5514 return NULL;
5515 }
5516
5517
5518 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5519 PyObject *resultobj = 0;
5520 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5521 double arg2 ;
5522 double arg3 ;
5523 void *argp1 = 0 ;
5524 int res1 = 0 ;
5525 double val2 ;
5526 int ecode2 = 0 ;
5527 double val3 ;
5528 int ecode3 = 0 ;
5529 PyObject * obj0 = 0 ;
5530 PyObject * obj1 = 0 ;
5531 PyObject * obj2 = 0 ;
5532 char * kwnames[] = {
5533 (char *) "self",(char *) "x",(char *) "y", NULL
5534 };
5535
5536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5538 if (!SWIG_IsOK(res1)) {
5539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5540 }
5541 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5542 ecode2 = SWIG_AsVal_double(obj1, &val2);
5543 if (!SWIG_IsOK(ecode2)) {
5544 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5545 }
5546 arg2 = static_cast< double >(val2);
5547 ecode3 = SWIG_AsVal_double(obj2, &val3);
5548 if (!SWIG_IsOK(ecode3)) {
5549 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5550 }
5551 arg3 = static_cast< double >(val3);
5552 {
5553 PyThreadState* __tstate = wxPyBeginAllowThreads();
5554 wxRealPoint_Set(arg1,arg2,arg3);
5555 wxPyEndAllowThreads(__tstate);
5556 if (PyErr_Occurred()) SWIG_fail;
5557 }
5558 resultobj = SWIG_Py_Void();
5559 return resultobj;
5560 fail:
5561 return NULL;
5562 }
5563
5564
5565 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5566 PyObject *resultobj = 0;
5567 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5568 PyObject *result = 0 ;
5569 void *argp1 = 0 ;
5570 int res1 = 0 ;
5571 PyObject *swig_obj[1] ;
5572
5573 if (!args) SWIG_fail;
5574 swig_obj[0] = args;
5575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5576 if (!SWIG_IsOK(res1)) {
5577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5578 }
5579 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5580 {
5581 PyThreadState* __tstate = wxPyBeginAllowThreads();
5582 result = (PyObject *)wxRealPoint_Get(arg1);
5583 wxPyEndAllowThreads(__tstate);
5584 if (PyErr_Occurred()) SWIG_fail;
5585 }
5586 resultobj = result;
5587 return resultobj;
5588 fail:
5589 return NULL;
5590 }
5591
5592
5593 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5594 PyObject *obj;
5595 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5596 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5597 return SWIG_Py_Void();
5598 }
5599
5600 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5601 return SWIG_Python_InitShadowInstance(args);
5602 }
5603
5604 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5605 PyObject *resultobj = 0;
5606 wxPoint *arg1 = (wxPoint *) 0 ;
5607 int arg2 ;
5608 void *argp1 = 0 ;
5609 int res1 = 0 ;
5610 int val2 ;
5611 int ecode2 = 0 ;
5612 PyObject *swig_obj[2] ;
5613
5614 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5616 if (!SWIG_IsOK(res1)) {
5617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5618 }
5619 arg1 = reinterpret_cast< wxPoint * >(argp1);
5620 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5621 if (!SWIG_IsOK(ecode2)) {
5622 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5623 }
5624 arg2 = static_cast< int >(val2);
5625 if (arg1) (arg1)->x = arg2;
5626
5627 resultobj = SWIG_Py_Void();
5628 return resultobj;
5629 fail:
5630 return NULL;
5631 }
5632
5633
5634 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5635 PyObject *resultobj = 0;
5636 wxPoint *arg1 = (wxPoint *) 0 ;
5637 int result;
5638 void *argp1 = 0 ;
5639 int res1 = 0 ;
5640 PyObject *swig_obj[1] ;
5641
5642 if (!args) SWIG_fail;
5643 swig_obj[0] = args;
5644 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5645 if (!SWIG_IsOK(res1)) {
5646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5647 }
5648 arg1 = reinterpret_cast< wxPoint * >(argp1);
5649 result = (int) ((arg1)->x);
5650 resultobj = SWIG_From_int(static_cast< int >(result));
5651 return resultobj;
5652 fail:
5653 return NULL;
5654 }
5655
5656
5657 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5658 PyObject *resultobj = 0;
5659 wxPoint *arg1 = (wxPoint *) 0 ;
5660 int arg2 ;
5661 void *argp1 = 0 ;
5662 int res1 = 0 ;
5663 int val2 ;
5664 int ecode2 = 0 ;
5665 PyObject *swig_obj[2] ;
5666
5667 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5669 if (!SWIG_IsOK(res1)) {
5670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5671 }
5672 arg1 = reinterpret_cast< wxPoint * >(argp1);
5673 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5674 if (!SWIG_IsOK(ecode2)) {
5675 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5676 }
5677 arg2 = static_cast< int >(val2);
5678 if (arg1) (arg1)->y = arg2;
5679
5680 resultobj = SWIG_Py_Void();
5681 return resultobj;
5682 fail:
5683 return NULL;
5684 }
5685
5686
5687 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5688 PyObject *resultobj = 0;
5689 wxPoint *arg1 = (wxPoint *) 0 ;
5690 int result;
5691 void *argp1 = 0 ;
5692 int res1 = 0 ;
5693 PyObject *swig_obj[1] ;
5694
5695 if (!args) SWIG_fail;
5696 swig_obj[0] = args;
5697 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5698 if (!SWIG_IsOK(res1)) {
5699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5700 }
5701 arg1 = reinterpret_cast< wxPoint * >(argp1);
5702 result = (int) ((arg1)->y);
5703 resultobj = SWIG_From_int(static_cast< int >(result));
5704 return resultobj;
5705 fail:
5706 return NULL;
5707 }
5708
5709
5710 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5711 PyObject *resultobj = 0;
5712 int arg1 = (int) 0 ;
5713 int arg2 = (int) 0 ;
5714 wxPoint *result = 0 ;
5715 int val1 ;
5716 int ecode1 = 0 ;
5717 int val2 ;
5718 int ecode2 = 0 ;
5719 PyObject * obj0 = 0 ;
5720 PyObject * obj1 = 0 ;
5721 char * kwnames[] = {
5722 (char *) "x",(char *) "y", NULL
5723 };
5724
5725 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5726 if (obj0) {
5727 ecode1 = SWIG_AsVal_int(obj0, &val1);
5728 if (!SWIG_IsOK(ecode1)) {
5729 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5730 }
5731 arg1 = static_cast< int >(val1);
5732 }
5733 if (obj1) {
5734 ecode2 = SWIG_AsVal_int(obj1, &val2);
5735 if (!SWIG_IsOK(ecode2)) {
5736 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5737 }
5738 arg2 = static_cast< int >(val2);
5739 }
5740 {
5741 PyThreadState* __tstate = wxPyBeginAllowThreads();
5742 result = (wxPoint *)new wxPoint(arg1,arg2);
5743 wxPyEndAllowThreads(__tstate);
5744 if (PyErr_Occurred()) SWIG_fail;
5745 }
5746 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5747 return resultobj;
5748 fail:
5749 return NULL;
5750 }
5751
5752
5753 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5754 PyObject *resultobj = 0;
5755 wxPoint *arg1 = (wxPoint *) 0 ;
5756 void *argp1 = 0 ;
5757 int res1 = 0 ;
5758 PyObject *swig_obj[1] ;
5759
5760 if (!args) SWIG_fail;
5761 swig_obj[0] = args;
5762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5763 if (!SWIG_IsOK(res1)) {
5764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5765 }
5766 arg1 = reinterpret_cast< wxPoint * >(argp1);
5767 {
5768 PyThreadState* __tstate = wxPyBeginAllowThreads();
5769 delete arg1;
5770
5771 wxPyEndAllowThreads(__tstate);
5772 if (PyErr_Occurred()) SWIG_fail;
5773 }
5774 resultobj = SWIG_Py_Void();
5775 return resultobj;
5776 fail:
5777 return NULL;
5778 }
5779
5780
5781 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5782 PyObject *resultobj = 0;
5783 wxPoint *arg1 = (wxPoint *) 0 ;
5784 PyObject *arg2 = (PyObject *) 0 ;
5785 bool result;
5786 void *argp1 = 0 ;
5787 int res1 = 0 ;
5788 PyObject * obj0 = 0 ;
5789 PyObject * obj1 = 0 ;
5790 char * kwnames[] = {
5791 (char *) "self",(char *) "other", NULL
5792 };
5793
5794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5796 if (!SWIG_IsOK(res1)) {
5797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
5798 }
5799 arg1 = reinterpret_cast< wxPoint * >(argp1);
5800 arg2 = obj1;
5801 {
5802 result = (bool)wxPoint___eq__(arg1,arg2);
5803 if (PyErr_Occurred()) SWIG_fail;
5804 }
5805 {
5806 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5807 }
5808 return resultobj;
5809 fail:
5810 return NULL;
5811 }
5812
5813
5814 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5815 PyObject *resultobj = 0;
5816 wxPoint *arg1 = (wxPoint *) 0 ;
5817 PyObject *arg2 = (PyObject *) 0 ;
5818 bool result;
5819 void *argp1 = 0 ;
5820 int res1 = 0 ;
5821 PyObject * obj0 = 0 ;
5822 PyObject * obj1 = 0 ;
5823 char * kwnames[] = {
5824 (char *) "self",(char *) "other", NULL
5825 };
5826
5827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5829 if (!SWIG_IsOK(res1)) {
5830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
5831 }
5832 arg1 = reinterpret_cast< wxPoint * >(argp1);
5833 arg2 = obj1;
5834 {
5835 result = (bool)wxPoint___ne__(arg1,arg2);
5836 if (PyErr_Occurred()) SWIG_fail;
5837 }
5838 {
5839 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5840 }
5841 return resultobj;
5842 fail:
5843 return NULL;
5844 }
5845
5846
5847 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5848 PyObject *resultobj = 0;
5849 wxPoint *arg1 = (wxPoint *) 0 ;
5850 wxPoint *arg2 = 0 ;
5851 wxPoint result;
5852 void *argp1 = 0 ;
5853 int res1 = 0 ;
5854 wxPoint temp2 ;
5855 PyObject * obj0 = 0 ;
5856 PyObject * obj1 = 0 ;
5857 char * kwnames[] = {
5858 (char *) "self",(char *) "pt", NULL
5859 };
5860
5861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5862 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5863 if (!SWIG_IsOK(res1)) {
5864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
5865 }
5866 arg1 = reinterpret_cast< wxPoint * >(argp1);
5867 {
5868 arg2 = &temp2;
5869 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5870 }
5871 {
5872 PyThreadState* __tstate = wxPyBeginAllowThreads();
5873 result = (arg1)->operator +((wxPoint const &)*arg2);
5874 wxPyEndAllowThreads(__tstate);
5875 if (PyErr_Occurred()) SWIG_fail;
5876 }
5877 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5878 return resultobj;
5879 fail:
5880 return NULL;
5881 }
5882
5883
5884 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5885 PyObject *resultobj = 0;
5886 wxPoint *arg1 = (wxPoint *) 0 ;
5887 wxPoint *arg2 = 0 ;
5888 wxPoint result;
5889 void *argp1 = 0 ;
5890 int res1 = 0 ;
5891 wxPoint temp2 ;
5892 PyObject * obj0 = 0 ;
5893 PyObject * obj1 = 0 ;
5894 char * kwnames[] = {
5895 (char *) "self",(char *) "pt", NULL
5896 };
5897
5898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5900 if (!SWIG_IsOK(res1)) {
5901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5902 }
5903 arg1 = reinterpret_cast< wxPoint * >(argp1);
5904 {
5905 arg2 = &temp2;
5906 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5907 }
5908 {
5909 PyThreadState* __tstate = wxPyBeginAllowThreads();
5910 result = (arg1)->operator -((wxPoint const &)*arg2);
5911 wxPyEndAllowThreads(__tstate);
5912 if (PyErr_Occurred()) SWIG_fail;
5913 }
5914 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5915 return resultobj;
5916 fail:
5917 return NULL;
5918 }
5919
5920
5921 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5922 PyObject *resultobj = 0;
5923 wxPoint *arg1 = (wxPoint *) 0 ;
5924 wxPoint *arg2 = 0 ;
5925 wxPoint *result = 0 ;
5926 void *argp1 = 0 ;
5927 int res1 = 0 ;
5928 wxPoint temp2 ;
5929 PyObject * obj0 = 0 ;
5930 PyObject * obj1 = 0 ;
5931 char * kwnames[] = {
5932 (char *) "self",(char *) "pt", NULL
5933 };
5934
5935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
5936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5937 if (!SWIG_IsOK(res1)) {
5938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
5939 }
5940 arg1 = reinterpret_cast< wxPoint * >(argp1);
5941 {
5942 arg2 = &temp2;
5943 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5944 }
5945 {
5946 PyThreadState* __tstate = wxPyBeginAllowThreads();
5947 {
5948 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
5949 result = (wxPoint *) &_result_ref;
5950 }
5951 wxPyEndAllowThreads(__tstate);
5952 if (PyErr_Occurred()) SWIG_fail;
5953 }
5954 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5955 return resultobj;
5956 fail:
5957 return NULL;
5958 }
5959
5960
5961 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5962 PyObject *resultobj = 0;
5963 wxPoint *arg1 = (wxPoint *) 0 ;
5964 wxPoint *arg2 = 0 ;
5965 wxPoint *result = 0 ;
5966 void *argp1 = 0 ;
5967 int res1 = 0 ;
5968 wxPoint temp2 ;
5969 PyObject * obj0 = 0 ;
5970 PyObject * obj1 = 0 ;
5971 char * kwnames[] = {
5972 (char *) "self",(char *) "pt", NULL
5973 };
5974
5975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
5976 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5977 if (!SWIG_IsOK(res1)) {
5978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5979 }
5980 arg1 = reinterpret_cast< wxPoint * >(argp1);
5981 {
5982 arg2 = &temp2;
5983 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5984 }
5985 {
5986 PyThreadState* __tstate = wxPyBeginAllowThreads();
5987 {
5988 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
5989 result = (wxPoint *) &_result_ref;
5990 }
5991 wxPyEndAllowThreads(__tstate);
5992 if (PyErr_Occurred()) SWIG_fail;
5993 }
5994 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5995 return resultobj;
5996 fail:
5997 return NULL;
5998 }
5999
6000
6001 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6002 PyObject *resultobj = 0;
6003 wxPoint *arg1 = (wxPoint *) 0 ;
6004 long arg2 ;
6005 long arg3 ;
6006 void *argp1 = 0 ;
6007 int res1 = 0 ;
6008 long val2 ;
6009 int ecode2 = 0 ;
6010 long val3 ;
6011 int ecode3 = 0 ;
6012 PyObject * obj0 = 0 ;
6013 PyObject * obj1 = 0 ;
6014 PyObject * obj2 = 0 ;
6015 char * kwnames[] = {
6016 (char *) "self",(char *) "x",(char *) "y", NULL
6017 };
6018
6019 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6020 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6021 if (!SWIG_IsOK(res1)) {
6022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
6023 }
6024 arg1 = reinterpret_cast< wxPoint * >(argp1);
6025 ecode2 = SWIG_AsVal_long(obj1, &val2);
6026 if (!SWIG_IsOK(ecode2)) {
6027 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
6028 }
6029 arg2 = static_cast< long >(val2);
6030 ecode3 = SWIG_AsVal_long(obj2, &val3);
6031 if (!SWIG_IsOK(ecode3)) {
6032 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
6033 }
6034 arg3 = static_cast< long >(val3);
6035 {
6036 PyThreadState* __tstate = wxPyBeginAllowThreads();
6037 wxPoint_Set(arg1,arg2,arg3);
6038 wxPyEndAllowThreads(__tstate);
6039 if (PyErr_Occurred()) SWIG_fail;
6040 }
6041 resultobj = SWIG_Py_Void();
6042 return resultobj;
6043 fail:
6044 return NULL;
6045 }
6046
6047
6048 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6049 PyObject *resultobj = 0;
6050 wxPoint *arg1 = (wxPoint *) 0 ;
6051 PyObject *result = 0 ;
6052 void *argp1 = 0 ;
6053 int res1 = 0 ;
6054 PyObject *swig_obj[1] ;
6055
6056 if (!args) SWIG_fail;
6057 swig_obj[0] = args;
6058 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6059 if (!SWIG_IsOK(res1)) {
6060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
6061 }
6062 arg1 = reinterpret_cast< wxPoint * >(argp1);
6063 {
6064 PyThreadState* __tstate = wxPyBeginAllowThreads();
6065 result = (PyObject *)wxPoint_Get(arg1);
6066 wxPyEndAllowThreads(__tstate);
6067 if (PyErr_Occurred()) SWIG_fail;
6068 }
6069 resultobj = result;
6070 return resultobj;
6071 fail:
6072 return NULL;
6073 }
6074
6075
6076 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6077 PyObject *obj;
6078 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6079 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
6080 return SWIG_Py_Void();
6081 }
6082
6083 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6084 return SWIG_Python_InitShadowInstance(args);
6085 }
6086
6087 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6088 PyObject *resultobj = 0;
6089 int arg1 = (int) 0 ;
6090 int arg2 = (int) 0 ;
6091 int arg3 = (int) 0 ;
6092 int arg4 = (int) 0 ;
6093 wxRect *result = 0 ;
6094 int val1 ;
6095 int ecode1 = 0 ;
6096 int val2 ;
6097 int ecode2 = 0 ;
6098 int val3 ;
6099 int ecode3 = 0 ;
6100 int val4 ;
6101 int ecode4 = 0 ;
6102 PyObject * obj0 = 0 ;
6103 PyObject * obj1 = 0 ;
6104 PyObject * obj2 = 0 ;
6105 PyObject * obj3 = 0 ;
6106 char * kwnames[] = {
6107 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6108 };
6109
6110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6111 if (obj0) {
6112 ecode1 = SWIG_AsVal_int(obj0, &val1);
6113 if (!SWIG_IsOK(ecode1)) {
6114 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
6115 }
6116 arg1 = static_cast< int >(val1);
6117 }
6118 if (obj1) {
6119 ecode2 = SWIG_AsVal_int(obj1, &val2);
6120 if (!SWIG_IsOK(ecode2)) {
6121 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
6122 }
6123 arg2 = static_cast< int >(val2);
6124 }
6125 if (obj2) {
6126 ecode3 = SWIG_AsVal_int(obj2, &val3);
6127 if (!SWIG_IsOK(ecode3)) {
6128 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
6129 }
6130 arg3 = static_cast< int >(val3);
6131 }
6132 if (obj3) {
6133 ecode4 = SWIG_AsVal_int(obj3, &val4);
6134 if (!SWIG_IsOK(ecode4)) {
6135 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
6136 }
6137 arg4 = static_cast< int >(val4);
6138 }
6139 {
6140 PyThreadState* __tstate = wxPyBeginAllowThreads();
6141 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
6142 wxPyEndAllowThreads(__tstate);
6143 if (PyErr_Occurred()) SWIG_fail;
6144 }
6145 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
6146 return resultobj;
6147 fail:
6148 return NULL;
6149 }
6150
6151
6152 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6153 PyObject *resultobj = 0;
6154 wxPoint *arg1 = 0 ;
6155 wxPoint *arg2 = 0 ;
6156 wxRect *result = 0 ;
6157 wxPoint temp1 ;
6158 wxPoint temp2 ;
6159 PyObject * obj0 = 0 ;
6160 PyObject * obj1 = 0 ;
6161 char * kwnames[] = {
6162 (char *) "topLeft",(char *) "bottomRight", NULL
6163 };
6164
6165 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
6166 {
6167 arg1 = &temp1;
6168 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6169 }
6170 {
6171 arg2 = &temp2;
6172 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6173 }
6174 {
6175 PyThreadState* __tstate = wxPyBeginAllowThreads();
6176 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6177 wxPyEndAllowThreads(__tstate);
6178 if (PyErr_Occurred()) SWIG_fail;
6179 }
6180 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6181 return resultobj;
6182 fail:
6183 return NULL;
6184 }
6185
6186
6187 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6188 PyObject *resultobj = 0;
6189 wxPoint *arg1 = 0 ;
6190 wxSize *arg2 = 0 ;
6191 wxRect *result = 0 ;
6192 wxPoint temp1 ;
6193 wxSize temp2 ;
6194 PyObject * obj0 = 0 ;
6195 PyObject * obj1 = 0 ;
6196 char * kwnames[] = {
6197 (char *) "pos",(char *) "size", NULL
6198 };
6199
6200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6201 {
6202 arg1 = &temp1;
6203 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6204 }
6205 {
6206 arg2 = &temp2;
6207 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6208 }
6209 {
6210 PyThreadState* __tstate = wxPyBeginAllowThreads();
6211 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6212 wxPyEndAllowThreads(__tstate);
6213 if (PyErr_Occurred()) SWIG_fail;
6214 }
6215 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6216 return resultobj;
6217 fail:
6218 return NULL;
6219 }
6220
6221
6222 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6223 PyObject *resultobj = 0;
6224 wxSize *arg1 = 0 ;
6225 wxRect *result = 0 ;
6226 wxSize temp1 ;
6227 PyObject * obj0 = 0 ;
6228 char * kwnames[] = {
6229 (char *) "size", NULL
6230 };
6231
6232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6233 {
6234 arg1 = &temp1;
6235 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6236 }
6237 {
6238 PyThreadState* __tstate = wxPyBeginAllowThreads();
6239 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6240 wxPyEndAllowThreads(__tstate);
6241 if (PyErr_Occurred()) SWIG_fail;
6242 }
6243 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6244 return resultobj;
6245 fail:
6246 return NULL;
6247 }
6248
6249
6250 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6251 PyObject *resultobj = 0;
6252 wxRect *arg1 = (wxRect *) 0 ;
6253 void *argp1 = 0 ;
6254 int res1 = 0 ;
6255 PyObject *swig_obj[1] ;
6256
6257 if (!args) SWIG_fail;
6258 swig_obj[0] = args;
6259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6260 if (!SWIG_IsOK(res1)) {
6261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6262 }
6263 arg1 = reinterpret_cast< wxRect * >(argp1);
6264 {
6265 PyThreadState* __tstate = wxPyBeginAllowThreads();
6266 delete arg1;
6267
6268 wxPyEndAllowThreads(__tstate);
6269 if (PyErr_Occurred()) SWIG_fail;
6270 }
6271 resultobj = SWIG_Py_Void();
6272 return resultobj;
6273 fail:
6274 return NULL;
6275 }
6276
6277
6278 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6279 PyObject *resultobj = 0;
6280 wxRect *arg1 = (wxRect *) 0 ;
6281 int result;
6282 void *argp1 = 0 ;
6283 int res1 = 0 ;
6284 PyObject *swig_obj[1] ;
6285
6286 if (!args) SWIG_fail;
6287 swig_obj[0] = args;
6288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6289 if (!SWIG_IsOK(res1)) {
6290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6291 }
6292 arg1 = reinterpret_cast< wxRect * >(argp1);
6293 {
6294 PyThreadState* __tstate = wxPyBeginAllowThreads();
6295 result = (int)((wxRect const *)arg1)->GetX();
6296 wxPyEndAllowThreads(__tstate);
6297 if (PyErr_Occurred()) SWIG_fail;
6298 }
6299 resultobj = SWIG_From_int(static_cast< int >(result));
6300 return resultobj;
6301 fail:
6302 return NULL;
6303 }
6304
6305
6306 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6307 PyObject *resultobj = 0;
6308 wxRect *arg1 = (wxRect *) 0 ;
6309 int arg2 ;
6310 void *argp1 = 0 ;
6311 int res1 = 0 ;
6312 int val2 ;
6313 int ecode2 = 0 ;
6314 PyObject * obj0 = 0 ;
6315 PyObject * obj1 = 0 ;
6316 char * kwnames[] = {
6317 (char *) "self",(char *) "x", NULL
6318 };
6319
6320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6321 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6322 if (!SWIG_IsOK(res1)) {
6323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6324 }
6325 arg1 = reinterpret_cast< wxRect * >(argp1);
6326 ecode2 = SWIG_AsVal_int(obj1, &val2);
6327 if (!SWIG_IsOK(ecode2)) {
6328 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6329 }
6330 arg2 = static_cast< int >(val2);
6331 {
6332 PyThreadState* __tstate = wxPyBeginAllowThreads();
6333 (arg1)->SetX(arg2);
6334 wxPyEndAllowThreads(__tstate);
6335 if (PyErr_Occurred()) SWIG_fail;
6336 }
6337 resultobj = SWIG_Py_Void();
6338 return resultobj;
6339 fail:
6340 return NULL;
6341 }
6342
6343
6344 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6345 PyObject *resultobj = 0;
6346 wxRect *arg1 = (wxRect *) 0 ;
6347 int result;
6348 void *argp1 = 0 ;
6349 int res1 = 0 ;
6350 PyObject *swig_obj[1] ;
6351
6352 if (!args) SWIG_fail;
6353 swig_obj[0] = args;
6354 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6355 if (!SWIG_IsOK(res1)) {
6356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6357 }
6358 arg1 = reinterpret_cast< wxRect * >(argp1);
6359 {
6360 PyThreadState* __tstate = wxPyBeginAllowThreads();
6361 result = (int)(arg1)->GetY();
6362 wxPyEndAllowThreads(__tstate);
6363 if (PyErr_Occurred()) SWIG_fail;
6364 }
6365 resultobj = SWIG_From_int(static_cast< int >(result));
6366 return resultobj;
6367 fail:
6368 return NULL;
6369 }
6370
6371
6372 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6373 PyObject *resultobj = 0;
6374 wxRect *arg1 = (wxRect *) 0 ;
6375 int arg2 ;
6376 void *argp1 = 0 ;
6377 int res1 = 0 ;
6378 int val2 ;
6379 int ecode2 = 0 ;
6380 PyObject * obj0 = 0 ;
6381 PyObject * obj1 = 0 ;
6382 char * kwnames[] = {
6383 (char *) "self",(char *) "y", NULL
6384 };
6385
6386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6387 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6388 if (!SWIG_IsOK(res1)) {
6389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6390 }
6391 arg1 = reinterpret_cast< wxRect * >(argp1);
6392 ecode2 = SWIG_AsVal_int(obj1, &val2);
6393 if (!SWIG_IsOK(ecode2)) {
6394 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6395 }
6396 arg2 = static_cast< int >(val2);
6397 {
6398 PyThreadState* __tstate = wxPyBeginAllowThreads();
6399 (arg1)->SetY(arg2);
6400 wxPyEndAllowThreads(__tstate);
6401 if (PyErr_Occurred()) SWIG_fail;
6402 }
6403 resultobj = SWIG_Py_Void();
6404 return resultobj;
6405 fail:
6406 return NULL;
6407 }
6408
6409
6410 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6411 PyObject *resultobj = 0;
6412 wxRect *arg1 = (wxRect *) 0 ;
6413 int result;
6414 void *argp1 = 0 ;
6415 int res1 = 0 ;
6416 PyObject *swig_obj[1] ;
6417
6418 if (!args) SWIG_fail;
6419 swig_obj[0] = args;
6420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6421 if (!SWIG_IsOK(res1)) {
6422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6423 }
6424 arg1 = reinterpret_cast< wxRect * >(argp1);
6425 {
6426 PyThreadState* __tstate = wxPyBeginAllowThreads();
6427 result = (int)((wxRect const *)arg1)->GetWidth();
6428 wxPyEndAllowThreads(__tstate);
6429 if (PyErr_Occurred()) SWIG_fail;
6430 }
6431 resultobj = SWIG_From_int(static_cast< int >(result));
6432 return resultobj;
6433 fail:
6434 return NULL;
6435 }
6436
6437
6438 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6439 PyObject *resultobj = 0;
6440 wxRect *arg1 = (wxRect *) 0 ;
6441 int arg2 ;
6442 void *argp1 = 0 ;
6443 int res1 = 0 ;
6444 int val2 ;
6445 int ecode2 = 0 ;
6446 PyObject * obj0 = 0 ;
6447 PyObject * obj1 = 0 ;
6448 char * kwnames[] = {
6449 (char *) "self",(char *) "w", NULL
6450 };
6451
6452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6453 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6454 if (!SWIG_IsOK(res1)) {
6455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6456 }
6457 arg1 = reinterpret_cast< wxRect * >(argp1);
6458 ecode2 = SWIG_AsVal_int(obj1, &val2);
6459 if (!SWIG_IsOK(ecode2)) {
6460 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6461 }
6462 arg2 = static_cast< int >(val2);
6463 {
6464 PyThreadState* __tstate = wxPyBeginAllowThreads();
6465 (arg1)->SetWidth(arg2);
6466 wxPyEndAllowThreads(__tstate);
6467 if (PyErr_Occurred()) SWIG_fail;
6468 }
6469 resultobj = SWIG_Py_Void();
6470 return resultobj;
6471 fail:
6472 return NULL;
6473 }
6474
6475
6476 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6477 PyObject *resultobj = 0;
6478 wxRect *arg1 = (wxRect *) 0 ;
6479 int result;
6480 void *argp1 = 0 ;
6481 int res1 = 0 ;
6482 PyObject *swig_obj[1] ;
6483
6484 if (!args) SWIG_fail;
6485 swig_obj[0] = args;
6486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6487 if (!SWIG_IsOK(res1)) {
6488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6489 }
6490 arg1 = reinterpret_cast< wxRect * >(argp1);
6491 {
6492 PyThreadState* __tstate = wxPyBeginAllowThreads();
6493 result = (int)((wxRect const *)arg1)->GetHeight();
6494 wxPyEndAllowThreads(__tstate);
6495 if (PyErr_Occurred()) SWIG_fail;
6496 }
6497 resultobj = SWIG_From_int(static_cast< int >(result));
6498 return resultobj;
6499 fail:
6500 return NULL;
6501 }
6502
6503
6504 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6505 PyObject *resultobj = 0;
6506 wxRect *arg1 = (wxRect *) 0 ;
6507 int arg2 ;
6508 void *argp1 = 0 ;
6509 int res1 = 0 ;
6510 int val2 ;
6511 int ecode2 = 0 ;
6512 PyObject * obj0 = 0 ;
6513 PyObject * obj1 = 0 ;
6514 char * kwnames[] = {
6515 (char *) "self",(char *) "h", NULL
6516 };
6517
6518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6520 if (!SWIG_IsOK(res1)) {
6521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6522 }
6523 arg1 = reinterpret_cast< wxRect * >(argp1);
6524 ecode2 = SWIG_AsVal_int(obj1, &val2);
6525 if (!SWIG_IsOK(ecode2)) {
6526 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6527 }
6528 arg2 = static_cast< int >(val2);
6529 {
6530 PyThreadState* __tstate = wxPyBeginAllowThreads();
6531 (arg1)->SetHeight(arg2);
6532 wxPyEndAllowThreads(__tstate);
6533 if (PyErr_Occurred()) SWIG_fail;
6534 }
6535 resultobj = SWIG_Py_Void();
6536 return resultobj;
6537 fail:
6538 return NULL;
6539 }
6540
6541
6542 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6543 PyObject *resultobj = 0;
6544 wxRect *arg1 = (wxRect *) 0 ;
6545 wxPoint result;
6546 void *argp1 = 0 ;
6547 int res1 = 0 ;
6548 PyObject *swig_obj[1] ;
6549
6550 if (!args) SWIG_fail;
6551 swig_obj[0] = args;
6552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6553 if (!SWIG_IsOK(res1)) {
6554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6555 }
6556 arg1 = reinterpret_cast< wxRect * >(argp1);
6557 {
6558 PyThreadState* __tstate = wxPyBeginAllowThreads();
6559 result = ((wxRect const *)arg1)->GetPosition();
6560 wxPyEndAllowThreads(__tstate);
6561 if (PyErr_Occurred()) SWIG_fail;
6562 }
6563 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6564 return resultobj;
6565 fail:
6566 return NULL;
6567 }
6568
6569
6570 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6571 PyObject *resultobj = 0;
6572 wxRect *arg1 = (wxRect *) 0 ;
6573 wxPoint *arg2 = 0 ;
6574 void *argp1 = 0 ;
6575 int res1 = 0 ;
6576 wxPoint temp2 ;
6577 PyObject * obj0 = 0 ;
6578 PyObject * obj1 = 0 ;
6579 char * kwnames[] = {
6580 (char *) "self",(char *) "p", NULL
6581 };
6582
6583 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6584 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6585 if (!SWIG_IsOK(res1)) {
6586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6587 }
6588 arg1 = reinterpret_cast< wxRect * >(argp1);
6589 {
6590 arg2 = &temp2;
6591 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6592 }
6593 {
6594 PyThreadState* __tstate = wxPyBeginAllowThreads();
6595 (arg1)->SetPosition((wxPoint const &)*arg2);
6596 wxPyEndAllowThreads(__tstate);
6597 if (PyErr_Occurred()) SWIG_fail;
6598 }
6599 resultobj = SWIG_Py_Void();
6600 return resultobj;
6601 fail:
6602 return NULL;
6603 }
6604
6605
6606 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6607 PyObject *resultobj = 0;
6608 wxRect *arg1 = (wxRect *) 0 ;
6609 wxSize result;
6610 void *argp1 = 0 ;
6611 int res1 = 0 ;
6612 PyObject *swig_obj[1] ;
6613
6614 if (!args) SWIG_fail;
6615 swig_obj[0] = args;
6616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6617 if (!SWIG_IsOK(res1)) {
6618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6619 }
6620 arg1 = reinterpret_cast< wxRect * >(argp1);
6621 {
6622 PyThreadState* __tstate = wxPyBeginAllowThreads();
6623 result = ((wxRect const *)arg1)->GetSize();
6624 wxPyEndAllowThreads(__tstate);
6625 if (PyErr_Occurred()) SWIG_fail;
6626 }
6627 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6628 return resultobj;
6629 fail:
6630 return NULL;
6631 }
6632
6633
6634 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6635 PyObject *resultobj = 0;
6636 wxRect *arg1 = (wxRect *) 0 ;
6637 wxSize *arg2 = 0 ;
6638 void *argp1 = 0 ;
6639 int res1 = 0 ;
6640 wxSize temp2 ;
6641 PyObject * obj0 = 0 ;
6642 PyObject * obj1 = 0 ;
6643 char * kwnames[] = {
6644 (char *) "self",(char *) "s", NULL
6645 };
6646
6647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6649 if (!SWIG_IsOK(res1)) {
6650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6651 }
6652 arg1 = reinterpret_cast< wxRect * >(argp1);
6653 {
6654 arg2 = &temp2;
6655 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6656 }
6657 {
6658 PyThreadState* __tstate = wxPyBeginAllowThreads();
6659 (arg1)->SetSize((wxSize const &)*arg2);
6660 wxPyEndAllowThreads(__tstate);
6661 if (PyErr_Occurred()) SWIG_fail;
6662 }
6663 resultobj = SWIG_Py_Void();
6664 return resultobj;
6665 fail:
6666 return NULL;
6667 }
6668
6669
6670 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6671 PyObject *resultobj = 0;
6672 wxRect *arg1 = (wxRect *) 0 ;
6673 bool result;
6674 void *argp1 = 0 ;
6675 int res1 = 0 ;
6676 PyObject *swig_obj[1] ;
6677
6678 if (!args) SWIG_fail;
6679 swig_obj[0] = args;
6680 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6681 if (!SWIG_IsOK(res1)) {
6682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6683 }
6684 arg1 = reinterpret_cast< wxRect * >(argp1);
6685 {
6686 PyThreadState* __tstate = wxPyBeginAllowThreads();
6687 result = (bool)((wxRect const *)arg1)->IsEmpty();
6688 wxPyEndAllowThreads(__tstate);
6689 if (PyErr_Occurred()) SWIG_fail;
6690 }
6691 {
6692 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6693 }
6694 return resultobj;
6695 fail:
6696 return NULL;
6697 }
6698
6699
6700 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6701 PyObject *resultobj = 0;
6702 wxRect *arg1 = (wxRect *) 0 ;
6703 wxPoint result;
6704 void *argp1 = 0 ;
6705 int res1 = 0 ;
6706 PyObject *swig_obj[1] ;
6707
6708 if (!args) SWIG_fail;
6709 swig_obj[0] = args;
6710 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6711 if (!SWIG_IsOK(res1)) {
6712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6713 }
6714 arg1 = reinterpret_cast< wxRect * >(argp1);
6715 {
6716 PyThreadState* __tstate = wxPyBeginAllowThreads();
6717 result = ((wxRect const *)arg1)->GetTopLeft();
6718 wxPyEndAllowThreads(__tstate);
6719 if (PyErr_Occurred()) SWIG_fail;
6720 }
6721 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6722 return resultobj;
6723 fail:
6724 return NULL;
6725 }
6726
6727
6728 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6729 PyObject *resultobj = 0;
6730 wxRect *arg1 = (wxRect *) 0 ;
6731 wxPoint *arg2 = 0 ;
6732 void *argp1 = 0 ;
6733 int res1 = 0 ;
6734 wxPoint temp2 ;
6735 PyObject * obj0 = 0 ;
6736 PyObject * obj1 = 0 ;
6737 char * kwnames[] = {
6738 (char *) "self",(char *) "p", NULL
6739 };
6740
6741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6743 if (!SWIG_IsOK(res1)) {
6744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6745 }
6746 arg1 = reinterpret_cast< wxRect * >(argp1);
6747 {
6748 arg2 = &temp2;
6749 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6750 }
6751 {
6752 PyThreadState* __tstate = wxPyBeginAllowThreads();
6753 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6754 wxPyEndAllowThreads(__tstate);
6755 if (PyErr_Occurred()) SWIG_fail;
6756 }
6757 resultobj = SWIG_Py_Void();
6758 return resultobj;
6759 fail:
6760 return NULL;
6761 }
6762
6763
6764 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6765 PyObject *resultobj = 0;
6766 wxRect *arg1 = (wxRect *) 0 ;
6767 wxPoint result;
6768 void *argp1 = 0 ;
6769 int res1 = 0 ;
6770 PyObject *swig_obj[1] ;
6771
6772 if (!args) SWIG_fail;
6773 swig_obj[0] = args;
6774 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6775 if (!SWIG_IsOK(res1)) {
6776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6777 }
6778 arg1 = reinterpret_cast< wxRect * >(argp1);
6779 {
6780 PyThreadState* __tstate = wxPyBeginAllowThreads();
6781 result = ((wxRect const *)arg1)->GetBottomRight();
6782 wxPyEndAllowThreads(__tstate);
6783 if (PyErr_Occurred()) SWIG_fail;
6784 }
6785 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6786 return resultobj;
6787 fail:
6788 return NULL;
6789 }
6790
6791
6792 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6793 PyObject *resultobj = 0;
6794 wxRect *arg1 = (wxRect *) 0 ;
6795 wxPoint *arg2 = 0 ;
6796 void *argp1 = 0 ;
6797 int res1 = 0 ;
6798 wxPoint temp2 ;
6799 PyObject * obj0 = 0 ;
6800 PyObject * obj1 = 0 ;
6801 char * kwnames[] = {
6802 (char *) "self",(char *) "p", NULL
6803 };
6804
6805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6806 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6807 if (!SWIG_IsOK(res1)) {
6808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6809 }
6810 arg1 = reinterpret_cast< wxRect * >(argp1);
6811 {
6812 arg2 = &temp2;
6813 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6814 }
6815 {
6816 PyThreadState* __tstate = wxPyBeginAllowThreads();
6817 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6818 wxPyEndAllowThreads(__tstate);
6819 if (PyErr_Occurred()) SWIG_fail;
6820 }
6821 resultobj = SWIG_Py_Void();
6822 return resultobj;
6823 fail:
6824 return NULL;
6825 }
6826
6827
6828 SWIGINTERN PyObject *_wrap_Rect_GetTopRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6829 PyObject *resultobj = 0;
6830 wxRect *arg1 = (wxRect *) 0 ;
6831 wxPoint result;
6832 void *argp1 = 0 ;
6833 int res1 = 0 ;
6834 PyObject *swig_obj[1] ;
6835
6836 if (!args) SWIG_fail;
6837 swig_obj[0] = args;
6838 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6839 if (!SWIG_IsOK(res1)) {
6840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6841 }
6842 arg1 = reinterpret_cast< wxRect * >(argp1);
6843 {
6844 PyThreadState* __tstate = wxPyBeginAllowThreads();
6845 result = ((wxRect const *)arg1)->GetTopRight();
6846 wxPyEndAllowThreads(__tstate);
6847 if (PyErr_Occurred()) SWIG_fail;
6848 }
6849 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6850 return resultobj;
6851 fail:
6852 return NULL;
6853 }
6854
6855
6856 SWIGINTERN PyObject *_wrap_Rect_SetTopRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6857 PyObject *resultobj = 0;
6858 wxRect *arg1 = (wxRect *) 0 ;
6859 wxPoint *arg2 = 0 ;
6860 void *argp1 = 0 ;
6861 int res1 = 0 ;
6862 wxPoint temp2 ;
6863 PyObject * obj0 = 0 ;
6864 PyObject * obj1 = 0 ;
6865 char * kwnames[] = {
6866 (char *) "self",(char *) "p", NULL
6867 };
6868
6869 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopRight",kwnames,&obj0,&obj1)) SWIG_fail;
6870 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6871 if (!SWIG_IsOK(res1)) {
6872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopRight" "', expected argument " "1"" of type '" "wxRect *""'");
6873 }
6874 arg1 = reinterpret_cast< wxRect * >(argp1);
6875 {
6876 arg2 = &temp2;
6877 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6878 }
6879 {
6880 PyThreadState* __tstate = wxPyBeginAllowThreads();
6881 (arg1)->SetTopRight((wxPoint const &)*arg2);
6882 wxPyEndAllowThreads(__tstate);
6883 if (PyErr_Occurred()) SWIG_fail;
6884 }
6885 resultobj = SWIG_Py_Void();
6886 return resultobj;
6887 fail:
6888 return NULL;
6889 }
6890
6891
6892 SWIGINTERN PyObject *_wrap_Rect_GetBottomLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6893 PyObject *resultobj = 0;
6894 wxRect *arg1 = (wxRect *) 0 ;
6895 wxPoint result;
6896 void *argp1 = 0 ;
6897 int res1 = 0 ;
6898 PyObject *swig_obj[1] ;
6899
6900 if (!args) SWIG_fail;
6901 swig_obj[0] = args;
6902 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6903 if (!SWIG_IsOK(res1)) {
6904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6905 }
6906 arg1 = reinterpret_cast< wxRect * >(argp1);
6907 {
6908 PyThreadState* __tstate = wxPyBeginAllowThreads();
6909 result = ((wxRect const *)arg1)->GetBottomLeft();
6910 wxPyEndAllowThreads(__tstate);
6911 if (PyErr_Occurred()) SWIG_fail;
6912 }
6913 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6914 return resultobj;
6915 fail:
6916 return NULL;
6917 }
6918
6919
6920 SWIGINTERN PyObject *_wrap_Rect_SetBottomLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6921 PyObject *resultobj = 0;
6922 wxRect *arg1 = (wxRect *) 0 ;
6923 wxPoint *arg2 = 0 ;
6924 void *argp1 = 0 ;
6925 int res1 = 0 ;
6926 wxPoint temp2 ;
6927 PyObject * obj0 = 0 ;
6928 PyObject * obj1 = 0 ;
6929 char * kwnames[] = {
6930 (char *) "self",(char *) "p", NULL
6931 };
6932
6933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6934 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6935 if (!SWIG_IsOK(res1)) {
6936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6937 }
6938 arg1 = reinterpret_cast< wxRect * >(argp1);
6939 {
6940 arg2 = &temp2;
6941 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6942 }
6943 {
6944 PyThreadState* __tstate = wxPyBeginAllowThreads();
6945 (arg1)->SetBottomLeft((wxPoint const &)*arg2);
6946 wxPyEndAllowThreads(__tstate);
6947 if (PyErr_Occurred()) SWIG_fail;
6948 }
6949 resultobj = SWIG_Py_Void();
6950 return resultobj;
6951 fail:
6952 return NULL;
6953 }
6954
6955
6956 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6957 PyObject *resultobj = 0;
6958 wxRect *arg1 = (wxRect *) 0 ;
6959 int result;
6960 void *argp1 = 0 ;
6961 int res1 = 0 ;
6962 PyObject *swig_obj[1] ;
6963
6964 if (!args) SWIG_fail;
6965 swig_obj[0] = args;
6966 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6967 if (!SWIG_IsOK(res1)) {
6968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6969 }
6970 arg1 = reinterpret_cast< wxRect * >(argp1);
6971 {
6972 PyThreadState* __tstate = wxPyBeginAllowThreads();
6973 result = (int)((wxRect const *)arg1)->GetLeft();
6974 wxPyEndAllowThreads(__tstate);
6975 if (PyErr_Occurred()) SWIG_fail;
6976 }
6977 resultobj = SWIG_From_int(static_cast< int >(result));
6978 return resultobj;
6979 fail:
6980 return NULL;
6981 }
6982
6983
6984 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6985 PyObject *resultobj = 0;
6986 wxRect *arg1 = (wxRect *) 0 ;
6987 int result;
6988 void *argp1 = 0 ;
6989 int res1 = 0 ;
6990 PyObject *swig_obj[1] ;
6991
6992 if (!args) SWIG_fail;
6993 swig_obj[0] = args;
6994 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6995 if (!SWIG_IsOK(res1)) {
6996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
6997 }
6998 arg1 = reinterpret_cast< wxRect * >(argp1);
6999 {
7000 PyThreadState* __tstate = wxPyBeginAllowThreads();
7001 result = (int)((wxRect const *)arg1)->GetTop();
7002 wxPyEndAllowThreads(__tstate);
7003 if (PyErr_Occurred()) SWIG_fail;
7004 }
7005 resultobj = SWIG_From_int(static_cast< int >(result));
7006 return resultobj;
7007 fail:
7008 return NULL;
7009 }
7010
7011
7012 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7013 PyObject *resultobj = 0;
7014 wxRect *arg1 = (wxRect *) 0 ;
7015 int result;
7016 void *argp1 = 0 ;
7017 int res1 = 0 ;
7018 PyObject *swig_obj[1] ;
7019
7020 if (!args) SWIG_fail;
7021 swig_obj[0] = args;
7022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7023 if (!SWIG_IsOK(res1)) {
7024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
7025 }
7026 arg1 = reinterpret_cast< wxRect * >(argp1);
7027 {
7028 PyThreadState* __tstate = wxPyBeginAllowThreads();
7029 result = (int)((wxRect const *)arg1)->GetBottom();
7030 wxPyEndAllowThreads(__tstate);
7031 if (PyErr_Occurred()) SWIG_fail;
7032 }
7033 resultobj = SWIG_From_int(static_cast< int >(result));
7034 return resultobj;
7035 fail:
7036 return NULL;
7037 }
7038
7039
7040 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7041 PyObject *resultobj = 0;
7042 wxRect *arg1 = (wxRect *) 0 ;
7043 int result;
7044 void *argp1 = 0 ;
7045 int res1 = 0 ;
7046 PyObject *swig_obj[1] ;
7047
7048 if (!args) SWIG_fail;
7049 swig_obj[0] = args;
7050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7051 if (!SWIG_IsOK(res1)) {
7052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
7053 }
7054 arg1 = reinterpret_cast< wxRect * >(argp1);
7055 {
7056 PyThreadState* __tstate = wxPyBeginAllowThreads();
7057 result = (int)((wxRect const *)arg1)->GetRight();
7058 wxPyEndAllowThreads(__tstate);
7059 if (PyErr_Occurred()) SWIG_fail;
7060 }
7061 resultobj = SWIG_From_int(static_cast< int >(result));
7062 return resultobj;
7063 fail:
7064 return NULL;
7065 }
7066
7067
7068 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7069 PyObject *resultobj = 0;
7070 wxRect *arg1 = (wxRect *) 0 ;
7071 int arg2 ;
7072 void *argp1 = 0 ;
7073 int res1 = 0 ;
7074 int val2 ;
7075 int ecode2 = 0 ;
7076 PyObject * obj0 = 0 ;
7077 PyObject * obj1 = 0 ;
7078 char * kwnames[] = {
7079 (char *) "self",(char *) "left", NULL
7080 };
7081
7082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
7083 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7084 if (!SWIG_IsOK(res1)) {
7085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
7086 }
7087 arg1 = reinterpret_cast< wxRect * >(argp1);
7088 ecode2 = SWIG_AsVal_int(obj1, &val2);
7089 if (!SWIG_IsOK(ecode2)) {
7090 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
7091 }
7092 arg2 = static_cast< int >(val2);
7093 {
7094 PyThreadState* __tstate = wxPyBeginAllowThreads();
7095 (arg1)->SetLeft(arg2);
7096 wxPyEndAllowThreads(__tstate);
7097 if (PyErr_Occurred()) SWIG_fail;
7098 }
7099 resultobj = SWIG_Py_Void();
7100 return resultobj;
7101 fail:
7102 return NULL;
7103 }
7104
7105
7106 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7107 PyObject *resultobj = 0;
7108 wxRect *arg1 = (wxRect *) 0 ;
7109 int arg2 ;
7110 void *argp1 = 0 ;
7111 int res1 = 0 ;
7112 int val2 ;
7113 int ecode2 = 0 ;
7114 PyObject * obj0 = 0 ;
7115 PyObject * obj1 = 0 ;
7116 char * kwnames[] = {
7117 (char *) "self",(char *) "right", NULL
7118 };
7119
7120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
7121 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7122 if (!SWIG_IsOK(res1)) {
7123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
7124 }
7125 arg1 = reinterpret_cast< wxRect * >(argp1);
7126 ecode2 = SWIG_AsVal_int(obj1, &val2);
7127 if (!SWIG_IsOK(ecode2)) {
7128 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
7129 }
7130 arg2 = static_cast< int >(val2);
7131 {
7132 PyThreadState* __tstate = wxPyBeginAllowThreads();
7133 (arg1)->SetRight(arg2);
7134 wxPyEndAllowThreads(__tstate);
7135 if (PyErr_Occurred()) SWIG_fail;
7136 }
7137 resultobj = SWIG_Py_Void();
7138 return resultobj;
7139 fail:
7140 return NULL;
7141 }
7142
7143
7144 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7145 PyObject *resultobj = 0;
7146 wxRect *arg1 = (wxRect *) 0 ;
7147 int arg2 ;
7148 void *argp1 = 0 ;
7149 int res1 = 0 ;
7150 int val2 ;
7151 int ecode2 = 0 ;
7152 PyObject * obj0 = 0 ;
7153 PyObject * obj1 = 0 ;
7154 char * kwnames[] = {
7155 (char *) "self",(char *) "top", NULL
7156 };
7157
7158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
7159 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7160 if (!SWIG_IsOK(res1)) {
7161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
7162 }
7163 arg1 = reinterpret_cast< wxRect * >(argp1);
7164 ecode2 = SWIG_AsVal_int(obj1, &val2);
7165 if (!SWIG_IsOK(ecode2)) {
7166 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
7167 }
7168 arg2 = static_cast< int >(val2);
7169 {
7170 PyThreadState* __tstate = wxPyBeginAllowThreads();
7171 (arg1)->SetTop(arg2);
7172 wxPyEndAllowThreads(__tstate);
7173 if (PyErr_Occurred()) SWIG_fail;
7174 }
7175 resultobj = SWIG_Py_Void();
7176 return resultobj;
7177 fail:
7178 return NULL;
7179 }
7180
7181
7182 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7183 PyObject *resultobj = 0;
7184 wxRect *arg1 = (wxRect *) 0 ;
7185 int arg2 ;
7186 void *argp1 = 0 ;
7187 int res1 = 0 ;
7188 int val2 ;
7189 int ecode2 = 0 ;
7190 PyObject * obj0 = 0 ;
7191 PyObject * obj1 = 0 ;
7192 char * kwnames[] = {
7193 (char *) "self",(char *) "bottom", NULL
7194 };
7195
7196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
7197 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7198 if (!SWIG_IsOK(res1)) {
7199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
7200 }
7201 arg1 = reinterpret_cast< wxRect * >(argp1);
7202 ecode2 = SWIG_AsVal_int(obj1, &val2);
7203 if (!SWIG_IsOK(ecode2)) {
7204 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
7205 }
7206 arg2 = static_cast< int >(val2);
7207 {
7208 PyThreadState* __tstate = wxPyBeginAllowThreads();
7209 (arg1)->SetBottom(arg2);
7210 wxPyEndAllowThreads(__tstate);
7211 if (PyErr_Occurred()) SWIG_fail;
7212 }
7213 resultobj = SWIG_Py_Void();
7214 return resultobj;
7215 fail:
7216 return NULL;
7217 }
7218
7219
7220 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7221 PyObject *resultobj = 0;
7222 wxRect *arg1 = (wxRect *) 0 ;
7223 int arg2 ;
7224 int arg3 ;
7225 wxRect *result = 0 ;
7226 void *argp1 = 0 ;
7227 int res1 = 0 ;
7228 int val2 ;
7229 int ecode2 = 0 ;
7230 int val3 ;
7231 int ecode3 = 0 ;
7232 PyObject * obj0 = 0 ;
7233 PyObject * obj1 = 0 ;
7234 PyObject * obj2 = 0 ;
7235 char * kwnames[] = {
7236 (char *) "self",(char *) "dx",(char *) "dy", NULL
7237 };
7238
7239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7240 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7241 if (!SWIG_IsOK(res1)) {
7242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
7243 }
7244 arg1 = reinterpret_cast< wxRect * >(argp1);
7245 ecode2 = SWIG_AsVal_int(obj1, &val2);
7246 if (!SWIG_IsOK(ecode2)) {
7247 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
7248 }
7249 arg2 = static_cast< int >(val2);
7250 ecode3 = SWIG_AsVal_int(obj2, &val3);
7251 if (!SWIG_IsOK(ecode3)) {
7252 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
7253 }
7254 arg3 = static_cast< int >(val3);
7255 {
7256 PyThreadState* __tstate = wxPyBeginAllowThreads();
7257 {
7258 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
7259 result = (wxRect *) &_result_ref;
7260 }
7261 wxPyEndAllowThreads(__tstate);
7262 if (PyErr_Occurred()) SWIG_fail;
7263 }
7264 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7265 return resultobj;
7266 fail:
7267 return NULL;
7268 }
7269
7270
7271 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7272 PyObject *resultobj = 0;
7273 wxRect *arg1 = (wxRect *) 0 ;
7274 int arg2 ;
7275 int arg3 ;
7276 wxRect *result = 0 ;
7277 void *argp1 = 0 ;
7278 int res1 = 0 ;
7279 int val2 ;
7280 int ecode2 = 0 ;
7281 int val3 ;
7282 int ecode3 = 0 ;
7283 PyObject * obj0 = 0 ;
7284 PyObject * obj1 = 0 ;
7285 PyObject * obj2 = 0 ;
7286 char * kwnames[] = {
7287 (char *) "self",(char *) "dx",(char *) "dy", NULL
7288 };
7289
7290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7292 if (!SWIG_IsOK(res1)) {
7293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
7294 }
7295 arg1 = reinterpret_cast< wxRect * >(argp1);
7296 ecode2 = SWIG_AsVal_int(obj1, &val2);
7297 if (!SWIG_IsOK(ecode2)) {
7298 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7299 }
7300 arg2 = static_cast< int >(val2);
7301 ecode3 = SWIG_AsVal_int(obj2, &val3);
7302 if (!SWIG_IsOK(ecode3)) {
7303 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7304 }
7305 arg3 = static_cast< int >(val3);
7306 {
7307 PyThreadState* __tstate = wxPyBeginAllowThreads();
7308 {
7309 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7310 result = (wxRect *) &_result_ref;
7311 }
7312 wxPyEndAllowThreads(__tstate);
7313 if (PyErr_Occurred()) SWIG_fail;
7314 }
7315 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7316 return resultobj;
7317 fail:
7318 return NULL;
7319 }
7320
7321
7322 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7323 PyObject *resultobj = 0;
7324 wxRect *arg1 = (wxRect *) 0 ;
7325 int arg2 ;
7326 int arg3 ;
7327 void *argp1 = 0 ;
7328 int res1 = 0 ;
7329 int val2 ;
7330 int ecode2 = 0 ;
7331 int val3 ;
7332 int ecode3 = 0 ;
7333 PyObject * obj0 = 0 ;
7334 PyObject * obj1 = 0 ;
7335 PyObject * obj2 = 0 ;
7336 char * kwnames[] = {
7337 (char *) "self",(char *) "dx",(char *) "dy", NULL
7338 };
7339
7340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7342 if (!SWIG_IsOK(res1)) {
7343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7344 }
7345 arg1 = reinterpret_cast< wxRect * >(argp1);
7346 ecode2 = SWIG_AsVal_int(obj1, &val2);
7347 if (!SWIG_IsOK(ecode2)) {
7348 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7349 }
7350 arg2 = static_cast< int >(val2);
7351 ecode3 = SWIG_AsVal_int(obj2, &val3);
7352 if (!SWIG_IsOK(ecode3)) {
7353 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7354 }
7355 arg3 = static_cast< int >(val3);
7356 {
7357 PyThreadState* __tstate = wxPyBeginAllowThreads();
7358 (arg1)->Offset(arg2,arg3);
7359 wxPyEndAllowThreads(__tstate);
7360 if (PyErr_Occurred()) SWIG_fail;
7361 }
7362 resultobj = SWIG_Py_Void();
7363 return resultobj;
7364 fail:
7365 return NULL;
7366 }
7367
7368
7369 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7370 PyObject *resultobj = 0;
7371 wxRect *arg1 = (wxRect *) 0 ;
7372 wxPoint *arg2 = 0 ;
7373 void *argp1 = 0 ;
7374 int res1 = 0 ;
7375 wxPoint temp2 ;
7376 PyObject * obj0 = 0 ;
7377 PyObject * obj1 = 0 ;
7378 char * kwnames[] = {
7379 (char *) "self",(char *) "pt", NULL
7380 };
7381
7382 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7383 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7384 if (!SWIG_IsOK(res1)) {
7385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7386 }
7387 arg1 = reinterpret_cast< wxRect * >(argp1);
7388 {
7389 arg2 = &temp2;
7390 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7391 }
7392 {
7393 PyThreadState* __tstate = wxPyBeginAllowThreads();
7394 (arg1)->Offset((wxPoint const &)*arg2);
7395 wxPyEndAllowThreads(__tstate);
7396 if (PyErr_Occurred()) SWIG_fail;
7397 }
7398 resultobj = SWIG_Py_Void();
7399 return resultobj;
7400 fail:
7401 return NULL;
7402 }
7403
7404
7405 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7406 PyObject *resultobj = 0;
7407 wxRect *arg1 = (wxRect *) 0 ;
7408 wxRect *arg2 = 0 ;
7409 wxRect result;
7410 void *argp1 = 0 ;
7411 int res1 = 0 ;
7412 wxRect temp2 ;
7413 PyObject * obj0 = 0 ;
7414 PyObject * obj1 = 0 ;
7415 char * kwnames[] = {
7416 (char *) "self",(char *) "rect", NULL
7417 };
7418
7419 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7420 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7421 if (!SWIG_IsOK(res1)) {
7422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7423 }
7424 arg1 = reinterpret_cast< wxRect * >(argp1);
7425 {
7426 arg2 = &temp2;
7427 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7428 }
7429 {
7430 PyThreadState* __tstate = wxPyBeginAllowThreads();
7431 result = (arg1)->Intersect((wxRect const &)*arg2);
7432 wxPyEndAllowThreads(__tstate);
7433 if (PyErr_Occurred()) SWIG_fail;
7434 }
7435 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7436 return resultobj;
7437 fail:
7438 return NULL;
7439 }
7440
7441
7442 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7443 PyObject *resultobj = 0;
7444 wxRect *arg1 = (wxRect *) 0 ;
7445 wxRect *arg2 = 0 ;
7446 wxRect result;
7447 void *argp1 = 0 ;
7448 int res1 = 0 ;
7449 wxRect temp2 ;
7450 PyObject * obj0 = 0 ;
7451 PyObject * obj1 = 0 ;
7452 char * kwnames[] = {
7453 (char *) "self",(char *) "rect", NULL
7454 };
7455
7456 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7457 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7458 if (!SWIG_IsOK(res1)) {
7459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7460 }
7461 arg1 = reinterpret_cast< wxRect * >(argp1);
7462 {
7463 arg2 = &temp2;
7464 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7465 }
7466 {
7467 PyThreadState* __tstate = wxPyBeginAllowThreads();
7468 result = (arg1)->Union((wxRect const &)*arg2);
7469 wxPyEndAllowThreads(__tstate);
7470 if (PyErr_Occurred()) SWIG_fail;
7471 }
7472 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7473 return resultobj;
7474 fail:
7475 return NULL;
7476 }
7477
7478
7479 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7480 PyObject *resultobj = 0;
7481 wxRect *arg1 = (wxRect *) 0 ;
7482 wxRect *arg2 = 0 ;
7483 wxRect result;
7484 void *argp1 = 0 ;
7485 int res1 = 0 ;
7486 wxRect temp2 ;
7487 PyObject * obj0 = 0 ;
7488 PyObject * obj1 = 0 ;
7489 char * kwnames[] = {
7490 (char *) "self",(char *) "rect", NULL
7491 };
7492
7493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7494 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7495 if (!SWIG_IsOK(res1)) {
7496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7497 }
7498 arg1 = reinterpret_cast< wxRect * >(argp1);
7499 {
7500 arg2 = &temp2;
7501 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7502 }
7503 {
7504 PyThreadState* __tstate = wxPyBeginAllowThreads();
7505 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7506 wxPyEndAllowThreads(__tstate);
7507 if (PyErr_Occurred()) SWIG_fail;
7508 }
7509 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7510 return resultobj;
7511 fail:
7512 return NULL;
7513 }
7514
7515
7516 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7517 PyObject *resultobj = 0;
7518 wxRect *arg1 = (wxRect *) 0 ;
7519 wxRect *arg2 = 0 ;
7520 wxRect *result = 0 ;
7521 void *argp1 = 0 ;
7522 int res1 = 0 ;
7523 wxRect temp2 ;
7524 PyObject * obj0 = 0 ;
7525 PyObject * obj1 = 0 ;
7526 char * kwnames[] = {
7527 (char *) "self",(char *) "rect", NULL
7528 };
7529
7530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7532 if (!SWIG_IsOK(res1)) {
7533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7534 }
7535 arg1 = reinterpret_cast< wxRect * >(argp1);
7536 {
7537 arg2 = &temp2;
7538 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7539 }
7540 {
7541 PyThreadState* __tstate = wxPyBeginAllowThreads();
7542 {
7543 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7544 result = (wxRect *) &_result_ref;
7545 }
7546 wxPyEndAllowThreads(__tstate);
7547 if (PyErr_Occurred()) SWIG_fail;
7548 }
7549 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7550 return resultobj;
7551 fail:
7552 return NULL;
7553 }
7554
7555
7556 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7557 PyObject *resultobj = 0;
7558 wxRect *arg1 = (wxRect *) 0 ;
7559 PyObject *arg2 = (PyObject *) 0 ;
7560 bool result;
7561 void *argp1 = 0 ;
7562 int res1 = 0 ;
7563 PyObject * obj0 = 0 ;
7564 PyObject * obj1 = 0 ;
7565 char * kwnames[] = {
7566 (char *) "self",(char *) "other", NULL
7567 };
7568
7569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7570 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7571 if (!SWIG_IsOK(res1)) {
7572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect *""'");
7573 }
7574 arg1 = reinterpret_cast< wxRect * >(argp1);
7575 arg2 = obj1;
7576 {
7577 result = (bool)wxRect___eq__(arg1,arg2);
7578 if (PyErr_Occurred()) SWIG_fail;
7579 }
7580 {
7581 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7582 }
7583 return resultobj;
7584 fail:
7585 return NULL;
7586 }
7587
7588
7589 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7590 PyObject *resultobj = 0;
7591 wxRect *arg1 = (wxRect *) 0 ;
7592 PyObject *arg2 = (PyObject *) 0 ;
7593 bool result;
7594 void *argp1 = 0 ;
7595 int res1 = 0 ;
7596 PyObject * obj0 = 0 ;
7597 PyObject * obj1 = 0 ;
7598 char * kwnames[] = {
7599 (char *) "self",(char *) "other", NULL
7600 };
7601
7602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7603 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7604 if (!SWIG_IsOK(res1)) {
7605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect *""'");
7606 }
7607 arg1 = reinterpret_cast< wxRect * >(argp1);
7608 arg2 = obj1;
7609 {
7610 result = (bool)wxRect___ne__(arg1,arg2);
7611 if (PyErr_Occurred()) SWIG_fail;
7612 }
7613 {
7614 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7615 }
7616 return resultobj;
7617 fail:
7618 return NULL;
7619 }
7620
7621
7622 SWIGINTERN PyObject *_wrap_Rect_ContainsXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7623 PyObject *resultobj = 0;
7624 wxRect *arg1 = (wxRect *) 0 ;
7625 int arg2 ;
7626 int arg3 ;
7627 bool result;
7628 void *argp1 = 0 ;
7629 int res1 = 0 ;
7630 int val2 ;
7631 int ecode2 = 0 ;
7632 int val3 ;
7633 int ecode3 = 0 ;
7634 PyObject * obj0 = 0 ;
7635 PyObject * obj1 = 0 ;
7636 PyObject * obj2 = 0 ;
7637 char * kwnames[] = {
7638 (char *) "self",(char *) "x",(char *) "y", NULL
7639 };
7640
7641 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_ContainsXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7642 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7643 if (!SWIG_IsOK(res1)) {
7644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7645 }
7646 arg1 = reinterpret_cast< wxRect * >(argp1);
7647 ecode2 = SWIG_AsVal_int(obj1, &val2);
7648 if (!SWIG_IsOK(ecode2)) {
7649 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_ContainsXY" "', expected argument " "2"" of type '" "int""'");
7650 }
7651 arg2 = static_cast< int >(val2);
7652 ecode3 = SWIG_AsVal_int(obj2, &val3);
7653 if (!SWIG_IsOK(ecode3)) {
7654 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_ContainsXY" "', expected argument " "3"" of type '" "int""'");
7655 }
7656 arg3 = static_cast< int >(val3);
7657 {
7658 PyThreadState* __tstate = wxPyBeginAllowThreads();
7659 result = (bool)((wxRect const *)arg1)->Contains(arg2,arg3);
7660 wxPyEndAllowThreads(__tstate);
7661 if (PyErr_Occurred()) SWIG_fail;
7662 }
7663 {
7664 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7665 }
7666 return resultobj;
7667 fail:
7668 return NULL;
7669 }
7670
7671
7672 SWIGINTERN PyObject *_wrap_Rect_Contains(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7673 PyObject *resultobj = 0;
7674 wxRect *arg1 = (wxRect *) 0 ;
7675 wxPoint *arg2 = 0 ;
7676 bool result;
7677 void *argp1 = 0 ;
7678 int res1 = 0 ;
7679 wxPoint temp2 ;
7680 PyObject * obj0 = 0 ;
7681 PyObject * obj1 = 0 ;
7682 char * kwnames[] = {
7683 (char *) "self",(char *) "pt", NULL
7684 };
7685
7686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Contains",kwnames,&obj0,&obj1)) SWIG_fail;
7687 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7688 if (!SWIG_IsOK(res1)) {
7689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Contains" "', expected argument " "1"" of type '" "wxRect const *""'");
7690 }
7691 arg1 = reinterpret_cast< wxRect * >(argp1);
7692 {
7693 arg2 = &temp2;
7694 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7695 }
7696 {
7697 PyThreadState* __tstate = wxPyBeginAllowThreads();
7698 result = (bool)((wxRect const *)arg1)->Contains((wxPoint const &)*arg2);
7699 wxPyEndAllowThreads(__tstate);
7700 if (PyErr_Occurred()) SWIG_fail;
7701 }
7702 {
7703 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7704 }
7705 return resultobj;
7706 fail:
7707 return NULL;
7708 }
7709
7710
7711 SWIGINTERN PyObject *_wrap_Rect_ContainsRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7712 PyObject *resultobj = 0;
7713 wxRect *arg1 = (wxRect *) 0 ;
7714 wxRect *arg2 = 0 ;
7715 bool result;
7716 void *argp1 = 0 ;
7717 int res1 = 0 ;
7718 wxRect temp2 ;
7719 PyObject * obj0 = 0 ;
7720 PyObject * obj1 = 0 ;
7721 char * kwnames[] = {
7722 (char *) "self",(char *) "rect", NULL
7723 };
7724
7725 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_ContainsRect",kwnames,&obj0,&obj1)) SWIG_fail;
7726 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7727 if (!SWIG_IsOK(res1)) {
7728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsRect" "', expected argument " "1"" of type '" "wxRect const *""'");
7729 }
7730 arg1 = reinterpret_cast< wxRect * >(argp1);
7731 {
7732 arg2 = &temp2;
7733 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7734 }
7735 {
7736 PyThreadState* __tstate = wxPyBeginAllowThreads();
7737 result = (bool)((wxRect const *)arg1)->Contains((wxRect const &)*arg2);
7738 wxPyEndAllowThreads(__tstate);
7739 if (PyErr_Occurred()) SWIG_fail;
7740 }
7741 {
7742 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7743 }
7744 return resultobj;
7745 fail:
7746 return NULL;
7747 }
7748
7749
7750 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7751 PyObject *resultobj = 0;
7752 wxRect *arg1 = (wxRect *) 0 ;
7753 wxRect *arg2 = 0 ;
7754 bool result;
7755 void *argp1 = 0 ;
7756 int res1 = 0 ;
7757 wxRect temp2 ;
7758 PyObject * obj0 = 0 ;
7759 PyObject * obj1 = 0 ;
7760 char * kwnames[] = {
7761 (char *) "self",(char *) "rect", NULL
7762 };
7763
7764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7765 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7766 if (!SWIG_IsOK(res1)) {
7767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7768 }
7769 arg1 = reinterpret_cast< wxRect * >(argp1);
7770 {
7771 arg2 = &temp2;
7772 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7773 }
7774 {
7775 PyThreadState* __tstate = wxPyBeginAllowThreads();
7776 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7777 wxPyEndAllowThreads(__tstate);
7778 if (PyErr_Occurred()) SWIG_fail;
7779 }
7780 {
7781 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7782 }
7783 return resultobj;
7784 fail:
7785 return NULL;
7786 }
7787
7788
7789 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7790 PyObject *resultobj = 0;
7791 wxRect *arg1 = (wxRect *) 0 ;
7792 wxRect *arg2 = 0 ;
7793 int arg3 = (int) wxBOTH ;
7794 wxRect result;
7795 void *argp1 = 0 ;
7796 int res1 = 0 ;
7797 wxRect temp2 ;
7798 int val3 ;
7799 int ecode3 = 0 ;
7800 PyObject * obj0 = 0 ;
7801 PyObject * obj1 = 0 ;
7802 PyObject * obj2 = 0 ;
7803 char * kwnames[] = {
7804 (char *) "self",(char *) "r",(char *) "dir", NULL
7805 };
7806
7807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7808 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7809 if (!SWIG_IsOK(res1)) {
7810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7811 }
7812 arg1 = reinterpret_cast< wxRect * >(argp1);
7813 {
7814 arg2 = &temp2;
7815 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7816 }
7817 if (obj2) {
7818 ecode3 = SWIG_AsVal_int(obj2, &val3);
7819 if (!SWIG_IsOK(ecode3)) {
7820 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7821 }
7822 arg3 = static_cast< int >(val3);
7823 }
7824 {
7825 PyThreadState* __tstate = wxPyBeginAllowThreads();
7826 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7827 wxPyEndAllowThreads(__tstate);
7828 if (PyErr_Occurred()) SWIG_fail;
7829 }
7830 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7831 return resultobj;
7832 fail:
7833 return NULL;
7834 }
7835
7836
7837 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7838 PyObject *resultobj = 0;
7839 wxRect *arg1 = (wxRect *) 0 ;
7840 int arg2 ;
7841 void *argp1 = 0 ;
7842 int res1 = 0 ;
7843 int val2 ;
7844 int ecode2 = 0 ;
7845 PyObject *swig_obj[2] ;
7846
7847 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7848 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7849 if (!SWIG_IsOK(res1)) {
7850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7851 }
7852 arg1 = reinterpret_cast< wxRect * >(argp1);
7853 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7854 if (!SWIG_IsOK(ecode2)) {
7855 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7856 }
7857 arg2 = static_cast< int >(val2);
7858 if (arg1) (arg1)->x = arg2;
7859
7860 resultobj = SWIG_Py_Void();
7861 return resultobj;
7862 fail:
7863 return NULL;
7864 }
7865
7866
7867 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7868 PyObject *resultobj = 0;
7869 wxRect *arg1 = (wxRect *) 0 ;
7870 int result;
7871 void *argp1 = 0 ;
7872 int res1 = 0 ;
7873 PyObject *swig_obj[1] ;
7874
7875 if (!args) SWIG_fail;
7876 swig_obj[0] = args;
7877 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7878 if (!SWIG_IsOK(res1)) {
7879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7880 }
7881 arg1 = reinterpret_cast< wxRect * >(argp1);
7882 result = (int) ((arg1)->x);
7883 resultobj = SWIG_From_int(static_cast< int >(result));
7884 return resultobj;
7885 fail:
7886 return NULL;
7887 }
7888
7889
7890 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7891 PyObject *resultobj = 0;
7892 wxRect *arg1 = (wxRect *) 0 ;
7893 int arg2 ;
7894 void *argp1 = 0 ;
7895 int res1 = 0 ;
7896 int val2 ;
7897 int ecode2 = 0 ;
7898 PyObject *swig_obj[2] ;
7899
7900 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7901 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7902 if (!SWIG_IsOK(res1)) {
7903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
7904 }
7905 arg1 = reinterpret_cast< wxRect * >(argp1);
7906 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7907 if (!SWIG_IsOK(ecode2)) {
7908 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
7909 }
7910 arg2 = static_cast< int >(val2);
7911 if (arg1) (arg1)->y = arg2;
7912
7913 resultobj = SWIG_Py_Void();
7914 return resultobj;
7915 fail:
7916 return NULL;
7917 }
7918
7919
7920 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7921 PyObject *resultobj = 0;
7922 wxRect *arg1 = (wxRect *) 0 ;
7923 int result;
7924 void *argp1 = 0 ;
7925 int res1 = 0 ;
7926 PyObject *swig_obj[1] ;
7927
7928 if (!args) SWIG_fail;
7929 swig_obj[0] = args;
7930 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7931 if (!SWIG_IsOK(res1)) {
7932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
7933 }
7934 arg1 = reinterpret_cast< wxRect * >(argp1);
7935 result = (int) ((arg1)->y);
7936 resultobj = SWIG_From_int(static_cast< int >(result));
7937 return resultobj;
7938 fail:
7939 return NULL;
7940 }
7941
7942
7943 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7944 PyObject *resultobj = 0;
7945 wxRect *arg1 = (wxRect *) 0 ;
7946 int arg2 ;
7947 void *argp1 = 0 ;
7948 int res1 = 0 ;
7949 int val2 ;
7950 int ecode2 = 0 ;
7951 PyObject *swig_obj[2] ;
7952
7953 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
7954 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7955 if (!SWIG_IsOK(res1)) {
7956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
7957 }
7958 arg1 = reinterpret_cast< wxRect * >(argp1);
7959 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7960 if (!SWIG_IsOK(ecode2)) {
7961 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
7962 }
7963 arg2 = static_cast< int >(val2);
7964 if (arg1) (arg1)->width = arg2;
7965
7966 resultobj = SWIG_Py_Void();
7967 return resultobj;
7968 fail:
7969 return NULL;
7970 }
7971
7972
7973 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7974 PyObject *resultobj = 0;
7975 wxRect *arg1 = (wxRect *) 0 ;
7976 int result;
7977 void *argp1 = 0 ;
7978 int res1 = 0 ;
7979 PyObject *swig_obj[1] ;
7980
7981 if (!args) SWIG_fail;
7982 swig_obj[0] = args;
7983 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7984 if (!SWIG_IsOK(res1)) {
7985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
7986 }
7987 arg1 = reinterpret_cast< wxRect * >(argp1);
7988 result = (int) ((arg1)->width);
7989 resultobj = SWIG_From_int(static_cast< int >(result));
7990 return resultobj;
7991 fail:
7992 return NULL;
7993 }
7994
7995
7996 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7997 PyObject *resultobj = 0;
7998 wxRect *arg1 = (wxRect *) 0 ;
7999 int arg2 ;
8000 void *argp1 = 0 ;
8001 int res1 = 0 ;
8002 int val2 ;
8003 int ecode2 = 0 ;
8004 PyObject *swig_obj[2] ;
8005
8006 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
8007 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8008 if (!SWIG_IsOK(res1)) {
8009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
8010 }
8011 arg1 = reinterpret_cast< wxRect * >(argp1);
8012 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
8013 if (!SWIG_IsOK(ecode2)) {
8014 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
8015 }
8016 arg2 = static_cast< int >(val2);
8017 if (arg1) (arg1)->height = arg2;
8018
8019 resultobj = SWIG_Py_Void();
8020 return resultobj;
8021 fail:
8022 return NULL;
8023 }
8024
8025
8026 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8027 PyObject *resultobj = 0;
8028 wxRect *arg1 = (wxRect *) 0 ;
8029 int result;
8030 void *argp1 = 0 ;
8031 int res1 = 0 ;
8032 PyObject *swig_obj[1] ;
8033
8034 if (!args) SWIG_fail;
8035 swig_obj[0] = args;
8036 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8037 if (!SWIG_IsOK(res1)) {
8038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
8039 }
8040 arg1 = reinterpret_cast< wxRect * >(argp1);
8041 result = (int) ((arg1)->height);
8042 resultobj = SWIG_From_int(static_cast< int >(result));
8043 return resultobj;
8044 fail:
8045 return NULL;
8046 }
8047
8048
8049 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8050 PyObject *resultobj = 0;
8051 wxRect *arg1 = (wxRect *) 0 ;
8052 int arg2 = (int) 0 ;
8053 int arg3 = (int) 0 ;
8054 int arg4 = (int) 0 ;
8055 int arg5 = (int) 0 ;
8056 void *argp1 = 0 ;
8057 int res1 = 0 ;
8058 int val2 ;
8059 int ecode2 = 0 ;
8060 int val3 ;
8061 int ecode3 = 0 ;
8062 int val4 ;
8063 int ecode4 = 0 ;
8064 int val5 ;
8065 int ecode5 = 0 ;
8066 PyObject * obj0 = 0 ;
8067 PyObject * obj1 = 0 ;
8068 PyObject * obj2 = 0 ;
8069 PyObject * obj3 = 0 ;
8070 PyObject * obj4 = 0 ;
8071 char * kwnames[] = {
8072 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
8073 };
8074
8075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
8076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8077 if (!SWIG_IsOK(res1)) {
8078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
8079 }
8080 arg1 = reinterpret_cast< wxRect * >(argp1);
8081 if (obj1) {
8082 ecode2 = SWIG_AsVal_int(obj1, &val2);
8083 if (!SWIG_IsOK(ecode2)) {
8084 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
8085 }
8086 arg2 = static_cast< int >(val2);
8087 }
8088 if (obj2) {
8089 ecode3 = SWIG_AsVal_int(obj2, &val3);
8090 if (!SWIG_IsOK(ecode3)) {
8091 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
8092 }
8093 arg3 = static_cast< int >(val3);
8094 }
8095 if (obj3) {
8096 ecode4 = SWIG_AsVal_int(obj3, &val4);
8097 if (!SWIG_IsOK(ecode4)) {
8098 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
8099 }
8100 arg4 = static_cast< int >(val4);
8101 }
8102 if (obj4) {
8103 ecode5 = SWIG_AsVal_int(obj4, &val5);
8104 if (!SWIG_IsOK(ecode5)) {
8105 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
8106 }
8107 arg5 = static_cast< int >(val5);
8108 }
8109 {
8110 PyThreadState* __tstate = wxPyBeginAllowThreads();
8111 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
8112 wxPyEndAllowThreads(__tstate);
8113 if (PyErr_Occurred()) SWIG_fail;
8114 }
8115 resultobj = SWIG_Py_Void();
8116 return resultobj;
8117 fail:
8118 return NULL;
8119 }
8120
8121
8122 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8123 PyObject *resultobj = 0;
8124 wxRect *arg1 = (wxRect *) 0 ;
8125 PyObject *result = 0 ;
8126 void *argp1 = 0 ;
8127 int res1 = 0 ;
8128 PyObject *swig_obj[1] ;
8129
8130 if (!args) SWIG_fail;
8131 swig_obj[0] = args;
8132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8133 if (!SWIG_IsOK(res1)) {
8134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
8135 }
8136 arg1 = reinterpret_cast< wxRect * >(argp1);
8137 {
8138 PyThreadState* __tstate = wxPyBeginAllowThreads();
8139 result = (PyObject *)wxRect_Get(arg1);
8140 wxPyEndAllowThreads(__tstate);
8141 if (PyErr_Occurred()) SWIG_fail;
8142 }
8143 resultobj = result;
8144 return resultobj;
8145 fail:
8146 return NULL;
8147 }
8148
8149
8150 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8151 PyObject *obj;
8152 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8153 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
8154 return SWIG_Py_Void();
8155 }
8156
8157 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8158 return SWIG_Python_InitShadowInstance(args);
8159 }
8160
8161 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8162 PyObject *resultobj = 0;
8163 wxRect *arg1 = (wxRect *) 0 ;
8164 wxRect *arg2 = (wxRect *) 0 ;
8165 PyObject *result = 0 ;
8166 void *argp1 = 0 ;
8167 int res1 = 0 ;
8168 void *argp2 = 0 ;
8169 int res2 = 0 ;
8170 PyObject * obj0 = 0 ;
8171 PyObject * obj1 = 0 ;
8172 char * kwnames[] = {
8173 (char *) "r1",(char *) "r2", NULL
8174 };
8175
8176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
8177 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8178 if (!SWIG_IsOK(res1)) {
8179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
8180 }
8181 arg1 = reinterpret_cast< wxRect * >(argp1);
8182 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
8183 if (!SWIG_IsOK(res2)) {
8184 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
8185 }
8186 arg2 = reinterpret_cast< wxRect * >(argp2);
8187 {
8188 if (!wxPyCheckForApp()) SWIG_fail;
8189 PyThreadState* __tstate = wxPyBeginAllowThreads();
8190 result = (PyObject *)wxIntersectRect(arg1,arg2);
8191 wxPyEndAllowThreads(__tstate);
8192 if (PyErr_Occurred()) SWIG_fail;
8193 }
8194 resultobj = result;
8195 return resultobj;
8196 fail:
8197 return NULL;
8198 }
8199
8200
8201 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8202 PyObject *resultobj = 0;
8203 double arg1 = (double) 0.0 ;
8204 double arg2 = (double) 0.0 ;
8205 wxPoint2D *result = 0 ;
8206 double val1 ;
8207 int ecode1 = 0 ;
8208 double val2 ;
8209 int ecode2 = 0 ;
8210 PyObject * obj0 = 0 ;
8211 PyObject * obj1 = 0 ;
8212 char * kwnames[] = {
8213 (char *) "x",(char *) "y", NULL
8214 };
8215
8216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
8217 if (obj0) {
8218 ecode1 = SWIG_AsVal_double(obj0, &val1);
8219 if (!SWIG_IsOK(ecode1)) {
8220 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
8221 }
8222 arg1 = static_cast< double >(val1);
8223 }
8224 if (obj1) {
8225 ecode2 = SWIG_AsVal_double(obj1, &val2);
8226 if (!SWIG_IsOK(ecode2)) {
8227 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
8228 }
8229 arg2 = static_cast< double >(val2);
8230 }
8231 {
8232 PyThreadState* __tstate = wxPyBeginAllowThreads();
8233 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
8234 wxPyEndAllowThreads(__tstate);
8235 if (PyErr_Occurred()) SWIG_fail;
8236 }
8237 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
8238 return resultobj;
8239 fail:
8240 return NULL;
8241 }
8242
8243
8244 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8245 PyObject *resultobj = 0;
8246 wxPoint2D *arg1 = 0 ;
8247 wxPoint2D *result = 0 ;
8248 wxPoint2D temp1 ;
8249 PyObject * obj0 = 0 ;
8250 char * kwnames[] = {
8251 (char *) "pt", NULL
8252 };
8253
8254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
8255 {
8256 arg1 = &temp1;
8257 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
8258 }
8259 {
8260 PyThreadState* __tstate = wxPyBeginAllowThreads();
8261 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
8262 wxPyEndAllowThreads(__tstate);
8263 if (PyErr_Occurred()) SWIG_fail;
8264 }
8265 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8266 return resultobj;
8267 fail:
8268 return NULL;
8269 }
8270
8271
8272 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8273 PyObject *resultobj = 0;
8274 wxPoint *arg1 = 0 ;
8275 wxPoint2D *result = 0 ;
8276 wxPoint temp1 ;
8277 PyObject * obj0 = 0 ;
8278 char * kwnames[] = {
8279 (char *) "pt", NULL
8280 };
8281
8282 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
8283 {
8284 arg1 = &temp1;
8285 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
8286 }
8287 {
8288 PyThreadState* __tstate = wxPyBeginAllowThreads();
8289 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
8290 wxPyEndAllowThreads(__tstate);
8291 if (PyErr_Occurred()) SWIG_fail;
8292 }
8293 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8294 return resultobj;
8295 fail:
8296 return NULL;
8297 }
8298
8299
8300 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8301 PyObject *resultobj = 0;
8302 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8303 int *arg2 = (int *) 0 ;
8304 int *arg3 = (int *) 0 ;
8305 void *argp1 = 0 ;
8306 int res1 = 0 ;
8307 int temp2 ;
8308 int res2 = SWIG_TMPOBJ ;
8309 int temp3 ;
8310 int res3 = SWIG_TMPOBJ ;
8311 PyObject *swig_obj[1] ;
8312
8313 arg2 = &temp2;
8314 arg3 = &temp3;
8315 if (!args) SWIG_fail;
8316 swig_obj[0] = args;
8317 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8318 if (!SWIG_IsOK(res1)) {
8319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8320 }
8321 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8322 {
8323 PyThreadState* __tstate = wxPyBeginAllowThreads();
8324 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8325 wxPyEndAllowThreads(__tstate);
8326 if (PyErr_Occurred()) SWIG_fail;
8327 }
8328 resultobj = SWIG_Py_Void();
8329 if (SWIG_IsTmpObj(res2)) {
8330 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8331 } else {
8332 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8333 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8334 }
8335 if (SWIG_IsTmpObj(res3)) {
8336 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8337 } else {
8338 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8339 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8340 }
8341 return resultobj;
8342 fail:
8343 return NULL;
8344 }
8345
8346
8347 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8348 PyObject *resultobj = 0;
8349 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8350 int *arg2 = (int *) 0 ;
8351 int *arg3 = (int *) 0 ;
8352 void *argp1 = 0 ;
8353 int res1 = 0 ;
8354 int temp2 ;
8355 int res2 = SWIG_TMPOBJ ;
8356 int temp3 ;
8357 int res3 = SWIG_TMPOBJ ;
8358 PyObject *swig_obj[1] ;
8359
8360 arg2 = &temp2;
8361 arg3 = &temp3;
8362 if (!args) SWIG_fail;
8363 swig_obj[0] = args;
8364 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8365 if (!SWIG_IsOK(res1)) {
8366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8367 }
8368 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8369 {
8370 PyThreadState* __tstate = wxPyBeginAllowThreads();
8371 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8372 wxPyEndAllowThreads(__tstate);
8373 if (PyErr_Occurred()) SWIG_fail;
8374 }
8375 resultobj = SWIG_Py_Void();
8376 if (SWIG_IsTmpObj(res2)) {
8377 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8378 } else {
8379 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8380 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8381 }
8382 if (SWIG_IsTmpObj(res3)) {
8383 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8384 } else {
8385 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8386 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8387 }
8388 return resultobj;
8389 fail:
8390 return NULL;
8391 }
8392
8393
8394 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8395 PyObject *resultobj = 0;
8396 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8397 double result;
8398 void *argp1 = 0 ;
8399 int res1 = 0 ;
8400 PyObject *swig_obj[1] ;
8401
8402 if (!args) SWIG_fail;
8403 swig_obj[0] = args;
8404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8405 if (!SWIG_IsOK(res1)) {
8406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8407 }
8408 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8409 {
8410 PyThreadState* __tstate = wxPyBeginAllowThreads();
8411 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8412 wxPyEndAllowThreads(__tstate);
8413 if (PyErr_Occurred()) SWIG_fail;
8414 }
8415 resultobj = SWIG_From_double(static_cast< double >(result));
8416 return resultobj;
8417 fail:
8418 return NULL;
8419 }
8420
8421
8422 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8423 PyObject *resultobj = 0;
8424 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8425 double result;
8426 void *argp1 = 0 ;
8427 int res1 = 0 ;
8428 PyObject *swig_obj[1] ;
8429
8430 if (!args) SWIG_fail;
8431 swig_obj[0] = args;
8432 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8433 if (!SWIG_IsOK(res1)) {
8434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8435 }
8436 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8437 {
8438 PyThreadState* __tstate = wxPyBeginAllowThreads();
8439 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8440 wxPyEndAllowThreads(__tstate);
8441 if (PyErr_Occurred()) SWIG_fail;
8442 }
8443 resultobj = SWIG_From_double(static_cast< double >(result));
8444 return resultobj;
8445 fail:
8446 return NULL;
8447 }
8448
8449
8450 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8451 PyObject *resultobj = 0;
8452 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8453 double arg2 ;
8454 void *argp1 = 0 ;
8455 int res1 = 0 ;
8456 double val2 ;
8457 int ecode2 = 0 ;
8458 PyObject * obj0 = 0 ;
8459 PyObject * obj1 = 0 ;
8460 char * kwnames[] = {
8461 (char *) "self",(char *) "length", NULL
8462 };
8463
8464 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8465 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8466 if (!SWIG_IsOK(res1)) {
8467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8468 }
8469 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8470 ecode2 = SWIG_AsVal_double(obj1, &val2);
8471 if (!SWIG_IsOK(ecode2)) {
8472 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8473 }
8474 arg2 = static_cast< double >(val2);
8475 {
8476 PyThreadState* __tstate = wxPyBeginAllowThreads();
8477 (arg1)->SetVectorLength(arg2);
8478 wxPyEndAllowThreads(__tstate);
8479 if (PyErr_Occurred()) SWIG_fail;
8480 }
8481 resultobj = SWIG_Py_Void();
8482 return resultobj;
8483 fail:
8484 return NULL;
8485 }
8486
8487
8488 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8489 PyObject *resultobj = 0;
8490 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8491 double arg2 ;
8492 void *argp1 = 0 ;
8493 int res1 = 0 ;
8494 double val2 ;
8495 int ecode2 = 0 ;
8496 PyObject * obj0 = 0 ;
8497 PyObject * obj1 = 0 ;
8498 char * kwnames[] = {
8499 (char *) "self",(char *) "degrees", NULL
8500 };
8501
8502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8503 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8504 if (!SWIG_IsOK(res1)) {
8505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8506 }
8507 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8508 ecode2 = SWIG_AsVal_double(obj1, &val2);
8509 if (!SWIG_IsOK(ecode2)) {
8510 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8511 }
8512 arg2 = static_cast< double >(val2);
8513 {
8514 PyThreadState* __tstate = wxPyBeginAllowThreads();
8515 (arg1)->SetVectorAngle(arg2);
8516 wxPyEndAllowThreads(__tstate);
8517 if (PyErr_Occurred()) SWIG_fail;
8518 }
8519 resultobj = SWIG_Py_Void();
8520 return resultobj;
8521 fail:
8522 return NULL;
8523 }
8524
8525
8526 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8527 PyObject *resultobj = 0;
8528 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8529 wxPoint2D *arg2 = 0 ;
8530 double result;
8531 void *argp1 = 0 ;
8532 int res1 = 0 ;
8533 wxPoint2D temp2 ;
8534 PyObject * obj0 = 0 ;
8535 PyObject * obj1 = 0 ;
8536 char * kwnames[] = {
8537 (char *) "self",(char *) "pt", NULL
8538 };
8539
8540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8541 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8542 if (!SWIG_IsOK(res1)) {
8543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8544 }
8545 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8546 {
8547 arg2 = &temp2;
8548 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8549 }
8550 {
8551 PyThreadState* __tstate = wxPyBeginAllowThreads();
8552 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8553 wxPyEndAllowThreads(__tstate);
8554 if (PyErr_Occurred()) SWIG_fail;
8555 }
8556 resultobj = SWIG_From_double(static_cast< double >(result));
8557 return resultobj;
8558 fail:
8559 return NULL;
8560 }
8561
8562
8563 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8564 PyObject *resultobj = 0;
8565 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8566 wxPoint2D *arg2 = 0 ;
8567 double result;
8568 void *argp1 = 0 ;
8569 int res1 = 0 ;
8570 wxPoint2D temp2 ;
8571 PyObject * obj0 = 0 ;
8572 PyObject * obj1 = 0 ;
8573 char * kwnames[] = {
8574 (char *) "self",(char *) "pt", NULL
8575 };
8576
8577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8578 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8579 if (!SWIG_IsOK(res1)) {
8580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8581 }
8582 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8583 {
8584 arg2 = &temp2;
8585 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8586 }
8587 {
8588 PyThreadState* __tstate = wxPyBeginAllowThreads();
8589 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8590 wxPyEndAllowThreads(__tstate);
8591 if (PyErr_Occurred()) SWIG_fail;
8592 }
8593 resultobj = SWIG_From_double(static_cast< double >(result));
8594 return resultobj;
8595 fail:
8596 return NULL;
8597 }
8598
8599
8600 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8601 PyObject *resultobj = 0;
8602 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8603 wxPoint2D *arg2 = 0 ;
8604 double result;
8605 void *argp1 = 0 ;
8606 int res1 = 0 ;
8607 wxPoint2D temp2 ;
8608 PyObject * obj0 = 0 ;
8609 PyObject * obj1 = 0 ;
8610 char * kwnames[] = {
8611 (char *) "self",(char *) "vec", NULL
8612 };
8613
8614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8615 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8616 if (!SWIG_IsOK(res1)) {
8617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8618 }
8619 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8620 {
8621 arg2 = &temp2;
8622 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8623 }
8624 {
8625 PyThreadState* __tstate = wxPyBeginAllowThreads();
8626 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8627 wxPyEndAllowThreads(__tstate);
8628 if (PyErr_Occurred()) SWIG_fail;
8629 }
8630 resultobj = SWIG_From_double(static_cast< double >(result));
8631 return resultobj;
8632 fail:
8633 return NULL;
8634 }
8635
8636
8637 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8638 PyObject *resultobj = 0;
8639 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8640 wxPoint2D *arg2 = 0 ;
8641 double result;
8642 void *argp1 = 0 ;
8643 int res1 = 0 ;
8644 wxPoint2D temp2 ;
8645 PyObject * obj0 = 0 ;
8646 PyObject * obj1 = 0 ;
8647 char * kwnames[] = {
8648 (char *) "self",(char *) "vec", NULL
8649 };
8650
8651 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8652 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8653 if (!SWIG_IsOK(res1)) {
8654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8655 }
8656 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8657 {
8658 arg2 = &temp2;
8659 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8660 }
8661 {
8662 PyThreadState* __tstate = wxPyBeginAllowThreads();
8663 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8664 wxPyEndAllowThreads(__tstate);
8665 if (PyErr_Occurred()) SWIG_fail;
8666 }
8667 resultobj = SWIG_From_double(static_cast< double >(result));
8668 return resultobj;
8669 fail:
8670 return NULL;
8671 }
8672
8673
8674 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8675 PyObject *resultobj = 0;
8676 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8677 wxPoint2D result;
8678 void *argp1 = 0 ;
8679 int res1 = 0 ;
8680 PyObject *swig_obj[1] ;
8681
8682 if (!args) SWIG_fail;
8683 swig_obj[0] = args;
8684 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8685 if (!SWIG_IsOK(res1)) {
8686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8687 }
8688 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8689 {
8690 PyThreadState* __tstate = wxPyBeginAllowThreads();
8691 result = (arg1)->operator -();
8692 wxPyEndAllowThreads(__tstate);
8693 if (PyErr_Occurred()) SWIG_fail;
8694 }
8695 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8696 return resultobj;
8697 fail:
8698 return NULL;
8699 }
8700
8701
8702 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8703 PyObject *resultobj = 0;
8704 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8705 wxPoint2D *arg2 = 0 ;
8706 wxPoint2D *result = 0 ;
8707 void *argp1 = 0 ;
8708 int res1 = 0 ;
8709 wxPoint2D temp2 ;
8710 PyObject * obj0 = 0 ;
8711 PyObject * obj1 = 0 ;
8712 char * kwnames[] = {
8713 (char *) "self",(char *) "pt", NULL
8714 };
8715
8716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8717 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8718 if (!SWIG_IsOK(res1)) {
8719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8720 }
8721 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8722 {
8723 arg2 = &temp2;
8724 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8725 }
8726 {
8727 PyThreadState* __tstate = wxPyBeginAllowThreads();
8728 {
8729 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8730 result = (wxPoint2D *) &_result_ref;
8731 }
8732 wxPyEndAllowThreads(__tstate);
8733 if (PyErr_Occurred()) SWIG_fail;
8734 }
8735 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8736 return resultobj;
8737 fail:
8738 return NULL;
8739 }
8740
8741
8742 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8743 PyObject *resultobj = 0;
8744 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8745 wxPoint2D *arg2 = 0 ;
8746 wxPoint2D *result = 0 ;
8747 void *argp1 = 0 ;
8748 int res1 = 0 ;
8749 wxPoint2D temp2 ;
8750 PyObject * obj0 = 0 ;
8751 PyObject * obj1 = 0 ;
8752 char * kwnames[] = {
8753 (char *) "self",(char *) "pt", NULL
8754 };
8755
8756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8758 if (!SWIG_IsOK(res1)) {
8759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8760 }
8761 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8762 {
8763 arg2 = &temp2;
8764 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8765 }
8766 {
8767 PyThreadState* __tstate = wxPyBeginAllowThreads();
8768 {
8769 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8770 result = (wxPoint2D *) &_result_ref;
8771 }
8772 wxPyEndAllowThreads(__tstate);
8773 if (PyErr_Occurred()) SWIG_fail;
8774 }
8775 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8776 return resultobj;
8777 fail:
8778 return NULL;
8779 }
8780
8781
8782 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8783 PyObject *resultobj = 0;
8784 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8785 wxPoint2D *arg2 = 0 ;
8786 wxPoint2D *result = 0 ;
8787 void *argp1 = 0 ;
8788 int res1 = 0 ;
8789 wxPoint2D temp2 ;
8790 PyObject * obj0 = 0 ;
8791 PyObject * obj1 = 0 ;
8792 char * kwnames[] = {
8793 (char *) "self",(char *) "pt", NULL
8794 };
8795
8796 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8797 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8798 if (!SWIG_IsOK(res1)) {
8799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8800 }
8801 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8802 {
8803 arg2 = &temp2;
8804 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8805 }
8806 {
8807 PyThreadState* __tstate = wxPyBeginAllowThreads();
8808 {
8809 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8810 result = (wxPoint2D *) &_result_ref;
8811 }
8812 wxPyEndAllowThreads(__tstate);
8813 if (PyErr_Occurred()) SWIG_fail;
8814 }
8815 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8816 return resultobj;
8817 fail:
8818 return NULL;
8819 }
8820
8821
8822 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8823 PyObject *resultobj = 0;
8824 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8825 wxPoint2D *arg2 = 0 ;
8826 wxPoint2D *result = 0 ;
8827 void *argp1 = 0 ;
8828 int res1 = 0 ;
8829 wxPoint2D temp2 ;
8830 PyObject * obj0 = 0 ;
8831 PyObject * obj1 = 0 ;
8832 char * kwnames[] = {
8833 (char *) "self",(char *) "pt", NULL
8834 };
8835
8836 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8837 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8838 if (!SWIG_IsOK(res1)) {
8839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8840 }
8841 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8842 {
8843 arg2 = &temp2;
8844 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8845 }
8846 {
8847 PyThreadState* __tstate = wxPyBeginAllowThreads();
8848 {
8849 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8850 result = (wxPoint2D *) &_result_ref;
8851 }
8852 wxPyEndAllowThreads(__tstate);
8853 if (PyErr_Occurred()) SWIG_fail;
8854 }
8855 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8856 return resultobj;
8857 fail:
8858 return NULL;
8859 }
8860
8861
8862 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8863 PyObject *resultobj = 0;
8864 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8865 PyObject *arg2 = (PyObject *) 0 ;
8866 bool result;
8867 void *argp1 = 0 ;
8868 int res1 = 0 ;
8869 PyObject * obj0 = 0 ;
8870 PyObject * obj1 = 0 ;
8871 char * kwnames[] = {
8872 (char *) "self",(char *) "other", NULL
8873 };
8874
8875 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8876 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8877 if (!SWIG_IsOK(res1)) {
8878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8879 }
8880 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8881 arg2 = obj1;
8882 {
8883 result = (bool)wxPoint2D___eq__(arg1,arg2);
8884 if (PyErr_Occurred()) SWIG_fail;
8885 }
8886 {
8887 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8888 }
8889 return resultobj;
8890 fail:
8891 return NULL;
8892 }
8893
8894
8895 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8896 PyObject *resultobj = 0;
8897 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8898 PyObject *arg2 = (PyObject *) 0 ;
8899 bool result;
8900 void *argp1 = 0 ;
8901 int res1 = 0 ;
8902 PyObject * obj0 = 0 ;
8903 PyObject * obj1 = 0 ;
8904 char * kwnames[] = {
8905 (char *) "self",(char *) "other", NULL
8906 };
8907
8908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
8909 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8910 if (!SWIG_IsOK(res1)) {
8911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8912 }
8913 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8914 arg2 = obj1;
8915 {
8916 result = (bool)wxPoint2D___ne__(arg1,arg2);
8917 if (PyErr_Occurred()) SWIG_fail;
8918 }
8919 {
8920 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8921 }
8922 return resultobj;
8923 fail:
8924 return NULL;
8925 }
8926
8927
8928 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8929 PyObject *resultobj = 0;
8930 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8931 double arg2 ;
8932 void *argp1 = 0 ;
8933 int res1 = 0 ;
8934 double val2 ;
8935 int ecode2 = 0 ;
8936 PyObject *swig_obj[2] ;
8937
8938 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
8939 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8940 if (!SWIG_IsOK(res1)) {
8941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8942 }
8943 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8944 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8945 if (!SWIG_IsOK(ecode2)) {
8946 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
8947 }
8948 arg2 = static_cast< double >(val2);
8949 if (arg1) (arg1)->m_x = arg2;
8950
8951 resultobj = SWIG_Py_Void();
8952 return resultobj;
8953 fail:
8954 return NULL;
8955 }
8956
8957
8958 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8959 PyObject *resultobj = 0;
8960 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8961 double result;
8962 void *argp1 = 0 ;
8963 int res1 = 0 ;
8964 PyObject *swig_obj[1] ;
8965
8966 if (!args) SWIG_fail;
8967 swig_obj[0] = args;
8968 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8969 if (!SWIG_IsOK(res1)) {
8970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8971 }
8972 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8973 result = (double) ((arg1)->m_x);
8974 resultobj = SWIG_From_double(static_cast< double >(result));
8975 return resultobj;
8976 fail:
8977 return NULL;
8978 }
8979
8980
8981 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8982 PyObject *resultobj = 0;
8983 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8984 double arg2 ;
8985 void *argp1 = 0 ;
8986 int res1 = 0 ;
8987 double val2 ;
8988 int ecode2 = 0 ;
8989 PyObject *swig_obj[2] ;
8990
8991 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
8992 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8993 if (!SWIG_IsOK(res1)) {
8994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8995 }
8996 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8997 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8998 if (!SWIG_IsOK(ecode2)) {
8999 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
9000 }
9001 arg2 = static_cast< double >(val2);
9002 if (arg1) (arg1)->m_y = arg2;
9003
9004 resultobj = SWIG_Py_Void();
9005 return resultobj;
9006 fail:
9007 return NULL;
9008 }
9009
9010
9011 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9012 PyObject *resultobj = 0;
9013 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9014 double result;
9015 void *argp1 = 0 ;
9016 int res1 = 0 ;
9017 PyObject *swig_obj[1] ;
9018
9019 if (!args) SWIG_fail;
9020 swig_obj[0] = args;
9021 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9022 if (!SWIG_IsOK(res1)) {
9023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9024 }
9025 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9026 result = (double) ((arg1)->m_y);
9027 resultobj = SWIG_From_double(static_cast< double >(result));
9028 return resultobj;
9029 fail:
9030 return NULL;
9031 }
9032
9033
9034 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9035 PyObject *resultobj = 0;
9036 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9037 double arg2 = (double) 0 ;
9038 double arg3 = (double) 0 ;
9039 void *argp1 = 0 ;
9040 int res1 = 0 ;
9041 double val2 ;
9042 int ecode2 = 0 ;
9043 double val3 ;
9044 int ecode3 = 0 ;
9045 PyObject * obj0 = 0 ;
9046 PyObject * obj1 = 0 ;
9047 PyObject * obj2 = 0 ;
9048 char * kwnames[] = {
9049 (char *) "self",(char *) "x",(char *) "y", NULL
9050 };
9051
9052 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9053 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9054 if (!SWIG_IsOK(res1)) {
9055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9056 }
9057 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9058 if (obj1) {
9059 ecode2 = SWIG_AsVal_double(obj1, &val2);
9060 if (!SWIG_IsOK(ecode2)) {
9061 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
9062 }
9063 arg2 = static_cast< double >(val2);
9064 }
9065 if (obj2) {
9066 ecode3 = SWIG_AsVal_double(obj2, &val3);
9067 if (!SWIG_IsOK(ecode3)) {
9068 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
9069 }
9070 arg3 = static_cast< double >(val3);
9071 }
9072 {
9073 PyThreadState* __tstate = wxPyBeginAllowThreads();
9074 wxPoint2D_Set(arg1,arg2,arg3);
9075 wxPyEndAllowThreads(__tstate);
9076 if (PyErr_Occurred()) SWIG_fail;
9077 }
9078 resultobj = SWIG_Py_Void();
9079 return resultobj;
9080 fail:
9081 return NULL;
9082 }
9083
9084
9085 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9086 PyObject *resultobj = 0;
9087 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9088 PyObject *result = 0 ;
9089 void *argp1 = 0 ;
9090 int res1 = 0 ;
9091 PyObject *swig_obj[1] ;
9092
9093 if (!args) SWIG_fail;
9094 swig_obj[0] = args;
9095 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9096 if (!SWIG_IsOK(res1)) {
9097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9098 }
9099 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9100 {
9101 PyThreadState* __tstate = wxPyBeginAllowThreads();
9102 result = (PyObject *)wxPoint2D_Get(arg1);
9103 wxPyEndAllowThreads(__tstate);
9104 if (PyErr_Occurred()) SWIG_fail;
9105 }
9106 resultobj = result;
9107 return resultobj;
9108 fail:
9109 return NULL;
9110 }
9111
9112
9113 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9114 PyObject *obj;
9115 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9116 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
9117 return SWIG_Py_Void();
9118 }
9119
9120 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9121 return SWIG_Python_InitShadowInstance(args);
9122 }
9123
9124 SWIGINTERN int DefaultPosition_set(PyObject *) {
9125 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
9126 return 1;
9127 }
9128
9129
9130 SWIGINTERN PyObject *DefaultPosition_get(void) {
9131 PyObject *pyobj = 0;
9132
9133 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
9134 return pyobj;
9135 }
9136
9137
9138 SWIGINTERN int DefaultSize_set(PyObject *) {
9139 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
9140 return 1;
9141 }
9142
9143
9144 SWIGINTERN PyObject *DefaultSize_get(void) {
9145 PyObject *pyobj = 0;
9146
9147 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
9148 return pyobj;
9149 }
9150
9151
9152 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9153 PyObject *resultobj = 0;
9154 PyObject *arg1 = (PyObject *) 0 ;
9155 wxPyInputStream *result = 0 ;
9156 PyObject * obj0 = 0 ;
9157 char * kwnames[] = {
9158 (char *) "p", NULL
9159 };
9160
9161 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
9162 arg1 = obj0;
9163 {
9164 PyThreadState* __tstate = wxPyBeginAllowThreads();
9165 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
9166 wxPyEndAllowThreads(__tstate);
9167 if (PyErr_Occurred()) SWIG_fail;
9168 }
9169 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
9170 return resultobj;
9171 fail:
9172 return NULL;
9173 }
9174
9175
9176 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9177 PyObject *resultobj = 0;
9178 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9179 void *argp1 = 0 ;
9180 int res1 = 0 ;
9181 PyObject *swig_obj[1] ;
9182
9183 if (!args) SWIG_fail;
9184 swig_obj[0] = args;
9185 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
9186 if (!SWIG_IsOK(res1)) {
9187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9188 }
9189 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9190 {
9191 PyThreadState* __tstate = wxPyBeginAllowThreads();
9192 delete arg1;
9193
9194 wxPyEndAllowThreads(__tstate);
9195 if (PyErr_Occurred()) SWIG_fail;
9196 }
9197 resultobj = SWIG_Py_Void();
9198 return resultobj;
9199 fail:
9200 return NULL;
9201 }
9202
9203
9204 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9205 PyObject *resultobj = 0;
9206 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9207 void *argp1 = 0 ;
9208 int res1 = 0 ;
9209 PyObject *swig_obj[1] ;
9210
9211 if (!args) SWIG_fail;
9212 swig_obj[0] = args;
9213 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9214 if (!SWIG_IsOK(res1)) {
9215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9216 }
9217 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9218 {
9219 PyThreadState* __tstate = wxPyBeginAllowThreads();
9220 (arg1)->close();
9221 wxPyEndAllowThreads(__tstate);
9222 if (PyErr_Occurred()) SWIG_fail;
9223 }
9224 resultobj = SWIG_Py_Void();
9225 return resultobj;
9226 fail:
9227 return NULL;
9228 }
9229
9230
9231 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9232 PyObject *resultobj = 0;
9233 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9234 void *argp1 = 0 ;
9235 int res1 = 0 ;
9236 PyObject *swig_obj[1] ;
9237
9238 if (!args) SWIG_fail;
9239 swig_obj[0] = args;
9240 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9241 if (!SWIG_IsOK(res1)) {
9242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9243 }
9244 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9245 {
9246 PyThreadState* __tstate = wxPyBeginAllowThreads();
9247 (arg1)->flush();
9248 wxPyEndAllowThreads(__tstate);
9249 if (PyErr_Occurred()) SWIG_fail;
9250 }
9251 resultobj = SWIG_Py_Void();
9252 return resultobj;
9253 fail:
9254 return NULL;
9255 }
9256
9257
9258 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9259 PyObject *resultobj = 0;
9260 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9261 bool result;
9262 void *argp1 = 0 ;
9263 int res1 = 0 ;
9264 PyObject *swig_obj[1] ;
9265
9266 if (!args) SWIG_fail;
9267 swig_obj[0] = args;
9268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9269 if (!SWIG_IsOK(res1)) {
9270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9271 }
9272 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9273 {
9274 PyThreadState* __tstate = wxPyBeginAllowThreads();
9275 result = (bool)(arg1)->eof();
9276 wxPyEndAllowThreads(__tstate);
9277 if (PyErr_Occurred()) SWIG_fail;
9278 }
9279 {
9280 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9281 }
9282 return resultobj;
9283 fail:
9284 return NULL;
9285 }
9286
9287
9288 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9289 PyObject *resultobj = 0;
9290 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9291 int arg2 = (int) -1 ;
9292 PyObject *result = 0 ;
9293 void *argp1 = 0 ;
9294 int res1 = 0 ;
9295 int val2 ;
9296 int ecode2 = 0 ;
9297 PyObject * obj0 = 0 ;
9298 PyObject * obj1 = 0 ;
9299 char * kwnames[] = {
9300 (char *) "self",(char *) "size", NULL
9301 };
9302
9303 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
9304 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9305 if (!SWIG_IsOK(res1)) {
9306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9307 }
9308 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9309 if (obj1) {
9310 ecode2 = SWIG_AsVal_int(obj1, &val2);
9311 if (!SWIG_IsOK(ecode2)) {
9312 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
9313 }
9314 arg2 = static_cast< int >(val2);
9315 }
9316 {
9317 PyThreadState* __tstate = wxPyBeginAllowThreads();
9318 result = (PyObject *)(arg1)->read(arg2);
9319 wxPyEndAllowThreads(__tstate);
9320 if (PyErr_Occurred()) SWIG_fail;
9321 }
9322 resultobj = result;
9323 return resultobj;
9324 fail:
9325 return NULL;
9326 }
9327
9328
9329 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9330 PyObject *resultobj = 0;
9331 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9332 int arg2 = (int) -1 ;
9333 PyObject *result = 0 ;
9334 void *argp1 = 0 ;
9335 int res1 = 0 ;
9336 int val2 ;
9337 int ecode2 = 0 ;
9338 PyObject * obj0 = 0 ;
9339 PyObject * obj1 = 0 ;
9340 char * kwnames[] = {
9341 (char *) "self",(char *) "size", NULL
9342 };
9343
9344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
9345 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9346 if (!SWIG_IsOK(res1)) {
9347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9348 }
9349 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9350 if (obj1) {
9351 ecode2 = SWIG_AsVal_int(obj1, &val2);
9352 if (!SWIG_IsOK(ecode2)) {
9353 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
9354 }
9355 arg2 = static_cast< int >(val2);
9356 }
9357 {
9358 PyThreadState* __tstate = wxPyBeginAllowThreads();
9359 result = (PyObject *)(arg1)->readline(arg2);
9360 wxPyEndAllowThreads(__tstate);
9361 if (PyErr_Occurred()) SWIG_fail;
9362 }
9363 resultobj = result;
9364 return resultobj;
9365 fail:
9366 return NULL;
9367 }
9368
9369
9370 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9371 PyObject *resultobj = 0;
9372 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9373 int arg2 = (int) -1 ;
9374 PyObject *result = 0 ;
9375 void *argp1 = 0 ;
9376 int res1 = 0 ;
9377 int val2 ;
9378 int ecode2 = 0 ;
9379 PyObject * obj0 = 0 ;
9380 PyObject * obj1 = 0 ;
9381 char * kwnames[] = {
9382 (char *) "self",(char *) "sizehint", NULL
9383 };
9384
9385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
9386 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9387 if (!SWIG_IsOK(res1)) {
9388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9389 }
9390 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9391 if (obj1) {
9392 ecode2 = SWIG_AsVal_int(obj1, &val2);
9393 if (!SWIG_IsOK(ecode2)) {
9394 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
9395 }
9396 arg2 = static_cast< int >(val2);
9397 }
9398 {
9399 PyThreadState* __tstate = wxPyBeginAllowThreads();
9400 result = (PyObject *)(arg1)->readlines(arg2);
9401 wxPyEndAllowThreads(__tstate);
9402 if (PyErr_Occurred()) SWIG_fail;
9403 }
9404 resultobj = result;
9405 return resultobj;
9406 fail:
9407 return NULL;
9408 }
9409
9410
9411 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9412 PyObject *resultobj = 0;
9413 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9414 int arg2 ;
9415 int arg3 = (int) 0 ;
9416 void *argp1 = 0 ;
9417 int res1 = 0 ;
9418 int val2 ;
9419 int ecode2 = 0 ;
9420 int val3 ;
9421 int ecode3 = 0 ;
9422 PyObject * obj0 = 0 ;
9423 PyObject * obj1 = 0 ;
9424 PyObject * obj2 = 0 ;
9425 char * kwnames[] = {
9426 (char *) "self",(char *) "offset",(char *) "whence", NULL
9427 };
9428
9429 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9430 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9431 if (!SWIG_IsOK(res1)) {
9432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9433 }
9434 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9435 ecode2 = SWIG_AsVal_int(obj1, &val2);
9436 if (!SWIG_IsOK(ecode2)) {
9437 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
9438 }
9439 arg2 = static_cast< int >(val2);
9440 if (obj2) {
9441 ecode3 = SWIG_AsVal_int(obj2, &val3);
9442 if (!SWIG_IsOK(ecode3)) {
9443 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
9444 }
9445 arg3 = static_cast< int >(val3);
9446 }
9447 {
9448 PyThreadState* __tstate = wxPyBeginAllowThreads();
9449 (arg1)->seek(arg2,arg3);
9450 wxPyEndAllowThreads(__tstate);
9451 if (PyErr_Occurred()) SWIG_fail;
9452 }
9453 resultobj = SWIG_Py_Void();
9454 return resultobj;
9455 fail:
9456 return NULL;
9457 }
9458
9459
9460 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9461 PyObject *resultobj = 0;
9462 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9463 int result;
9464 void *argp1 = 0 ;
9465 int res1 = 0 ;
9466 PyObject *swig_obj[1] ;
9467
9468 if (!args) SWIG_fail;
9469 swig_obj[0] = args;
9470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9471 if (!SWIG_IsOK(res1)) {
9472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9473 }
9474 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9475 {
9476 PyThreadState* __tstate = wxPyBeginAllowThreads();
9477 result = (int)(arg1)->tell();
9478 wxPyEndAllowThreads(__tstate);
9479 if (PyErr_Occurred()) SWIG_fail;
9480 }
9481 resultobj = SWIG_From_int(static_cast< int >(result));
9482 return resultobj;
9483 fail:
9484 return NULL;
9485 }
9486
9487
9488 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9489 PyObject *resultobj = 0;
9490 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9491 char result;
9492 void *argp1 = 0 ;
9493 int res1 = 0 ;
9494 PyObject *swig_obj[1] ;
9495
9496 if (!args) SWIG_fail;
9497 swig_obj[0] = args;
9498 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9499 if (!SWIG_IsOK(res1)) {
9500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9501 }
9502 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9503 {
9504 PyThreadState* __tstate = wxPyBeginAllowThreads();
9505 result = (char)(arg1)->Peek();
9506 wxPyEndAllowThreads(__tstate);
9507 if (PyErr_Occurred()) SWIG_fail;
9508 }
9509 resultobj = SWIG_From_char(static_cast< char >(result));
9510 return resultobj;
9511 fail:
9512 return NULL;
9513 }
9514
9515
9516 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9517 PyObject *resultobj = 0;
9518 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9519 char result;
9520 void *argp1 = 0 ;
9521 int res1 = 0 ;
9522 PyObject *swig_obj[1] ;
9523
9524 if (!args) SWIG_fail;
9525 swig_obj[0] = args;
9526 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9527 if (!SWIG_IsOK(res1)) {
9528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9529 }
9530 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9531 {
9532 PyThreadState* __tstate = wxPyBeginAllowThreads();
9533 result = (char)(arg1)->GetC();
9534 wxPyEndAllowThreads(__tstate);
9535 if (PyErr_Occurred()) SWIG_fail;
9536 }
9537 resultobj = SWIG_From_char(static_cast< char >(result));
9538 return resultobj;
9539 fail:
9540 return NULL;
9541 }
9542
9543
9544 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9545 PyObject *resultobj = 0;
9546 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9547 size_t result;
9548 void *argp1 = 0 ;
9549 int res1 = 0 ;
9550 PyObject *swig_obj[1] ;
9551
9552 if (!args) SWIG_fail;
9553 swig_obj[0] = args;
9554 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9555 if (!SWIG_IsOK(res1)) {
9556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9557 }
9558 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9559 {
9560 PyThreadState* __tstate = wxPyBeginAllowThreads();
9561 result = (size_t)(arg1)->LastRead();
9562 wxPyEndAllowThreads(__tstate);
9563 if (PyErr_Occurred()) SWIG_fail;
9564 }
9565 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9566 return resultobj;
9567 fail:
9568 return NULL;
9569 }
9570
9571
9572 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9573 PyObject *resultobj = 0;
9574 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9575 bool result;
9576 void *argp1 = 0 ;
9577 int res1 = 0 ;
9578 PyObject *swig_obj[1] ;
9579
9580 if (!args) SWIG_fail;
9581 swig_obj[0] = args;
9582 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9583 if (!SWIG_IsOK(res1)) {
9584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9585 }
9586 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9587 {
9588 PyThreadState* __tstate = wxPyBeginAllowThreads();
9589 result = (bool)(arg1)->CanRead();
9590 wxPyEndAllowThreads(__tstate);
9591 if (PyErr_Occurred()) SWIG_fail;
9592 }
9593 {
9594 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9595 }
9596 return resultobj;
9597 fail:
9598 return NULL;
9599 }
9600
9601
9602 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9603 PyObject *resultobj = 0;
9604 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9605 bool result;
9606 void *argp1 = 0 ;
9607 int res1 = 0 ;
9608 PyObject *swig_obj[1] ;
9609
9610 if (!args) SWIG_fail;
9611 swig_obj[0] = args;
9612 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9613 if (!SWIG_IsOK(res1)) {
9614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9615 }
9616 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9617 {
9618 PyThreadState* __tstate = wxPyBeginAllowThreads();
9619 result = (bool)(arg1)->Eof();
9620 wxPyEndAllowThreads(__tstate);
9621 if (PyErr_Occurred()) SWIG_fail;
9622 }
9623 {
9624 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9625 }
9626 return resultobj;
9627 fail:
9628 return NULL;
9629 }
9630
9631
9632 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9633 PyObject *resultobj = 0;
9634 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9635 char arg2 ;
9636 bool result;
9637 void *argp1 = 0 ;
9638 int res1 = 0 ;
9639 char val2 ;
9640 int ecode2 = 0 ;
9641 PyObject * obj0 = 0 ;
9642 PyObject * obj1 = 0 ;
9643 char * kwnames[] = {
9644 (char *) "self",(char *) "c", NULL
9645 };
9646
9647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
9648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9649 if (!SWIG_IsOK(res1)) {
9650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9651 }
9652 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9653 ecode2 = SWIG_AsVal_char(obj1, &val2);
9654 if (!SWIG_IsOK(ecode2)) {
9655 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
9656 }
9657 arg2 = static_cast< char >(val2);
9658 {
9659 PyThreadState* __tstate = wxPyBeginAllowThreads();
9660 result = (bool)(arg1)->Ungetch(arg2);
9661 wxPyEndAllowThreads(__tstate);
9662 if (PyErr_Occurred()) SWIG_fail;
9663 }
9664 {
9665 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9666 }
9667 return resultobj;
9668 fail:
9669 return NULL;
9670 }
9671
9672
9673 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9674 PyObject *resultobj = 0;
9675 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9676 long arg2 ;
9677 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
9678 long result;
9679 void *argp1 = 0 ;
9680 int res1 = 0 ;
9681 long val2 ;
9682 int ecode2 = 0 ;
9683 int val3 ;
9684 int ecode3 = 0 ;
9685 PyObject * obj0 = 0 ;
9686 PyObject * obj1 = 0 ;
9687 PyObject * obj2 = 0 ;
9688 char * kwnames[] = {
9689 (char *) "self",(char *) "pos",(char *) "mode", NULL
9690 };
9691
9692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9693 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9694 if (!SWIG_IsOK(res1)) {
9695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9696 }
9697 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9698 ecode2 = SWIG_AsVal_long(obj1, &val2);
9699 if (!SWIG_IsOK(ecode2)) {
9700 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
9701 }
9702 arg2 = static_cast< long >(val2);
9703 if (obj2) {
9704 ecode3 = SWIG_AsVal_int(obj2, &val3);
9705 if (!SWIG_IsOK(ecode3)) {
9706 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
9707 }
9708 arg3 = static_cast< wxSeekMode >(val3);
9709 }
9710 {
9711 PyThreadState* __tstate = wxPyBeginAllowThreads();
9712 result = (long)(arg1)->SeekI(arg2,arg3);
9713 wxPyEndAllowThreads(__tstate);
9714 if (PyErr_Occurred()) SWIG_fail;
9715 }
9716 resultobj = SWIG_From_long(static_cast< long >(result));
9717 return resultobj;
9718 fail:
9719 return NULL;
9720 }
9721
9722
9723 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9724 PyObject *resultobj = 0;
9725 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9726 long result;
9727 void *argp1 = 0 ;
9728 int res1 = 0 ;
9729 PyObject *swig_obj[1] ;
9730
9731 if (!args) SWIG_fail;
9732 swig_obj[0] = args;
9733 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9734 if (!SWIG_IsOK(res1)) {
9735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9736 }
9737 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9738 {
9739 PyThreadState* __tstate = wxPyBeginAllowThreads();
9740 result = (long)(arg1)->TellI();
9741 wxPyEndAllowThreads(__tstate);
9742 if (PyErr_Occurred()) SWIG_fail;
9743 }
9744 resultobj = SWIG_From_long(static_cast< long >(result));
9745 return resultobj;
9746 fail:
9747 return NULL;
9748 }
9749
9750
9751 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9752 PyObject *obj;
9753 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9754 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
9755 return SWIG_Py_Void();
9756 }
9757
9758 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9759 return SWIG_Python_InitShadowInstance(args);
9760 }
9761
9762 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9763 PyObject *resultobj = 0;
9764 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9765 PyObject *arg2 = (PyObject *) 0 ;
9766 void *argp1 = 0 ;
9767 int res1 = 0 ;
9768 PyObject * obj0 = 0 ;
9769 PyObject * obj1 = 0 ;
9770 char * kwnames[] = {
9771 (char *) "self",(char *) "obj", NULL
9772 };
9773
9774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
9775 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9776 if (!SWIG_IsOK(res1)) {
9777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
9778 }
9779 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9780 arg2 = obj1;
9781 {
9782 PyThreadState* __tstate = wxPyBeginAllowThreads();
9783 wxOutputStream_write(arg1,arg2);
9784 wxPyEndAllowThreads(__tstate);
9785 if (PyErr_Occurred()) SWIG_fail;
9786 }
9787 resultobj = SWIG_Py_Void();
9788 return resultobj;
9789 fail:
9790 return NULL;
9791 }
9792
9793
9794 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9795 PyObject *resultobj = 0;
9796 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9797 size_t result;
9798 void *argp1 = 0 ;
9799 int res1 = 0 ;
9800 PyObject *swig_obj[1] ;
9801
9802 if (!args) SWIG_fail;
9803 swig_obj[0] = args;
9804 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9805 if (!SWIG_IsOK(res1)) {
9806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
9807 }
9808 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9809 {
9810 PyThreadState* __tstate = wxPyBeginAllowThreads();
9811 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
9812 wxPyEndAllowThreads(__tstate);
9813 if (PyErr_Occurred()) SWIG_fail;
9814 }
9815 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9816 return resultobj;
9817 fail:
9818 return NULL;
9819 }
9820
9821
9822 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9823 PyObject *obj;
9824 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9825 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
9826 return SWIG_Py_Void();
9827 }
9828
9829 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9830 PyObject *resultobj = 0;
9831 wxInputStream *arg1 = (wxInputStream *) 0 ;
9832 wxString *arg2 = 0 ;
9833 wxString *arg3 = 0 ;
9834 wxString *arg4 = 0 ;
9835 wxDateTime arg5 ;
9836 wxFSFile *result = 0 ;
9837 wxPyInputStream *temp1 ;
9838 bool temp2 = false ;
9839 bool temp3 = false ;
9840 bool temp4 = false ;
9841 void *argp5 ;
9842 int res5 = 0 ;
9843 PyObject * obj0 = 0 ;
9844 PyObject * obj1 = 0 ;
9845 PyObject * obj2 = 0 ;
9846 PyObject * obj3 = 0 ;
9847 PyObject * obj4 = 0 ;
9848 char * kwnames[] = {
9849 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
9850 };
9851
9852 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9853 {
9854 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
9855 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
9856 } else {
9857 PyErr_Clear(); // clear the failure of the wxPyConvert above
9858 arg1 = wxPyCBInputStream_create(obj0, true);
9859 if (arg1 == NULL) {
9860 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
9861 SWIG_fail;
9862 }
9863 }
9864 }
9865 {
9866 arg2 = wxString_in_helper(obj1);
9867 if (arg2 == NULL) SWIG_fail;
9868 temp2 = true;
9869 }
9870 {
9871 arg3 = wxString_in_helper(obj2);
9872 if (arg3 == NULL) SWIG_fail;
9873 temp3 = true;
9874 }
9875 {
9876 arg4 = wxString_in_helper(obj3);
9877 if (arg4 == NULL) SWIG_fail;
9878 temp4 = true;
9879 }
9880 {
9881 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
9882 if (!SWIG_IsOK(res5)) {
9883 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9884 }
9885 if (!argp5) {
9886 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9887 } else {
9888 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
9889 arg5 = *temp;
9890 if (SWIG_IsNewObj(res5)) delete temp;
9891 }
9892 }
9893 {
9894 PyThreadState* __tstate = wxPyBeginAllowThreads();
9895 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
9896 wxPyEndAllowThreads(__tstate);
9897 if (PyErr_Occurred()) SWIG_fail;
9898 }
9899 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFSFile, SWIG_POINTER_NEW | 0 );
9900 {
9901 if (temp2)
9902 delete arg2;
9903 }
9904 {
9905 if (temp3)
9906 delete arg3;
9907 }
9908 {
9909 if (temp4)
9910 delete arg4;
9911 }
9912 return resultobj;
9913 fail:
9914 {
9915 if (temp2)
9916 delete arg2;
9917 }
9918 {
9919 if (temp3)
9920 delete arg3;
9921 }
9922 {
9923 if (temp4)
9924 delete arg4;
9925 }
9926 return NULL;
9927 }
9928
9929
9930 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9931 PyObject *resultobj = 0;
9932 wxFSFile *arg1 = (wxFSFile *) 0 ;
9933 void *argp1 = 0 ;
9934 int res1 = 0 ;
9935 PyObject *swig_obj[1] ;
9936
9937 if (!args) SWIG_fail;
9938 swig_obj[0] = args;
9939 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
9940 if (!SWIG_IsOK(res1)) {
9941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
9942 }
9943 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9944 {
9945 PyThreadState* __tstate = wxPyBeginAllowThreads();
9946 delete arg1;
9947
9948 wxPyEndAllowThreads(__tstate);
9949 if (PyErr_Occurred()) SWIG_fail;
9950 }
9951 resultobj = SWIG_Py_Void();
9952 return resultobj;
9953 fail:
9954 return NULL;
9955 }
9956
9957
9958 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9959 PyObject *resultobj = 0;
9960 wxFSFile *arg1 = (wxFSFile *) 0 ;
9961 wxInputStream *result = 0 ;
9962 void *argp1 = 0 ;
9963 int res1 = 0 ;
9964 PyObject *swig_obj[1] ;
9965
9966 if (!args) SWIG_fail;
9967 swig_obj[0] = args;
9968 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9969 if (!SWIG_IsOK(res1)) {
9970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
9971 }
9972 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9973 {
9974 PyThreadState* __tstate = wxPyBeginAllowThreads();
9975 result = (wxInputStream *)(arg1)->GetStream();
9976 wxPyEndAllowThreads(__tstate);
9977 if (PyErr_Occurred()) SWIG_fail;
9978 }
9979 {
9980 wxPyInputStream * _ptr = NULL;
9981
9982 if (result) {
9983 _ptr = new wxPyInputStream(result);
9984 }
9985 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
9986 }
9987 return resultobj;
9988 fail:
9989 return NULL;
9990 }
9991
9992
9993 SWIGINTERN PyObject *_wrap_FSFile_DetachStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9994 PyObject *resultobj = 0;
9995 wxFSFile *arg1 = (wxFSFile *) 0 ;
9996 void *argp1 = 0 ;
9997 int res1 = 0 ;
9998 PyObject *swig_obj[1] ;
9999
10000 if (!args) SWIG_fail;
10001 swig_obj[0] = args;
10002 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
10003 if (!SWIG_IsOK(res1)) {
10004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_DetachStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
10005 }
10006 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10007 {
10008 PyThreadState* __tstate = wxPyBeginAllowThreads();
10009 (arg1)->DetachStream();
10010 wxPyEndAllowThreads(__tstate);
10011 if (PyErr_Occurred()) SWIG_fail;
10012 }
10013 resultobj = SWIG_Py_Void();
10014 return resultobj;
10015 fail:
10016 return NULL;
10017 }
10018
10019
10020 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10021 PyObject *resultobj = 0;
10022 wxFSFile *arg1 = (wxFSFile *) 0 ;
10023 wxString *result = 0 ;
10024 void *argp1 = 0 ;
10025 int res1 = 0 ;
10026 PyObject *swig_obj[1] ;
10027
10028 if (!args) SWIG_fail;
10029 swig_obj[0] = args;
10030 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
10031 if (!SWIG_IsOK(res1)) {
10032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
10033 }
10034 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10035 {
10036 PyThreadState* __tstate = wxPyBeginAllowThreads();
10037 {
10038 wxString const &_result_ref = (arg1)->GetMimeType();
10039 result = (wxString *) &_result_ref;
10040 }
10041 wxPyEndAllowThreads(__tstate);
10042 if (PyErr_Occurred()) SWIG_fail;
10043 }
10044 {
10045 #if wxUSE_UNICODE
10046 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
10047 #else
10048 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
10049 #endif
10050 }
10051 return resultobj;
10052 fail:
10053 return NULL;
10054 }
10055
10056
10057 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10058 PyObject *resultobj = 0;
10059 wxFSFile *arg1 = (wxFSFile *) 0 ;
10060 wxString *result = 0 ;
10061 void *argp1 = 0 ;
10062 int res1 = 0 ;
10063 PyObject *swig_obj[1] ;
10064
10065 if (!args) SWIG_fail;
10066 swig_obj[0] = args;
10067 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
10068 if (!SWIG_IsOK(res1)) {
10069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
10070 }
10071 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10072 {
10073 PyThreadState* __tstate = wxPyBeginAllowThreads();
10074 {
10075 wxString const &_result_ref = (arg1)->GetLocation();
10076 result = (wxString *) &_result_ref;
10077 }
10078 wxPyEndAllowThreads(__tstate);
10079 if (PyErr_Occurred()) SWIG_fail;
10080 }
10081 {
10082 #if wxUSE_UNICODE
10083 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
10084 #else
10085 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
10086 #endif
10087 }
10088 return resultobj;
10089 fail:
10090 return NULL;
10091 }
10092
10093
10094 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10095 PyObject *resultobj = 0;
10096 wxFSFile *arg1 = (wxFSFile *) 0 ;
10097 wxString *result = 0 ;
10098 void *argp1 = 0 ;
10099 int res1 = 0 ;
10100 PyObject *swig_obj[1] ;
10101
10102 if (!args) SWIG_fail;
10103 swig_obj[0] = args;
10104 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
10105 if (!SWIG_IsOK(res1)) {
10106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
10107 }
10108 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10109 {
10110 PyThreadState* __tstate = wxPyBeginAllowThreads();
10111 {
10112 wxString const &_result_ref = (arg1)->GetAnchor();
10113 result = (wxString *) &_result_ref;
10114 }
10115 wxPyEndAllowThreads(__tstate);
10116 if (PyErr_Occurred()) SWIG_fail;
10117 }
10118 {
10119 #if wxUSE_UNICODE
10120 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
10121 #else
10122 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
10123 #endif
10124 }
10125 return resultobj;
10126 fail:
10127 return NULL;
10128 }
10129
10130
10131 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10132 PyObject *resultobj = 0;
10133 wxFSFile *arg1 = (wxFSFile *) 0 ;
10134 wxDateTime result;
10135 void *argp1 = 0 ;
10136 int res1 = 0 ;
10137 PyObject *swig_obj[1] ;
10138
10139 if (!args) SWIG_fail;
10140 swig_obj[0] = args;
10141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
10142 if (!SWIG_IsOK(res1)) {
10143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
10144 }
10145 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10146 {
10147 PyThreadState* __tstate = wxPyBeginAllowThreads();
10148 result = (arg1)->GetModificationTime();
10149 wxPyEndAllowThreads(__tstate);
10150 if (PyErr_Occurred()) SWIG_fail;
10151 }
10152 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
10153 return resultobj;
10154 fail:
10155 return NULL;
10156 }
10157
10158
10159 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10160 PyObject *obj;
10161 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10162 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
10163 return SWIG_Py_Void();
10164 }
10165
10166 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10167 return SWIG_Python_InitShadowInstance(args);
10168 }
10169
10170 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10171 PyObject *resultobj = 0;
10172 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10173 void *argp1 = 0 ;
10174 int res1 = 0 ;
10175 PyObject *swig_obj[1] ;
10176
10177 if (!args) SWIG_fail;
10178 swig_obj[0] = args;
10179 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
10180 if (!SWIG_IsOK(res1)) {
10181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10182 }
10183 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
10184 {
10185 PyThreadState* __tstate = wxPyBeginAllowThreads();
10186 delete arg1;
10187
10188 wxPyEndAllowThreads(__tstate);
10189 if (PyErr_Occurred()) SWIG_fail;
10190 }
10191 resultobj = SWIG_Py_Void();
10192 return resultobj;
10193 fail:
10194 return NULL;
10195 }
10196
10197
10198 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10199 PyObject *obj;
10200 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10201 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
10202 return SWIG_Py_Void();
10203 }
10204
10205 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10206 PyObject *resultobj = 0;
10207 wxPyFileSystemHandler *result = 0 ;
10208
10209 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
10210 {
10211 PyThreadState* __tstate = wxPyBeginAllowThreads();
10212 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
10213 wxPyEndAllowThreads(__tstate);
10214 if (PyErr_Occurred()) SWIG_fail;
10215 }
10216 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
10217 return resultobj;
10218 fail:
10219 return NULL;
10220 }
10221
10222
10223 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10224 PyObject *resultobj = 0;
10225 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10226 PyObject *arg2 = (PyObject *) 0 ;
10227 PyObject *arg3 = (PyObject *) 0 ;
10228 void *argp1 = 0 ;
10229 int res1 = 0 ;
10230 PyObject * obj0 = 0 ;
10231 PyObject * obj1 = 0 ;
10232 PyObject * obj2 = 0 ;
10233 char * kwnames[] = {
10234 (char *) "self",(char *) "self",(char *) "_class", NULL
10235 };
10236
10237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10238 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10239 if (!SWIG_IsOK(res1)) {
10240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10241 }
10242 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10243 arg2 = obj1;
10244 arg3 = obj2;
10245 {
10246 PyThreadState* __tstate = wxPyBeginAllowThreads();
10247 (arg1)->_setCallbackInfo(arg2,arg3);
10248 wxPyEndAllowThreads(__tstate);
10249 if (PyErr_Occurred()) SWIG_fail;
10250 }
10251 resultobj = SWIG_Py_Void();
10252 return resultobj;
10253 fail:
10254 return NULL;
10255 }
10256
10257
10258 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10259 PyObject *resultobj = 0;
10260 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10261 wxString *arg2 = 0 ;
10262 bool result;
10263 void *argp1 = 0 ;
10264 int res1 = 0 ;
10265 bool temp2 = false ;
10266 PyObject * obj0 = 0 ;
10267 PyObject * obj1 = 0 ;
10268 char * kwnames[] = {
10269 (char *) "self",(char *) "location", NULL
10270 };
10271
10272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10273 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10274 if (!SWIG_IsOK(res1)) {
10275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10276 }
10277 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10278 {
10279 arg2 = wxString_in_helper(obj1);
10280 if (arg2 == NULL) SWIG_fail;
10281 temp2 = true;
10282 }
10283 {
10284 PyThreadState* __tstate = wxPyBeginAllowThreads();
10285 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10286 wxPyEndAllowThreads(__tstate);
10287 if (PyErr_Occurred()) SWIG_fail;
10288 }
10289 {
10290 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10291 }
10292 {
10293 if (temp2)
10294 delete arg2;
10295 }
10296 return resultobj;
10297 fail:
10298 {
10299 if (temp2)
10300 delete arg2;
10301 }
10302 return NULL;
10303 }
10304
10305
10306 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10307 PyObject *resultobj = 0;
10308 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10309 wxFileSystem *arg2 = 0 ;
10310 wxString *arg3 = 0 ;
10311 wxFSFile *result = 0 ;
10312 void *argp1 = 0 ;
10313 int res1 = 0 ;
10314 void *argp2 = 0 ;
10315 int res2 = 0 ;
10316 bool temp3 = false ;
10317 PyObject * obj0 = 0 ;
10318 PyObject * obj1 = 0 ;
10319 PyObject * obj2 = 0 ;
10320 char * kwnames[] = {
10321 (char *) "self",(char *) "fs",(char *) "location", NULL
10322 };
10323
10324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10325 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10326 if (!SWIG_IsOK(res1)) {
10327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10328 }
10329 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10330 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10331 if (!SWIG_IsOK(res2)) {
10332 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10333 }
10334 if (!argp2) {
10335 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10336 }
10337 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10338 {
10339 arg3 = wxString_in_helper(obj2);
10340 if (arg3 == NULL) SWIG_fail;
10341 temp3 = true;
10342 }
10343 {
10344 PyThreadState* __tstate = wxPyBeginAllowThreads();
10345 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10346 wxPyEndAllowThreads(__tstate);
10347 if (PyErr_Occurred()) SWIG_fail;
10348 }
10349 {
10350 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10351 }
10352 {
10353 if (temp3)
10354 delete arg3;
10355 }
10356 return resultobj;
10357 fail:
10358 {
10359 if (temp3)
10360 delete arg3;
10361 }
10362 return NULL;
10363 }
10364
10365
10366 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10367 PyObject *resultobj = 0;
10368 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10369 wxString *arg2 = 0 ;
10370 int arg3 = (int) 0 ;
10371 wxString result;
10372 void *argp1 = 0 ;
10373 int res1 = 0 ;
10374 bool temp2 = false ;
10375 int val3 ;
10376 int ecode3 = 0 ;
10377 PyObject * obj0 = 0 ;
10378 PyObject * obj1 = 0 ;
10379 PyObject * obj2 = 0 ;
10380 char * kwnames[] = {
10381 (char *) "self",(char *) "spec",(char *) "flags", NULL
10382 };
10383
10384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10385 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10386 if (!SWIG_IsOK(res1)) {
10387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10388 }
10389 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10390 {
10391 arg2 = wxString_in_helper(obj1);
10392 if (arg2 == NULL) SWIG_fail;
10393 temp2 = true;
10394 }
10395 if (obj2) {
10396 ecode3 = SWIG_AsVal_int(obj2, &val3);
10397 if (!SWIG_IsOK(ecode3)) {
10398 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
10399 }
10400 arg3 = static_cast< int >(val3);
10401 }
10402 {
10403 PyThreadState* __tstate = wxPyBeginAllowThreads();
10404 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10405 wxPyEndAllowThreads(__tstate);
10406 if (PyErr_Occurred()) SWIG_fail;
10407 }
10408 {
10409 #if wxUSE_UNICODE
10410 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10411 #else
10412 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10413 #endif
10414 }
10415 {
10416 if (temp2)
10417 delete arg2;
10418 }
10419 return resultobj;
10420 fail:
10421 {
10422 if (temp2)
10423 delete arg2;
10424 }
10425 return NULL;
10426 }
10427
10428
10429 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10430 PyObject *resultobj = 0;
10431 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10432 wxString result;
10433 void *argp1 = 0 ;
10434 int res1 = 0 ;
10435 PyObject *swig_obj[1] ;
10436
10437 if (!args) SWIG_fail;
10438 swig_obj[0] = args;
10439 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10440 if (!SWIG_IsOK(res1)) {
10441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10442 }
10443 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10444 {
10445 PyThreadState* __tstate = wxPyBeginAllowThreads();
10446 result = (arg1)->FindNext();
10447 wxPyEndAllowThreads(__tstate);
10448 if (PyErr_Occurred()) SWIG_fail;
10449 }
10450 {
10451 #if wxUSE_UNICODE
10452 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10453 #else
10454 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10455 #endif
10456 }
10457 return resultobj;
10458 fail:
10459 return NULL;
10460 }
10461
10462
10463 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10464 PyObject *resultobj = 0;
10465 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10466 wxString *arg2 = 0 ;
10467 wxString result;
10468 void *argp1 = 0 ;
10469 int res1 = 0 ;
10470 bool temp2 = false ;
10471 PyObject * obj0 = 0 ;
10472 PyObject * obj1 = 0 ;
10473 char * kwnames[] = {
10474 (char *) "self",(char *) "location", NULL
10475 };
10476
10477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
10478 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10479 if (!SWIG_IsOK(res1)) {
10480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10481 }
10482 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10483 {
10484 arg2 = wxString_in_helper(obj1);
10485 if (arg2 == NULL) SWIG_fail;
10486 temp2 = true;
10487 }
10488 {
10489 PyThreadState* __tstate = wxPyBeginAllowThreads();
10490 result = (arg1)->GetProtocol((wxString const &)*arg2);
10491 wxPyEndAllowThreads(__tstate);
10492 if (PyErr_Occurred()) SWIG_fail;
10493 }
10494 {
10495 #if wxUSE_UNICODE
10496 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10497 #else
10498 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10499 #endif
10500 }
10501 {
10502 if (temp2)
10503 delete arg2;
10504 }
10505 return resultobj;
10506 fail:
10507 {
10508 if (temp2)
10509 delete arg2;
10510 }
10511 return NULL;
10512 }
10513
10514
10515 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10516 PyObject *resultobj = 0;
10517 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10518 wxString *arg2 = 0 ;
10519 wxString result;
10520 void *argp1 = 0 ;
10521 int res1 = 0 ;
10522 bool temp2 = false ;
10523 PyObject * obj0 = 0 ;
10524 PyObject * obj1 = 0 ;
10525 char * kwnames[] = {
10526 (char *) "self",(char *) "location", NULL
10527 };
10528
10529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10530 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10531 if (!SWIG_IsOK(res1)) {
10532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10533 }
10534 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10535 {
10536 arg2 = wxString_in_helper(obj1);
10537 if (arg2 == NULL) SWIG_fail;
10538 temp2 = true;
10539 }
10540 {
10541 PyThreadState* __tstate = wxPyBeginAllowThreads();
10542 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
10543 wxPyEndAllowThreads(__tstate);
10544 if (PyErr_Occurred()) SWIG_fail;
10545 }
10546 {
10547 #if wxUSE_UNICODE
10548 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10549 #else
10550 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10551 #endif
10552 }
10553 {
10554 if (temp2)
10555 delete arg2;
10556 }
10557 return resultobj;
10558 fail:
10559 {
10560 if (temp2)
10561 delete arg2;
10562 }
10563 return NULL;
10564 }
10565
10566
10567 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10568 PyObject *resultobj = 0;
10569 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10570 wxString *arg2 = 0 ;
10571 wxString result;
10572 void *argp1 = 0 ;
10573 int res1 = 0 ;
10574 bool temp2 = false ;
10575 PyObject * obj0 = 0 ;
10576 PyObject * obj1 = 0 ;
10577 char * kwnames[] = {
10578 (char *) "self",(char *) "location", NULL
10579 };
10580
10581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
10582 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10583 if (!SWIG_IsOK(res1)) {
10584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10585 }
10586 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10587 {
10588 arg2 = wxString_in_helper(obj1);
10589 if (arg2 == NULL) SWIG_fail;
10590 temp2 = true;
10591 }
10592 {
10593 PyThreadState* __tstate = wxPyBeginAllowThreads();
10594 result = (arg1)->GetAnchor((wxString const &)*arg2);
10595 wxPyEndAllowThreads(__tstate);
10596 if (PyErr_Occurred()) SWIG_fail;
10597 }
10598 {
10599 #if wxUSE_UNICODE
10600 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10601 #else
10602 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10603 #endif
10604 }
10605 {
10606 if (temp2)
10607 delete arg2;
10608 }
10609 return resultobj;
10610 fail:
10611 {
10612 if (temp2)
10613 delete arg2;
10614 }
10615 return NULL;
10616 }
10617
10618
10619 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10620 PyObject *resultobj = 0;
10621 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10622 wxString *arg2 = 0 ;
10623 wxString result;
10624 void *argp1 = 0 ;
10625 int res1 = 0 ;
10626 bool temp2 = false ;
10627 PyObject * obj0 = 0 ;
10628 PyObject * obj1 = 0 ;
10629 char * kwnames[] = {
10630 (char *) "self",(char *) "location", NULL
10631 };
10632
10633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10634 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10635 if (!SWIG_IsOK(res1)) {
10636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10637 }
10638 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10639 {
10640 arg2 = wxString_in_helper(obj1);
10641 if (arg2 == NULL) SWIG_fail;
10642 temp2 = true;
10643 }
10644 {
10645 PyThreadState* __tstate = wxPyBeginAllowThreads();
10646 result = (arg1)->GetRightLocation((wxString const &)*arg2);
10647 wxPyEndAllowThreads(__tstate);
10648 if (PyErr_Occurred()) SWIG_fail;
10649 }
10650 {
10651 #if wxUSE_UNICODE
10652 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10653 #else
10654 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10655 #endif
10656 }
10657 {
10658 if (temp2)
10659 delete arg2;
10660 }
10661 return resultobj;
10662 fail:
10663 {
10664 if (temp2)
10665 delete arg2;
10666 }
10667 return NULL;
10668 }
10669
10670
10671 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10672 PyObject *resultobj = 0;
10673 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10674 wxString *arg2 = 0 ;
10675 wxString result;
10676 void *argp1 = 0 ;
10677 int res1 = 0 ;
10678 bool temp2 = false ;
10679 PyObject * obj0 = 0 ;
10680 PyObject * obj1 = 0 ;
10681 char * kwnames[] = {
10682 (char *) "self",(char *) "location", NULL
10683 };
10684
10685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
10686 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10687 if (!SWIG_IsOK(res1)) {
10688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10689 }
10690 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10691 {
10692 arg2 = wxString_in_helper(obj1);
10693 if (arg2 == NULL) SWIG_fail;
10694 temp2 = true;
10695 }
10696 {
10697 PyThreadState* __tstate = wxPyBeginAllowThreads();
10698 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
10699 wxPyEndAllowThreads(__tstate);
10700 if (PyErr_Occurred()) SWIG_fail;
10701 }
10702 {
10703 #if wxUSE_UNICODE
10704 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10705 #else
10706 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10707 #endif
10708 }
10709 {
10710 if (temp2)
10711 delete arg2;
10712 }
10713 return resultobj;
10714 fail:
10715 {
10716 if (temp2)
10717 delete arg2;
10718 }
10719 return NULL;
10720 }
10721
10722
10723 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10724 PyObject *obj;
10725 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10726 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
10727 return SWIG_Py_Void();
10728 }
10729
10730 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10731 return SWIG_Python_InitShadowInstance(args);
10732 }
10733
10734 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10735 PyObject *resultobj = 0;
10736 wxFileSystem *result = 0 ;
10737
10738 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
10739 {
10740 PyThreadState* __tstate = wxPyBeginAllowThreads();
10741 result = (wxFileSystem *)new wxFileSystem();
10742 wxPyEndAllowThreads(__tstate);
10743 if (PyErr_Occurred()) SWIG_fail;
10744 }
10745 {
10746 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
10747 }
10748 return resultobj;
10749 fail:
10750 return NULL;
10751 }
10752
10753
10754 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10755 PyObject *resultobj = 0;
10756 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10757 void *argp1 = 0 ;
10758 int res1 = 0 ;
10759 PyObject *swig_obj[1] ;
10760
10761 if (!args) SWIG_fail;
10762 swig_obj[0] = args;
10763 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
10764 if (!SWIG_IsOK(res1)) {
10765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10766 }
10767 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10768 {
10769 PyThreadState* __tstate = wxPyBeginAllowThreads();
10770 delete arg1;
10771
10772 wxPyEndAllowThreads(__tstate);
10773 if (PyErr_Occurred()) SWIG_fail;
10774 }
10775 resultobj = SWIG_Py_Void();
10776 return resultobj;
10777 fail:
10778 return NULL;
10779 }
10780
10781
10782 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10783 PyObject *resultobj = 0;
10784 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10785 wxString *arg2 = 0 ;
10786 bool arg3 = (bool) false ;
10787 void *argp1 = 0 ;
10788 int res1 = 0 ;
10789 bool temp2 = false ;
10790 bool val3 ;
10791 int ecode3 = 0 ;
10792 PyObject * obj0 = 0 ;
10793 PyObject * obj1 = 0 ;
10794 PyObject * obj2 = 0 ;
10795 char * kwnames[] = {
10796 (char *) "self",(char *) "location",(char *) "is_dir", NULL
10797 };
10798
10799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10800 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10801 if (!SWIG_IsOK(res1)) {
10802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10803 }
10804 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10805 {
10806 arg2 = wxString_in_helper(obj1);
10807 if (arg2 == NULL) SWIG_fail;
10808 temp2 = true;
10809 }
10810 if (obj2) {
10811 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10812 if (!SWIG_IsOK(ecode3)) {
10813 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
10814 }
10815 arg3 = static_cast< bool >(val3);
10816 }
10817 {
10818 PyThreadState* __tstate = wxPyBeginAllowThreads();
10819 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
10820 wxPyEndAllowThreads(__tstate);
10821 if (PyErr_Occurred()) SWIG_fail;
10822 }
10823 resultobj = SWIG_Py_Void();
10824 {
10825 if (temp2)
10826 delete arg2;
10827 }
10828 return resultobj;
10829 fail:
10830 {
10831 if (temp2)
10832 delete arg2;
10833 }
10834 return NULL;
10835 }
10836
10837
10838 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10839 PyObject *resultobj = 0;
10840 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10841 wxString result;
10842 void *argp1 = 0 ;
10843 int res1 = 0 ;
10844 PyObject *swig_obj[1] ;
10845
10846 if (!args) SWIG_fail;
10847 swig_obj[0] = args;
10848 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10849 if (!SWIG_IsOK(res1)) {
10850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10851 }
10852 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10853 {
10854 PyThreadState* __tstate = wxPyBeginAllowThreads();
10855 result = (arg1)->GetPath();
10856 wxPyEndAllowThreads(__tstate);
10857 if (PyErr_Occurred()) SWIG_fail;
10858 }
10859 {
10860 #if wxUSE_UNICODE
10861 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10862 #else
10863 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10864 #endif
10865 }
10866 return resultobj;
10867 fail:
10868 return NULL;
10869 }
10870
10871
10872 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10873 PyObject *resultobj = 0;
10874 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10875 wxString *arg2 = 0 ;
10876 wxFSFile *result = 0 ;
10877 void *argp1 = 0 ;
10878 int res1 = 0 ;
10879 bool temp2 = false ;
10880 PyObject * obj0 = 0 ;
10881 PyObject * obj1 = 0 ;
10882 char * kwnames[] = {
10883 (char *) "self",(char *) "location", NULL
10884 };
10885
10886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
10887 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10888 if (!SWIG_IsOK(res1)) {
10889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10890 }
10891 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10892 {
10893 arg2 = wxString_in_helper(obj1);
10894 if (arg2 == NULL) SWIG_fail;
10895 temp2 = true;
10896 }
10897 {
10898 PyThreadState* __tstate = wxPyBeginAllowThreads();
10899 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
10900 wxPyEndAllowThreads(__tstate);
10901 if (PyErr_Occurred()) SWIG_fail;
10902 }
10903 {
10904 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10905 }
10906 {
10907 if (temp2)
10908 delete arg2;
10909 }
10910 return resultobj;
10911 fail:
10912 {
10913 if (temp2)
10914 delete arg2;
10915 }
10916 return NULL;
10917 }
10918
10919
10920 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10921 PyObject *resultobj = 0;
10922 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10923 wxString *arg2 = 0 ;
10924 int arg3 = (int) 0 ;
10925 wxString result;
10926 void *argp1 = 0 ;
10927 int res1 = 0 ;
10928 bool temp2 = false ;
10929 int val3 ;
10930 int ecode3 = 0 ;
10931 PyObject * obj0 = 0 ;
10932 PyObject * obj1 = 0 ;
10933 PyObject * obj2 = 0 ;
10934 char * kwnames[] = {
10935 (char *) "self",(char *) "spec",(char *) "flags", NULL
10936 };
10937
10938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10939 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10940 if (!SWIG_IsOK(res1)) {
10941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10942 }
10943 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10944 {
10945 arg2 = wxString_in_helper(obj1);
10946 if (arg2 == NULL) SWIG_fail;
10947 temp2 = true;
10948 }
10949 if (obj2) {
10950 ecode3 = SWIG_AsVal_int(obj2, &val3);
10951 if (!SWIG_IsOK(ecode3)) {
10952 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
10953 }
10954 arg3 = static_cast< int >(val3);
10955 }
10956 {
10957 PyThreadState* __tstate = wxPyBeginAllowThreads();
10958 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10959 wxPyEndAllowThreads(__tstate);
10960 if (PyErr_Occurred()) SWIG_fail;
10961 }
10962 {
10963 #if wxUSE_UNICODE
10964 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10965 #else
10966 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10967 #endif
10968 }
10969 {
10970 if (temp2)
10971 delete arg2;
10972 }
10973 return resultobj;
10974 fail:
10975 {
10976 if (temp2)
10977 delete arg2;
10978 }
10979 return NULL;
10980 }
10981
10982
10983 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10984 PyObject *resultobj = 0;
10985 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10986 wxString result;
10987 void *argp1 = 0 ;
10988 int res1 = 0 ;
10989 PyObject *swig_obj[1] ;
10990
10991 if (!args) SWIG_fail;
10992 swig_obj[0] = args;
10993 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10994 if (!SWIG_IsOK(res1)) {
10995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10996 }
10997 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10998 {
10999 PyThreadState* __tstate = wxPyBeginAllowThreads();
11000 result = (arg1)->FindNext();
11001 wxPyEndAllowThreads(__tstate);
11002 if (PyErr_Occurred()) SWIG_fail;
11003 }
11004 {
11005 #if wxUSE_UNICODE
11006 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11007 #else
11008 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11009 #endif
11010 }
11011 return resultobj;
11012 fail:
11013 return NULL;
11014 }
11015
11016
11017 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11018 PyObject *resultobj = 0;
11019 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
11020 int res1 = 0 ;
11021 PyObject * obj0 = 0 ;
11022 char * kwnames[] = {
11023 (char *) "handler", NULL
11024 };
11025
11026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
11027 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
11028 if (!SWIG_IsOK(res1)) {
11029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
11030 }
11031 {
11032 PyThreadState* __tstate = wxPyBeginAllowThreads();
11033 wxFileSystem::AddHandler(arg1);
11034 wxPyEndAllowThreads(__tstate);
11035 if (PyErr_Occurred()) SWIG_fail;
11036 }
11037 resultobj = SWIG_Py_Void();
11038 return resultobj;
11039 fail:
11040 return NULL;
11041 }
11042
11043
11044 SWIGINTERN PyObject *_wrap_FileSystem_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11045 PyObject *resultobj = 0;
11046 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
11047 wxFileSystemHandler *result = 0 ;
11048 void *argp1 = 0 ;
11049 int res1 = 0 ;
11050 PyObject * obj0 = 0 ;
11051 char * kwnames[] = {
11052 (char *) "handler", NULL
11053 };
11054
11055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_RemoveHandler",kwnames,&obj0)) SWIG_fail;
11056 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystemHandler, 0 | 0 );
11057 if (!SWIG_IsOK(res1)) {
11058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_RemoveHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
11059 }
11060 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
11061 {
11062 PyThreadState* __tstate = wxPyBeginAllowThreads();
11063 result = (wxFileSystemHandler *)wxFileSystem::RemoveHandler(arg1);
11064 wxPyEndAllowThreads(__tstate);
11065 if (PyErr_Occurred()) SWIG_fail;
11066 }
11067 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_OWN | 0 );
11068 return resultobj;
11069 fail:
11070 return NULL;
11071 }
11072
11073
11074 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11075 PyObject *resultobj = 0;
11076
11077 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
11078 {
11079 PyThreadState* __tstate = wxPyBeginAllowThreads();
11080 wxFileSystem::CleanUpHandlers();
11081 wxPyEndAllowThreads(__tstate);
11082 if (PyErr_Occurred()) SWIG_fail;
11083 }
11084 resultobj = SWIG_Py_Void();
11085 return resultobj;
11086 fail:
11087 return NULL;
11088 }
11089
11090
11091 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11092 PyObject *resultobj = 0;
11093 wxString *arg1 = 0 ;
11094 wxString result;
11095 bool temp1 = false ;
11096 PyObject * obj0 = 0 ;
11097 char * kwnames[] = {
11098 (char *) "filename", NULL
11099 };
11100
11101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
11102 {
11103 arg1 = wxString_in_helper(obj0);
11104 if (arg1 == NULL) SWIG_fail;
11105 temp1 = true;
11106 }
11107 {
11108 PyThreadState* __tstate = wxPyBeginAllowThreads();
11109 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
11110 wxPyEndAllowThreads(__tstate);
11111 if (PyErr_Occurred()) SWIG_fail;
11112 }
11113 {
11114 #if wxUSE_UNICODE
11115 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11116 #else
11117 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11118 #endif
11119 }
11120 {
11121 if (temp1)
11122 delete arg1;
11123 }
11124 return resultobj;
11125 fail:
11126 {
11127 if (temp1)
11128 delete arg1;
11129 }
11130 return NULL;
11131 }
11132
11133
11134 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11135 PyObject *resultobj = 0;
11136 wxString *arg1 = 0 ;
11137 wxString result;
11138 bool temp1 = false ;
11139 PyObject * obj0 = 0 ;
11140 char * kwnames[] = {
11141 (char *) "url", NULL
11142 };
11143
11144 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
11145 {
11146 arg1 = wxString_in_helper(obj0);
11147 if (arg1 == NULL) SWIG_fail;
11148 temp1 = true;
11149 }
11150 {
11151 PyThreadState* __tstate = wxPyBeginAllowThreads();
11152 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
11153 wxPyEndAllowThreads(__tstate);
11154 if (PyErr_Occurred()) SWIG_fail;
11155 }
11156 {
11157 #if wxUSE_UNICODE
11158 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11159 #else
11160 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11161 #endif
11162 }
11163 {
11164 if (temp1)
11165 delete arg1;
11166 }
11167 return resultobj;
11168 fail:
11169 {
11170 if (temp1)
11171 delete arg1;
11172 }
11173 return NULL;
11174 }
11175
11176
11177 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11178 PyObject *obj;
11179 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11180 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
11181 return SWIG_Py_Void();
11182 }
11183
11184 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11185 return SWIG_Python_InitShadowInstance(args);
11186 }
11187
11188 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11189 PyObject *resultobj = 0;
11190 wxInternetFSHandler *result = 0 ;
11191
11192 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
11193 {
11194 PyThreadState* __tstate = wxPyBeginAllowThreads();
11195 result = (wxInternetFSHandler *)new wxInternetFSHandler();
11196 wxPyEndAllowThreads(__tstate);
11197 if (PyErr_Occurred()) SWIG_fail;
11198 }
11199 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
11200 return resultobj;
11201 fail:
11202 return NULL;
11203 }
11204
11205
11206 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11207 PyObject *resultobj = 0;
11208 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
11209 wxString *arg2 = 0 ;
11210 bool result;
11211 void *argp1 = 0 ;
11212 int res1 = 0 ;
11213 bool temp2 = false ;
11214 PyObject * obj0 = 0 ;
11215 PyObject * obj1 = 0 ;
11216 char * kwnames[] = {
11217 (char *) "self",(char *) "location", NULL
11218 };
11219
11220 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11221 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
11222 if (!SWIG_IsOK(res1)) {
11223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
11224 }
11225 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
11226 {
11227 arg2 = wxString_in_helper(obj1);
11228 if (arg2 == NULL) SWIG_fail;
11229 temp2 = true;
11230 }
11231 {
11232 PyThreadState* __tstate = wxPyBeginAllowThreads();
11233 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11234 wxPyEndAllowThreads(__tstate);
11235 if (PyErr_Occurred()) SWIG_fail;
11236 }
11237 {
11238 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11239 }
11240 {
11241 if (temp2)
11242 delete arg2;
11243 }
11244 return resultobj;
11245 fail:
11246 {
11247 if (temp2)
11248 delete arg2;
11249 }
11250 return NULL;
11251 }
11252
11253
11254 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11255 PyObject *resultobj = 0;
11256 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
11257 wxFileSystem *arg2 = 0 ;
11258 wxString *arg3 = 0 ;
11259 wxFSFile *result = 0 ;
11260 void *argp1 = 0 ;
11261 int res1 = 0 ;
11262 void *argp2 = 0 ;
11263 int res2 = 0 ;
11264 bool temp3 = false ;
11265 PyObject * obj0 = 0 ;
11266 PyObject * obj1 = 0 ;
11267 PyObject * obj2 = 0 ;
11268 char * kwnames[] = {
11269 (char *) "self",(char *) "fs",(char *) "location", NULL
11270 };
11271
11272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11273 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
11274 if (!SWIG_IsOK(res1)) {
11275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
11276 }
11277 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
11278 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11279 if (!SWIG_IsOK(res2)) {
11280 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11281 }
11282 if (!argp2) {
11283 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11284 }
11285 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11286 {
11287 arg3 = wxString_in_helper(obj2);
11288 if (arg3 == NULL) SWIG_fail;
11289 temp3 = true;
11290 }
11291 {
11292 PyThreadState* __tstate = wxPyBeginAllowThreads();
11293 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11294 wxPyEndAllowThreads(__tstate);
11295 if (PyErr_Occurred()) SWIG_fail;
11296 }
11297 {
11298 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11299 }
11300 {
11301 if (temp3)
11302 delete arg3;
11303 }
11304 return resultobj;
11305 fail:
11306 {
11307 if (temp3)
11308 delete arg3;
11309 }
11310 return NULL;
11311 }
11312
11313
11314 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11315 PyObject *obj;
11316 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11317 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
11318 return SWIG_Py_Void();
11319 }
11320
11321 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11322 return SWIG_Python_InitShadowInstance(args);
11323 }
11324
11325 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11326 PyObject *resultobj = 0;
11327 wxZipFSHandler *result = 0 ;
11328
11329 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
11330 {
11331 PyThreadState* __tstate = wxPyBeginAllowThreads();
11332 result = (wxZipFSHandler *)new wxZipFSHandler();
11333 wxPyEndAllowThreads(__tstate);
11334 if (PyErr_Occurred()) SWIG_fail;
11335 }
11336 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
11337 return resultobj;
11338 fail:
11339 return NULL;
11340 }
11341
11342
11343 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11344 PyObject *resultobj = 0;
11345 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11346 wxString *arg2 = 0 ;
11347 bool result;
11348 void *argp1 = 0 ;
11349 int res1 = 0 ;
11350 bool temp2 = false ;
11351 PyObject * obj0 = 0 ;
11352 PyObject * obj1 = 0 ;
11353 char * kwnames[] = {
11354 (char *) "self",(char *) "location", NULL
11355 };
11356
11357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11358 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11359 if (!SWIG_IsOK(res1)) {
11360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11361 }
11362 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11363 {
11364 arg2 = wxString_in_helper(obj1);
11365 if (arg2 == NULL) SWIG_fail;
11366 temp2 = true;
11367 }
11368 {
11369 PyThreadState* __tstate = wxPyBeginAllowThreads();
11370 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11371 wxPyEndAllowThreads(__tstate);
11372 if (PyErr_Occurred()) SWIG_fail;
11373 }
11374 {
11375 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11376 }
11377 {
11378 if (temp2)
11379 delete arg2;
11380 }
11381 return resultobj;
11382 fail:
11383 {
11384 if (temp2)
11385 delete arg2;
11386 }
11387 return NULL;
11388 }
11389
11390
11391 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11392 PyObject *resultobj = 0;
11393 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11394 wxFileSystem *arg2 = 0 ;
11395 wxString *arg3 = 0 ;
11396 wxFSFile *result = 0 ;
11397 void *argp1 = 0 ;
11398 int res1 = 0 ;
11399 void *argp2 = 0 ;
11400 int res2 = 0 ;
11401 bool temp3 = false ;
11402 PyObject * obj0 = 0 ;
11403 PyObject * obj1 = 0 ;
11404 PyObject * obj2 = 0 ;
11405 char * kwnames[] = {
11406 (char *) "self",(char *) "fs",(char *) "location", NULL
11407 };
11408
11409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11410 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11411 if (!SWIG_IsOK(res1)) {
11412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11413 }
11414 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11415 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11416 if (!SWIG_IsOK(res2)) {
11417 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11418 }
11419 if (!argp2) {
11420 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11421 }
11422 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11423 {
11424 arg3 = wxString_in_helper(obj2);
11425 if (arg3 == NULL) SWIG_fail;
11426 temp3 = true;
11427 }
11428 {
11429 PyThreadState* __tstate = wxPyBeginAllowThreads();
11430 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11431 wxPyEndAllowThreads(__tstate);
11432 if (PyErr_Occurred()) SWIG_fail;
11433 }
11434 {
11435 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11436 }
11437 {
11438 if (temp3)
11439 delete arg3;
11440 }
11441 return resultobj;
11442 fail:
11443 {
11444 if (temp3)
11445 delete arg3;
11446 }
11447 return NULL;
11448 }
11449
11450
11451 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11452 PyObject *resultobj = 0;
11453 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11454 wxString *arg2 = 0 ;
11455 int arg3 = (int) 0 ;
11456 wxString result;
11457 void *argp1 = 0 ;
11458 int res1 = 0 ;
11459 bool temp2 = false ;
11460 int val3 ;
11461 int ecode3 = 0 ;
11462 PyObject * obj0 = 0 ;
11463 PyObject * obj1 = 0 ;
11464 PyObject * obj2 = 0 ;
11465 char * kwnames[] = {
11466 (char *) "self",(char *) "spec",(char *) "flags", NULL
11467 };
11468
11469 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11470 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11471 if (!SWIG_IsOK(res1)) {
11472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11473 }
11474 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11475 {
11476 arg2 = wxString_in_helper(obj1);
11477 if (arg2 == NULL) SWIG_fail;
11478 temp2 = true;
11479 }
11480 if (obj2) {
11481 ecode3 = SWIG_AsVal_int(obj2, &val3);
11482 if (!SWIG_IsOK(ecode3)) {
11483 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11484 }
11485 arg3 = static_cast< int >(val3);
11486 }
11487 {
11488 PyThreadState* __tstate = wxPyBeginAllowThreads();
11489 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11490 wxPyEndAllowThreads(__tstate);
11491 if (PyErr_Occurred()) SWIG_fail;
11492 }
11493 {
11494 #if wxUSE_UNICODE
11495 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11496 #else
11497 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11498 #endif
11499 }
11500 {
11501 if (temp2)
11502 delete arg2;
11503 }
11504 return resultobj;
11505 fail:
11506 {
11507 if (temp2)
11508 delete arg2;
11509 }
11510 return NULL;
11511 }
11512
11513
11514 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11515 PyObject *resultobj = 0;
11516 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11517 wxString result;
11518 void *argp1 = 0 ;
11519 int res1 = 0 ;
11520 PyObject *swig_obj[1] ;
11521
11522 if (!args) SWIG_fail;
11523 swig_obj[0] = args;
11524 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11525 if (!SWIG_IsOK(res1)) {
11526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11527 }
11528 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11529 {
11530 PyThreadState* __tstate = wxPyBeginAllowThreads();
11531 result = (arg1)->FindNext();
11532 wxPyEndAllowThreads(__tstate);
11533 if (PyErr_Occurred()) SWIG_fail;
11534 }
11535 {
11536 #if wxUSE_UNICODE
11537 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11538 #else
11539 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11540 #endif
11541 }
11542 return resultobj;
11543 fail:
11544 return NULL;
11545 }
11546
11547
11548 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11549 PyObject *obj;
11550 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11551 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
11552 return SWIG_Py_Void();
11553 }
11554
11555 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11556 return SWIG_Python_InitShadowInstance(args);
11557 }
11558
11559 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11560 PyObject *resultobj = 0;
11561 wxString *arg1 = 0 ;
11562 wxImage *arg2 = 0 ;
11563 long arg3 ;
11564 bool temp1 = false ;
11565 void *argp2 = 0 ;
11566 int res2 = 0 ;
11567 long val3 ;
11568 int ecode3 = 0 ;
11569 PyObject * obj0 = 0 ;
11570 PyObject * obj1 = 0 ;
11571 PyObject * obj2 = 0 ;
11572 char * kwnames[] = {
11573 (char *) "filename",(char *) "image",(char *) "type", NULL
11574 };
11575
11576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11577 {
11578 arg1 = wxString_in_helper(obj0);
11579 if (arg1 == NULL) SWIG_fail;
11580 temp1 = true;
11581 }
11582 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
11583 if (!SWIG_IsOK(res2)) {
11584 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11585 }
11586 if (!argp2) {
11587 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11588 }
11589 arg2 = reinterpret_cast< wxImage * >(argp2);
11590 ecode3 = SWIG_AsVal_long(obj2, &val3);
11591 if (!SWIG_IsOK(ecode3)) {
11592 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
11593 }
11594 arg3 = static_cast< long >(val3);
11595 {
11596 PyThreadState* __tstate = wxPyBeginAllowThreads();
11597 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
11598 wxPyEndAllowThreads(__tstate);
11599 if (PyErr_Occurred()) SWIG_fail;
11600 }
11601 resultobj = SWIG_Py_Void();
11602 {
11603 if (temp1)
11604 delete arg1;
11605 }
11606 return resultobj;
11607 fail:
11608 {
11609 if (temp1)
11610 delete arg1;
11611 }
11612 return NULL;
11613 }
11614
11615
11616 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11617 PyObject *resultobj = 0;
11618 wxString *arg1 = 0 ;
11619 wxBitmap *arg2 = 0 ;
11620 long arg3 ;
11621 bool temp1 = false ;
11622 void *argp2 = 0 ;
11623 int res2 = 0 ;
11624 long val3 ;
11625 int ecode3 = 0 ;
11626 PyObject * obj0 = 0 ;
11627 PyObject * obj1 = 0 ;
11628 PyObject * obj2 = 0 ;
11629 char * kwnames[] = {
11630 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
11631 };
11632
11633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11634 {
11635 arg1 = wxString_in_helper(obj0);
11636 if (arg1 == NULL) SWIG_fail;
11637 temp1 = true;
11638 }
11639 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
11640 if (!SWIG_IsOK(res2)) {
11641 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11642 }
11643 if (!argp2) {
11644 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11645 }
11646 arg2 = reinterpret_cast< wxBitmap * >(argp2);
11647 ecode3 = SWIG_AsVal_long(obj2, &val3);
11648 if (!SWIG_IsOK(ecode3)) {
11649 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
11650 }
11651 arg3 = static_cast< long >(val3);
11652 {
11653 PyThreadState* __tstate = wxPyBeginAllowThreads();
11654 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
11655 wxPyEndAllowThreads(__tstate);
11656 if (PyErr_Occurred()) SWIG_fail;
11657 }
11658 resultobj = SWIG_Py_Void();
11659 {
11660 if (temp1)
11661 delete arg1;
11662 }
11663 return resultobj;
11664 fail:
11665 {
11666 if (temp1)
11667 delete arg1;
11668 }
11669 return NULL;
11670 }
11671
11672
11673 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11674 PyObject *resultobj = 0;
11675 wxString *arg1 = 0 ;
11676 PyObject *arg2 = (PyObject *) 0 ;
11677 bool temp1 = false ;
11678 PyObject * obj0 = 0 ;
11679 PyObject * obj1 = 0 ;
11680 char * kwnames[] = {
11681 (char *) "filename",(char *) "data", NULL
11682 };
11683
11684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
11685 {
11686 arg1 = wxString_in_helper(obj0);
11687 if (arg1 == NULL) SWIG_fail;
11688 temp1 = true;
11689 }
11690 arg2 = obj1;
11691 {
11692 PyThreadState* __tstate = wxPyBeginAllowThreads();
11693 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
11694 wxPyEndAllowThreads(__tstate);
11695 if (PyErr_Occurred()) SWIG_fail;
11696 }
11697 resultobj = SWIG_Py_Void();
11698 {
11699 if (temp1)
11700 delete arg1;
11701 }
11702 return resultobj;
11703 fail:
11704 {
11705 if (temp1)
11706 delete arg1;
11707 }
11708 return NULL;
11709 }
11710
11711
11712 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11713 PyObject *resultobj = 0;
11714 wxMemoryFSHandler *result = 0 ;
11715
11716 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
11717 {
11718 PyThreadState* __tstate = wxPyBeginAllowThreads();
11719 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
11720 wxPyEndAllowThreads(__tstate);
11721 if (PyErr_Occurred()) SWIG_fail;
11722 }
11723 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
11724 return resultobj;
11725 fail:
11726 return NULL;
11727 }
11728
11729
11730 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11731 PyObject *resultobj = 0;
11732 wxString *arg1 = 0 ;
11733 bool temp1 = false ;
11734 PyObject * obj0 = 0 ;
11735 char * kwnames[] = {
11736 (char *) "filename", NULL
11737 };
11738
11739 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
11740 {
11741 arg1 = wxString_in_helper(obj0);
11742 if (arg1 == NULL) SWIG_fail;
11743 temp1 = true;
11744 }
11745 {
11746 PyThreadState* __tstate = wxPyBeginAllowThreads();
11747 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
11748 wxPyEndAllowThreads(__tstate);
11749 if (PyErr_Occurred()) SWIG_fail;
11750 }
11751 resultobj = SWIG_Py_Void();
11752 {
11753 if (temp1)
11754 delete arg1;
11755 }
11756 return resultobj;
11757 fail:
11758 {
11759 if (temp1)
11760 delete arg1;
11761 }
11762 return NULL;
11763 }
11764
11765
11766 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11767 PyObject *resultobj = 0;
11768 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11769 wxString *arg2 = 0 ;
11770 bool result;
11771 void *argp1 = 0 ;
11772 int res1 = 0 ;
11773 bool temp2 = false ;
11774 PyObject * obj0 = 0 ;
11775 PyObject * obj1 = 0 ;
11776 char * kwnames[] = {
11777 (char *) "self",(char *) "location", NULL
11778 };
11779
11780 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11781 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11782 if (!SWIG_IsOK(res1)) {
11783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11784 }
11785 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11786 {
11787 arg2 = wxString_in_helper(obj1);
11788 if (arg2 == NULL) SWIG_fail;
11789 temp2 = true;
11790 }
11791 {
11792 PyThreadState* __tstate = wxPyBeginAllowThreads();
11793 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11794 wxPyEndAllowThreads(__tstate);
11795 if (PyErr_Occurred()) SWIG_fail;
11796 }
11797 {
11798 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11799 }
11800 {
11801 if (temp2)
11802 delete arg2;
11803 }
11804 return resultobj;
11805 fail:
11806 {
11807 if (temp2)
11808 delete arg2;
11809 }
11810 return NULL;
11811 }
11812
11813
11814 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11815 PyObject *resultobj = 0;
11816 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11817 wxFileSystem *arg2 = 0 ;
11818 wxString *arg3 = 0 ;
11819 wxFSFile *result = 0 ;
11820 void *argp1 = 0 ;
11821 int res1 = 0 ;
11822 void *argp2 = 0 ;
11823 int res2 = 0 ;
11824 bool temp3 = false ;
11825 PyObject * obj0 = 0 ;
11826 PyObject * obj1 = 0 ;
11827 PyObject * obj2 = 0 ;
11828 char * kwnames[] = {
11829 (char *) "self",(char *) "fs",(char *) "location", NULL
11830 };
11831
11832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11834 if (!SWIG_IsOK(res1)) {
11835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11836 }
11837 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11838 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11839 if (!SWIG_IsOK(res2)) {
11840 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11841 }
11842 if (!argp2) {
11843 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11844 }
11845 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11846 {
11847 arg3 = wxString_in_helper(obj2);
11848 if (arg3 == NULL) SWIG_fail;
11849 temp3 = true;
11850 }
11851 {
11852 PyThreadState* __tstate = wxPyBeginAllowThreads();
11853 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11854 wxPyEndAllowThreads(__tstate);
11855 if (PyErr_Occurred()) SWIG_fail;
11856 }
11857 {
11858 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11859 }
11860 {
11861 if (temp3)
11862 delete arg3;
11863 }
11864 return resultobj;
11865 fail:
11866 {
11867 if (temp3)
11868 delete arg3;
11869 }
11870 return NULL;
11871 }
11872
11873
11874 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11875 PyObject *resultobj = 0;
11876 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11877 wxString *arg2 = 0 ;
11878 int arg3 = (int) 0 ;
11879 wxString result;
11880 void *argp1 = 0 ;
11881 int res1 = 0 ;
11882 bool temp2 = false ;
11883 int val3 ;
11884 int ecode3 = 0 ;
11885 PyObject * obj0 = 0 ;
11886 PyObject * obj1 = 0 ;
11887 PyObject * obj2 = 0 ;
11888 char * kwnames[] = {
11889 (char *) "self",(char *) "spec",(char *) "flags", NULL
11890 };
11891
11892 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11893 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11894 if (!SWIG_IsOK(res1)) {
11895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11896 }
11897 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11898 {
11899 arg2 = wxString_in_helper(obj1);
11900 if (arg2 == NULL) SWIG_fail;
11901 temp2 = true;
11902 }
11903 if (obj2) {
11904 ecode3 = SWIG_AsVal_int(obj2, &val3);
11905 if (!SWIG_IsOK(ecode3)) {
11906 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11907 }
11908 arg3 = static_cast< int >(val3);
11909 }
11910 {
11911 PyThreadState* __tstate = wxPyBeginAllowThreads();
11912 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11913 wxPyEndAllowThreads(__tstate);
11914 if (PyErr_Occurred()) SWIG_fail;
11915 }
11916 {
11917 #if wxUSE_UNICODE
11918 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11919 #else
11920 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11921 #endif
11922 }
11923 {
11924 if (temp2)
11925 delete arg2;
11926 }
11927 return resultobj;
11928 fail:
11929 {
11930 if (temp2)
11931 delete arg2;
11932 }
11933 return NULL;
11934 }
11935
11936
11937 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11938 PyObject *resultobj = 0;
11939 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11940 wxString result;
11941 void *argp1 = 0 ;
11942 int res1 = 0 ;
11943 PyObject *swig_obj[1] ;
11944
11945 if (!args) SWIG_fail;
11946 swig_obj[0] = args;
11947 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11948 if (!SWIG_IsOK(res1)) {
11949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11950 }
11951 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11952 {
11953 PyThreadState* __tstate = wxPyBeginAllowThreads();
11954 result = (arg1)->FindNext();
11955 wxPyEndAllowThreads(__tstate);
11956 if (PyErr_Occurred()) SWIG_fail;
11957 }
11958 {
11959 #if wxUSE_UNICODE
11960 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11961 #else
11962 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11963 #endif
11964 }
11965 return resultobj;
11966 fail:
11967 return NULL;
11968 }
11969
11970
11971 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11972 PyObject *obj;
11973 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11974 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
11975 return SWIG_Py_Void();
11976 }
11977
11978 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11979 return SWIG_Python_InitShadowInstance(args);
11980 }
11981
11982 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11983 PyObject *resultobj = 0;
11984 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11985 wxString result;
11986 void *argp1 = 0 ;
11987 int res1 = 0 ;
11988 PyObject *swig_obj[1] ;
11989
11990 if (!args) SWIG_fail;
11991 swig_obj[0] = args;
11992 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11993 if (!SWIG_IsOK(res1)) {
11994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11995 }
11996 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11997 {
11998 PyThreadState* __tstate = wxPyBeginAllowThreads();
11999 result = (arg1)->GetName();
12000 wxPyEndAllowThreads(__tstate);
12001 if (PyErr_Occurred()) SWIG_fail;
12002 }
12003 {
12004 #if wxUSE_UNICODE
12005 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12006 #else
12007 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12008 #endif
12009 }
12010 return resultobj;
12011 fail:
12012 return NULL;
12013 }
12014
12015
12016 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12017 PyObject *resultobj = 0;
12018 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12019 wxString result;
12020 void *argp1 = 0 ;
12021 int res1 = 0 ;
12022 PyObject *swig_obj[1] ;
12023
12024 if (!args) SWIG_fail;
12025 swig_obj[0] = args;
12026 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12027 if (!SWIG_IsOK(res1)) {
12028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12029 }
12030 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12031 {
12032 PyThreadState* __tstate = wxPyBeginAllowThreads();
12033 result = (arg1)->GetExtension();
12034 wxPyEndAllowThreads(__tstate);
12035 if (PyErr_Occurred()) SWIG_fail;
12036 }
12037 {
12038 #if wxUSE_UNICODE
12039 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12040 #else
12041 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12042 #endif
12043 }
12044 return resultobj;
12045 fail:
12046 return NULL;
12047 }
12048
12049
12050 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12051 PyObject *resultobj = 0;
12052 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12053 long result;
12054 void *argp1 = 0 ;
12055 int res1 = 0 ;
12056 PyObject *swig_obj[1] ;
12057
12058 if (!args) SWIG_fail;
12059 swig_obj[0] = args;
12060 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12061 if (!SWIG_IsOK(res1)) {
12062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12063 }
12064 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12065 {
12066 PyThreadState* __tstate = wxPyBeginAllowThreads();
12067 result = (long)(arg1)->GetType();
12068 wxPyEndAllowThreads(__tstate);
12069 if (PyErr_Occurred()) SWIG_fail;
12070 }
12071 resultobj = SWIG_From_long(static_cast< long >(result));
12072 return resultobj;
12073 fail:
12074 return NULL;
12075 }
12076
12077
12078 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12079 PyObject *resultobj = 0;
12080 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12081 wxString result;
12082 void *argp1 = 0 ;
12083 int res1 = 0 ;
12084 PyObject *swig_obj[1] ;
12085
12086 if (!args) SWIG_fail;
12087 swig_obj[0] = args;
12088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12089 if (!SWIG_IsOK(res1)) {
12090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12091 }
12092 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12093 {
12094 PyThreadState* __tstate = wxPyBeginAllowThreads();
12095 result = (arg1)->GetMimeType();
12096 wxPyEndAllowThreads(__tstate);
12097 if (PyErr_Occurred()) SWIG_fail;
12098 }
12099 {
12100 #if wxUSE_UNICODE
12101 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12102 #else
12103 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12104 #endif
12105 }
12106 return resultobj;
12107 fail:
12108 return NULL;
12109 }
12110
12111
12112 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12113 PyObject *resultobj = 0;
12114 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12115 wxString *arg2 = 0 ;
12116 bool result;
12117 void *argp1 = 0 ;
12118 int res1 = 0 ;
12119 bool temp2 = false ;
12120 PyObject * obj0 = 0 ;
12121 PyObject * obj1 = 0 ;
12122 char * kwnames[] = {
12123 (char *) "self",(char *) "name", NULL
12124 };
12125
12126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
12127 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12128 if (!SWIG_IsOK(res1)) {
12129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12130 }
12131 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12132 {
12133 arg2 = wxString_in_helper(obj1);
12134 if (arg2 == NULL) SWIG_fail;
12135 temp2 = true;
12136 }
12137 {
12138 PyThreadState* __tstate = wxPyBeginAllowThreads();
12139 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
12140 wxPyEndAllowThreads(__tstate);
12141 if (PyErr_Occurred()) SWIG_fail;
12142 }
12143 {
12144 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12145 }
12146 {
12147 if (temp2)
12148 delete arg2;
12149 }
12150 return resultobj;
12151 fail:
12152 {
12153 if (temp2)
12154 delete arg2;
12155 }
12156 return NULL;
12157 }
12158
12159
12160 SWIGINTERN PyObject *_wrap_ImageHandler_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12161 PyObject *resultobj = 0;
12162 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12163 wxInputStream *arg2 = 0 ;
12164 bool result;
12165 void *argp1 = 0 ;
12166 int res1 = 0 ;
12167 wxPyInputStream *temp2 ;
12168 bool created2 ;
12169 PyObject * obj0 = 0 ;
12170 PyObject * obj1 = 0 ;
12171 char * kwnames[] = {
12172 (char *) "self",(char *) "stream", NULL
12173 };
12174
12175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanReadStream",kwnames,&obj0,&obj1)) SWIG_fail;
12176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12177 if (!SWIG_IsOK(res1)) {
12178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanReadStream" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12179 }
12180 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12181 {
12182 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
12183 arg2 = temp2->m_wxis;
12184 created2 = false;
12185 } else {
12186 PyErr_Clear(); // clear the failure of the wxPyConvert above
12187 arg2 = wxPyCBInputStream_create(obj1, false);
12188 if (arg2 == NULL) {
12189 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12190 SWIG_fail;
12191 }
12192 created2 = true;
12193 }
12194 }
12195 {
12196 PyThreadState* __tstate = wxPyBeginAllowThreads();
12197 result = (bool)(arg1)->CanRead(*arg2);
12198 wxPyEndAllowThreads(__tstate);
12199 if (PyErr_Occurred()) SWIG_fail;
12200 }
12201 {
12202 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12203 }
12204 {
12205 if (created2) delete arg2;
12206 }
12207 return resultobj;
12208 fail:
12209 {
12210 if (created2) delete arg2;
12211 }
12212 return NULL;
12213 }
12214
12215
12216 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12217 PyObject *resultobj = 0;
12218 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12219 wxString *arg2 = 0 ;
12220 void *argp1 = 0 ;
12221 int res1 = 0 ;
12222 bool temp2 = false ;
12223 PyObject * obj0 = 0 ;
12224 PyObject * obj1 = 0 ;
12225 char * kwnames[] = {
12226 (char *) "self",(char *) "name", NULL
12227 };
12228
12229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
12230 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12231 if (!SWIG_IsOK(res1)) {
12232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12233 }
12234 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12235 {
12236 arg2 = wxString_in_helper(obj1);
12237 if (arg2 == NULL) SWIG_fail;
12238 temp2 = true;
12239 }
12240 {
12241 PyThreadState* __tstate = wxPyBeginAllowThreads();
12242 (arg1)->SetName((wxString const &)*arg2);
12243 wxPyEndAllowThreads(__tstate);
12244 if (PyErr_Occurred()) SWIG_fail;
12245 }
12246 resultobj = SWIG_Py_Void();
12247 {
12248 if (temp2)
12249 delete arg2;
12250 }
12251 return resultobj;
12252 fail:
12253 {
12254 if (temp2)
12255 delete arg2;
12256 }
12257 return NULL;
12258 }
12259
12260
12261 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12262 PyObject *resultobj = 0;
12263 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12264 wxString *arg2 = 0 ;
12265 void *argp1 = 0 ;
12266 int res1 = 0 ;
12267 bool temp2 = false ;
12268 PyObject * obj0 = 0 ;
12269 PyObject * obj1 = 0 ;
12270 char * kwnames[] = {
12271 (char *) "self",(char *) "extension", NULL
12272 };
12273
12274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
12275 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12276 if (!SWIG_IsOK(res1)) {
12277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12278 }
12279 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12280 {
12281 arg2 = wxString_in_helper(obj1);
12282 if (arg2 == NULL) SWIG_fail;
12283 temp2 = true;
12284 }
12285 {
12286 PyThreadState* __tstate = wxPyBeginAllowThreads();
12287 (arg1)->SetExtension((wxString const &)*arg2);
12288 wxPyEndAllowThreads(__tstate);
12289 if (PyErr_Occurred()) SWIG_fail;
12290 }
12291 resultobj = SWIG_Py_Void();
12292 {
12293 if (temp2)
12294 delete arg2;
12295 }
12296 return resultobj;
12297 fail:
12298 {
12299 if (temp2)
12300 delete arg2;
12301 }
12302 return NULL;
12303 }
12304
12305
12306 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12307 PyObject *resultobj = 0;
12308 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12309 long arg2 ;
12310 void *argp1 = 0 ;
12311 int res1 = 0 ;
12312 long val2 ;
12313 int ecode2 = 0 ;
12314 PyObject * obj0 = 0 ;
12315 PyObject * obj1 = 0 ;
12316 char * kwnames[] = {
12317 (char *) "self",(char *) "type", NULL
12318 };
12319
12320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
12321 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12322 if (!SWIG_IsOK(res1)) {
12323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12324 }
12325 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12326 ecode2 = SWIG_AsVal_long(obj1, &val2);
12327 if (!SWIG_IsOK(ecode2)) {
12328 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
12329 }
12330 arg2 = static_cast< long >(val2);
12331 {
12332 PyThreadState* __tstate = wxPyBeginAllowThreads();
12333 (arg1)->SetType(arg2);
12334 wxPyEndAllowThreads(__tstate);
12335 if (PyErr_Occurred()) SWIG_fail;
12336 }
12337 resultobj = SWIG_Py_Void();
12338 return resultobj;
12339 fail:
12340 return NULL;
12341 }
12342
12343
12344 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12345 PyObject *resultobj = 0;
12346 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12347 wxString *arg2 = 0 ;
12348 void *argp1 = 0 ;
12349 int res1 = 0 ;
12350 bool temp2 = false ;
12351 PyObject * obj0 = 0 ;
12352 PyObject * obj1 = 0 ;
12353 char * kwnames[] = {
12354 (char *) "self",(char *) "mimetype", NULL
12355 };
12356
12357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
12358 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12359 if (!SWIG_IsOK(res1)) {
12360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12361 }
12362 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12363 {
12364 arg2 = wxString_in_helper(obj1);
12365 if (arg2 == NULL) SWIG_fail;
12366 temp2 = true;
12367 }
12368 {
12369 PyThreadState* __tstate = wxPyBeginAllowThreads();
12370 (arg1)->SetMimeType((wxString const &)*arg2);
12371 wxPyEndAllowThreads(__tstate);
12372 if (PyErr_Occurred()) SWIG_fail;
12373 }
12374 resultobj = SWIG_Py_Void();
12375 {
12376 if (temp2)
12377 delete arg2;
12378 }
12379 return resultobj;
12380 fail:
12381 {
12382 if (temp2)
12383 delete arg2;
12384 }
12385 return NULL;
12386 }
12387
12388
12389 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12390 PyObject *obj;
12391 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12392 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
12393 return SWIG_Py_Void();
12394 }
12395
12396 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12397 PyObject *resultobj = 0;
12398 wxPyImageHandler *result = 0 ;
12399
12400 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
12401 {
12402 PyThreadState* __tstate = wxPyBeginAllowThreads();
12403 result = (wxPyImageHandler *)new wxPyImageHandler();
12404 wxPyEndAllowThreads(__tstate);
12405 if (PyErr_Occurred()) SWIG_fail;
12406 }
12407 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
12408 return resultobj;
12409 fail:
12410 return NULL;
12411 }
12412
12413
12414 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12415 PyObject *resultobj = 0;
12416 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
12417 PyObject *arg2 = (PyObject *) 0 ;
12418 void *argp1 = 0 ;
12419 int res1 = 0 ;
12420 PyObject * obj0 = 0 ;
12421 PyObject * obj1 = 0 ;
12422 char * kwnames[] = {
12423 (char *) "self",(char *) "self", NULL
12424 };
12425
12426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
12427 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
12428 if (!SWIG_IsOK(res1)) {
12429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
12430 }
12431 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
12432 arg2 = obj1;
12433 {
12434 PyThreadState* __tstate = wxPyBeginAllowThreads();
12435 (arg1)->_SetSelf(arg2);
12436 wxPyEndAllowThreads(__tstate);
12437 if (PyErr_Occurred()) SWIG_fail;
12438 }
12439 resultobj = SWIG_Py_Void();
12440 return resultobj;
12441 fail:
12442 return NULL;
12443 }
12444
12445
12446 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12447 PyObject *obj;
12448 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12449 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
12450 return SWIG_Py_Void();
12451 }
12452
12453 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12454 return SWIG_Python_InitShadowInstance(args);
12455 }
12456
12457 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12458 PyObject *resultobj = 0;
12459 wxImageHistogram *result = 0 ;
12460
12461 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
12462 {
12463 PyThreadState* __tstate = wxPyBeginAllowThreads();
12464 result = (wxImageHistogram *)new wxImageHistogram();
12465 wxPyEndAllowThreads(__tstate);
12466 if (PyErr_Occurred()) SWIG_fail;
12467 }
12468 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
12469 return resultobj;
12470 fail:
12471 return NULL;
12472 }
12473
12474
12475 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12476 PyObject *resultobj = 0;
12477 byte arg1 ;
12478 byte arg2 ;
12479 byte arg3 ;
12480 unsigned long result;
12481 unsigned char val1 ;
12482 int ecode1 = 0 ;
12483 unsigned char val2 ;
12484 int ecode2 = 0 ;
12485 unsigned char val3 ;
12486 int ecode3 = 0 ;
12487 PyObject * obj0 = 0 ;
12488 PyObject * obj1 = 0 ;
12489 PyObject * obj2 = 0 ;
12490 char * kwnames[] = {
12491 (char *) "r",(char *) "g",(char *) "b", NULL
12492 };
12493
12494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12495 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12496 if (!SWIG_IsOK(ecode1)) {
12497 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
12498 }
12499 arg1 = static_cast< byte >(val1);
12500 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12501 if (!SWIG_IsOK(ecode2)) {
12502 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
12503 }
12504 arg2 = static_cast< byte >(val2);
12505 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12506 if (!SWIG_IsOK(ecode3)) {
12507 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
12508 }
12509 arg3 = static_cast< byte >(val3);
12510 {
12511 PyThreadState* __tstate = wxPyBeginAllowThreads();
12512 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
12513 wxPyEndAllowThreads(__tstate);
12514 if (PyErr_Occurred()) SWIG_fail;
12515 }
12516 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12517 return resultobj;
12518 fail:
12519 return NULL;
12520 }
12521
12522
12523 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12524 PyObject *resultobj = 0;
12525 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12526 byte *arg2 = (byte *) 0 ;
12527 byte *arg3 = (byte *) 0 ;
12528 byte *arg4 = (byte *) 0 ;
12529 byte arg5 = (byte) 1 ;
12530 byte arg6 = (byte) 0 ;
12531 byte arg7 = (byte) 0 ;
12532 bool result;
12533 void *argp1 = 0 ;
12534 int res1 = 0 ;
12535 byte temp2 ;
12536 int res2 = SWIG_TMPOBJ ;
12537 byte temp3 ;
12538 int res3 = SWIG_TMPOBJ ;
12539 byte temp4 ;
12540 int res4 = SWIG_TMPOBJ ;
12541 unsigned char val5 ;
12542 int ecode5 = 0 ;
12543 unsigned char val6 ;
12544 int ecode6 = 0 ;
12545 unsigned char val7 ;
12546 int ecode7 = 0 ;
12547 PyObject * obj0 = 0 ;
12548 PyObject * obj1 = 0 ;
12549 PyObject * obj2 = 0 ;
12550 PyObject * obj3 = 0 ;
12551 char * kwnames[] = {
12552 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
12553 };
12554
12555 arg2 = &temp2;
12556 arg3 = &temp3;
12557 arg4 = &temp4;
12558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12559 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12560 if (!SWIG_IsOK(res1)) {
12561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
12562 }
12563 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12564 if (obj1) {
12565 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
12566 if (!SWIG_IsOK(ecode5)) {
12567 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
12568 }
12569 arg5 = static_cast< byte >(val5);
12570 }
12571 if (obj2) {
12572 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
12573 if (!SWIG_IsOK(ecode6)) {
12574 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
12575 }
12576 arg6 = static_cast< byte >(val6);
12577 }
12578 if (obj3) {
12579 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
12580 if (!SWIG_IsOK(ecode7)) {
12581 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
12582 }
12583 arg7 = static_cast< byte >(val7);
12584 }
12585 {
12586 PyThreadState* __tstate = wxPyBeginAllowThreads();
12587 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
12588 wxPyEndAllowThreads(__tstate);
12589 if (PyErr_Occurred()) SWIG_fail;
12590 }
12591 {
12592 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12593 }
12594 if (SWIG_IsTmpObj(res2)) {
12595 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
12596 } else {
12597 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12598 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
12599 }
12600 if (SWIG_IsTmpObj(res3)) {
12601 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
12602 } else {
12603 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12604 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
12605 }
12606 if (SWIG_IsTmpObj(res4)) {
12607 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
12608 } else {
12609 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12610 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
12611 }
12612 return resultobj;
12613 fail:
12614 return NULL;
12615 }
12616
12617
12618 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12619 PyObject *resultobj = 0;
12620 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12621 unsigned long arg2 ;
12622 unsigned long result;
12623 void *argp1 = 0 ;
12624 int res1 = 0 ;
12625 unsigned long val2 ;
12626 int ecode2 = 0 ;
12627 PyObject * obj0 = 0 ;
12628 PyObject * obj1 = 0 ;
12629 char * kwnames[] = {
12630 (char *) "self",(char *) "key", NULL
12631 };
12632
12633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
12634 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12635 if (!SWIG_IsOK(res1)) {
12636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12637 }
12638 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12639 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
12640 if (!SWIG_IsOK(ecode2)) {
12641 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
12642 }
12643 arg2 = static_cast< unsigned long >(val2);
12644 {
12645 PyThreadState* __tstate = wxPyBeginAllowThreads();
12646 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
12647 wxPyEndAllowThreads(__tstate);
12648 if (PyErr_Occurred()) SWIG_fail;
12649 }
12650 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12651 return resultobj;
12652 fail:
12653 return NULL;
12654 }
12655
12656
12657 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12658 PyObject *resultobj = 0;
12659 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12660 byte arg2 ;
12661 byte arg3 ;
12662 byte arg4 ;
12663 unsigned long result;
12664 void *argp1 = 0 ;
12665 int res1 = 0 ;
12666 unsigned char val2 ;
12667 int ecode2 = 0 ;
12668 unsigned char val3 ;
12669 int ecode3 = 0 ;
12670 unsigned char val4 ;
12671 int ecode4 = 0 ;
12672 PyObject * obj0 = 0 ;
12673 PyObject * obj1 = 0 ;
12674 PyObject * obj2 = 0 ;
12675 PyObject * obj3 = 0 ;
12676 char * kwnames[] = {
12677 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12678 };
12679
12680 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12681 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12682 if (!SWIG_IsOK(res1)) {
12683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12684 }
12685 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12686 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12687 if (!SWIG_IsOK(ecode2)) {
12688 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
12689 }
12690 arg2 = static_cast< byte >(val2);
12691 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12692 if (!SWIG_IsOK(ecode3)) {
12693 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
12694 }
12695 arg3 = static_cast< byte >(val3);
12696 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
12697 if (!SWIG_IsOK(ecode4)) {
12698 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
12699 }
12700 arg4 = static_cast< byte >(val4);
12701 {
12702 PyThreadState* __tstate = wxPyBeginAllowThreads();
12703 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
12704 wxPyEndAllowThreads(__tstate);
12705 if (PyErr_Occurred()) SWIG_fail;
12706 }
12707 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12708 return resultobj;
12709 fail:
12710 return NULL;
12711 }
12712
12713
12714 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12715 PyObject *resultobj = 0;
12716 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12717 wxColour *arg2 = 0 ;
12718 unsigned long result;
12719 void *argp1 = 0 ;
12720 int res1 = 0 ;
12721 wxColour temp2 ;
12722 PyObject * obj0 = 0 ;
12723 PyObject * obj1 = 0 ;
12724 char * kwnames[] = {
12725 (char *) "self",(char *) "colour", NULL
12726 };
12727
12728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
12729 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12730 if (!SWIG_IsOK(res1)) {
12731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12732 }
12733 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12734 {
12735 arg2 = &temp2;
12736 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12737 }
12738 {
12739 PyThreadState* __tstate = wxPyBeginAllowThreads();
12740 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
12741 wxPyEndAllowThreads(__tstate);
12742 if (PyErr_Occurred()) SWIG_fail;
12743 }
12744 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12745 return resultobj;
12746 fail:
12747 return NULL;
12748 }
12749
12750
12751 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12752 PyObject *obj;
12753 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12754 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
12755 return SWIG_Py_Void();
12756 }
12757
12758 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12759 return SWIG_Python_InitShadowInstance(args);
12760 }
12761
12762 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12763 PyObject *resultobj = 0;
12764 byte arg1 = (byte) 0 ;
12765 byte arg2 = (byte) 0 ;
12766 byte arg3 = (byte) 0 ;
12767 wxImage_RGBValue *result = 0 ;
12768 unsigned char val1 ;
12769 int ecode1 = 0 ;
12770 unsigned char val2 ;
12771 int ecode2 = 0 ;
12772 unsigned char val3 ;
12773 int ecode3 = 0 ;
12774 PyObject * obj0 = 0 ;
12775 PyObject * obj1 = 0 ;
12776 PyObject * obj2 = 0 ;
12777 char * kwnames[] = {
12778 (char *) "r",(char *) "g",(char *) "b", NULL
12779 };
12780
12781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12782 if (obj0) {
12783 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12784 if (!SWIG_IsOK(ecode1)) {
12785 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
12786 }
12787 arg1 = static_cast< byte >(val1);
12788 }
12789 if (obj1) {
12790 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12791 if (!SWIG_IsOK(ecode2)) {
12792 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
12793 }
12794 arg2 = static_cast< byte >(val2);
12795 }
12796 if (obj2) {
12797 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12798 if (!SWIG_IsOK(ecode3)) {
12799 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
12800 }
12801 arg3 = static_cast< byte >(val3);
12802 }
12803 {
12804 PyThreadState* __tstate = wxPyBeginAllowThreads();
12805 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
12806 wxPyEndAllowThreads(__tstate);
12807 if (PyErr_Occurred()) SWIG_fail;
12808 }
12809 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
12810 return resultobj;
12811 fail:
12812 return NULL;
12813 }
12814
12815
12816 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12817 PyObject *resultobj = 0;
12818 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12819 byte arg2 ;
12820 void *argp1 = 0 ;
12821 int res1 = 0 ;
12822 unsigned char val2 ;
12823 int ecode2 = 0 ;
12824 PyObject *swig_obj[2] ;
12825
12826 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
12827 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12828 if (!SWIG_IsOK(res1)) {
12829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12830 }
12831 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12832 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12833 if (!SWIG_IsOK(ecode2)) {
12834 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
12835 }
12836 arg2 = static_cast< byte >(val2);
12837 if (arg1) (arg1)->red = arg2;
12838
12839 resultobj = SWIG_Py_Void();
12840 return resultobj;
12841 fail:
12842 return NULL;
12843 }
12844
12845
12846 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12847 PyObject *resultobj = 0;
12848 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12849 byte result;
12850 void *argp1 = 0 ;
12851 int res1 = 0 ;
12852 PyObject *swig_obj[1] ;
12853
12854 if (!args) SWIG_fail;
12855 swig_obj[0] = args;
12856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12857 if (!SWIG_IsOK(res1)) {
12858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12859 }
12860 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12861 result = (byte) ((arg1)->red);
12862 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12863 return resultobj;
12864 fail:
12865 return NULL;
12866 }
12867
12868
12869 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12870 PyObject *resultobj = 0;
12871 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12872 byte arg2 ;
12873 void *argp1 = 0 ;
12874 int res1 = 0 ;
12875 unsigned char val2 ;
12876 int ecode2 = 0 ;
12877 PyObject *swig_obj[2] ;
12878
12879 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
12880 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12881 if (!SWIG_IsOK(res1)) {
12882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12883 }
12884 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12885 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12886 if (!SWIG_IsOK(ecode2)) {
12887 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
12888 }
12889 arg2 = static_cast< byte >(val2);
12890 if (arg1) (arg1)->green = arg2;
12891
12892 resultobj = SWIG_Py_Void();
12893 return resultobj;
12894 fail:
12895 return NULL;
12896 }
12897
12898
12899 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12900 PyObject *resultobj = 0;
12901 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12902 byte result;
12903 void *argp1 = 0 ;
12904 int res1 = 0 ;
12905 PyObject *swig_obj[1] ;
12906
12907 if (!args) SWIG_fail;
12908 swig_obj[0] = args;
12909 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12910 if (!SWIG_IsOK(res1)) {
12911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12912 }
12913 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12914 result = (byte) ((arg1)->green);
12915 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12916 return resultobj;
12917 fail:
12918 return NULL;
12919 }
12920
12921
12922 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12923 PyObject *resultobj = 0;
12924 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12925 byte arg2 ;
12926 void *argp1 = 0 ;
12927 int res1 = 0 ;
12928 unsigned char val2 ;
12929 int ecode2 = 0 ;
12930 PyObject *swig_obj[2] ;
12931
12932 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
12933 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12934 if (!SWIG_IsOK(res1)) {
12935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12936 }
12937 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12938 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12939 if (!SWIG_IsOK(ecode2)) {
12940 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
12941 }
12942 arg2 = static_cast< byte >(val2);
12943 if (arg1) (arg1)->blue = arg2;
12944
12945 resultobj = SWIG_Py_Void();
12946 return resultobj;
12947 fail:
12948 return NULL;
12949 }
12950
12951
12952 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12953 PyObject *resultobj = 0;
12954 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12955 byte result;
12956 void *argp1 = 0 ;
12957 int res1 = 0 ;
12958 PyObject *swig_obj[1] ;
12959
12960 if (!args) SWIG_fail;
12961 swig_obj[0] = args;
12962 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12963 if (!SWIG_IsOK(res1)) {
12964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12965 }
12966 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12967 result = (byte) ((arg1)->blue);
12968 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12969 return resultobj;
12970 fail:
12971 return NULL;
12972 }
12973
12974
12975 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12976 PyObject *obj;
12977 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12978 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
12979 return SWIG_Py_Void();
12980 }
12981
12982 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12983 return SWIG_Python_InitShadowInstance(args);
12984 }
12985
12986 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12987 PyObject *resultobj = 0;
12988 double arg1 = (double) 0.0 ;
12989 double arg2 = (double) 0.0 ;
12990 double arg3 = (double) 0.0 ;
12991 wxImage_HSVValue *result = 0 ;
12992 double val1 ;
12993 int ecode1 = 0 ;
12994 double val2 ;
12995 int ecode2 = 0 ;
12996 double val3 ;
12997 int ecode3 = 0 ;
12998 PyObject * obj0 = 0 ;
12999 PyObject * obj1 = 0 ;
13000 PyObject * obj2 = 0 ;
13001 char * kwnames[] = {
13002 (char *) "h",(char *) "s",(char *) "v", NULL
13003 };
13004
13005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13006 if (obj0) {
13007 ecode1 = SWIG_AsVal_double(obj0, &val1);
13008 if (!SWIG_IsOK(ecode1)) {
13009 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
13010 }
13011 arg1 = static_cast< double >(val1);
13012 }
13013 if (obj1) {
13014 ecode2 = SWIG_AsVal_double(obj1, &val2);
13015 if (!SWIG_IsOK(ecode2)) {
13016 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
13017 }
13018 arg2 = static_cast< double >(val2);
13019 }
13020 if (obj2) {
13021 ecode3 = SWIG_AsVal_double(obj2, &val3);
13022 if (!SWIG_IsOK(ecode3)) {
13023 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
13024 }
13025 arg3 = static_cast< double >(val3);
13026 }
13027 {
13028 PyThreadState* __tstate = wxPyBeginAllowThreads();
13029 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
13030 wxPyEndAllowThreads(__tstate);
13031 if (PyErr_Occurred()) SWIG_fail;
13032 }
13033 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
13034 return resultobj;
13035 fail:
13036 return NULL;
13037 }
13038
13039
13040 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13041 PyObject *resultobj = 0;
13042 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13043 double arg2 ;
13044 void *argp1 = 0 ;
13045 int res1 = 0 ;
13046 double val2 ;
13047 int ecode2 = 0 ;
13048 PyObject *swig_obj[2] ;
13049
13050 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
13051 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13052 if (!SWIG_IsOK(res1)) {
13053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13054 }
13055 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13056 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
13057 if (!SWIG_IsOK(ecode2)) {
13058 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
13059 }
13060 arg2 = static_cast< double >(val2);
13061 if (arg1) (arg1)->hue = arg2;
13062
13063 resultobj = SWIG_Py_Void();
13064 return resultobj;
13065 fail:
13066 return NULL;
13067 }
13068
13069
13070 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13071 PyObject *resultobj = 0;
13072 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13073 double result;
13074 void *argp1 = 0 ;
13075 int res1 = 0 ;
13076 PyObject *swig_obj[1] ;
13077
13078 if (!args) SWIG_fail;
13079 swig_obj[0] = args;
13080 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13081 if (!SWIG_IsOK(res1)) {
13082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13083 }
13084 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13085 result = (double) ((arg1)->hue);
13086 resultobj = SWIG_From_double(static_cast< double >(result));
13087 return resultobj;
13088 fail:
13089 return NULL;
13090 }
13091
13092
13093 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13094 PyObject *resultobj = 0;
13095 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13096 double arg2 ;
13097 void *argp1 = 0 ;
13098 int res1 = 0 ;
13099 double val2 ;
13100 int ecode2 = 0 ;
13101 PyObject *swig_obj[2] ;
13102
13103 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
13104 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13105 if (!SWIG_IsOK(res1)) {
13106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13107 }
13108 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13109 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
13110 if (!SWIG_IsOK(ecode2)) {
13111 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
13112 }
13113 arg2 = static_cast< double >(val2);
13114 if (arg1) (arg1)->saturation = arg2;
13115
13116 resultobj = SWIG_Py_Void();
13117 return resultobj;
13118 fail:
13119 return NULL;
13120 }
13121
13122
13123 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13124 PyObject *resultobj = 0;
13125 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13126 double result;
13127 void *argp1 = 0 ;
13128 int res1 = 0 ;
13129 PyObject *swig_obj[1] ;
13130
13131 if (!args) SWIG_fail;
13132 swig_obj[0] = args;
13133 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13134 if (!SWIG_IsOK(res1)) {
13135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13136 }
13137 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13138 result = (double) ((arg1)->saturation);
13139 resultobj = SWIG_From_double(static_cast< double >(result));
13140 return resultobj;
13141 fail:
13142 return NULL;
13143 }
13144
13145
13146 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13147 PyObject *resultobj = 0;
13148 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13149 double arg2 ;
13150 void *argp1 = 0 ;
13151 int res1 = 0 ;
13152 double val2 ;
13153 int ecode2 = 0 ;
13154 PyObject *swig_obj[2] ;
13155
13156 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
13157 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13158 if (!SWIG_IsOK(res1)) {
13159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13160 }
13161 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13162 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
13163 if (!SWIG_IsOK(ecode2)) {
13164 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
13165 }
13166 arg2 = static_cast< double >(val2);
13167 if (arg1) (arg1)->value = arg2;
13168
13169 resultobj = SWIG_Py_Void();
13170 return resultobj;
13171 fail:
13172 return NULL;
13173 }
13174
13175
13176 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13177 PyObject *resultobj = 0;
13178 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13179 double result;
13180 void *argp1 = 0 ;
13181 int res1 = 0 ;
13182 PyObject *swig_obj[1] ;
13183
13184 if (!args) SWIG_fail;
13185 swig_obj[0] = args;
13186 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13187 if (!SWIG_IsOK(res1)) {
13188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13189 }
13190 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13191 result = (double) ((arg1)->value);
13192 resultobj = SWIG_From_double(static_cast< double >(result));
13193 return resultobj;
13194 fail:
13195 return NULL;
13196 }
13197
13198
13199 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13200 PyObject *obj;
13201 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13202 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
13203 return SWIG_Py_Void();
13204 }
13205
13206 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13207 return SWIG_Python_InitShadowInstance(args);
13208 }
13209
13210 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13211 PyObject *resultobj = 0;
13212 wxString *arg1 = 0 ;
13213 long arg2 = (long) wxBITMAP_TYPE_ANY ;
13214 int arg3 = (int) -1 ;
13215 wxImage *result = 0 ;
13216 bool temp1 = false ;
13217 long val2 ;
13218 int ecode2 = 0 ;
13219 int val3 ;
13220 int ecode3 = 0 ;
13221 PyObject * obj0 = 0 ;
13222 PyObject * obj1 = 0 ;
13223 PyObject * obj2 = 0 ;
13224 char * kwnames[] = {
13225 (char *) "name",(char *) "type",(char *) "index", NULL
13226 };
13227
13228 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13229 {
13230 arg1 = wxString_in_helper(obj0);
13231 if (arg1 == NULL) SWIG_fail;
13232 temp1 = true;
13233 }
13234 if (obj1) {
13235 ecode2 = SWIG_AsVal_long(obj1, &val2);
13236 if (!SWIG_IsOK(ecode2)) {
13237 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
13238 }
13239 arg2 = static_cast< long >(val2);
13240 }
13241 if (obj2) {
13242 ecode3 = SWIG_AsVal_int(obj2, &val3);
13243 if (!SWIG_IsOK(ecode3)) {
13244 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
13245 }
13246 arg3 = static_cast< int >(val3);
13247 }
13248 {
13249 PyThreadState* __tstate = wxPyBeginAllowThreads();
13250 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
13251 wxPyEndAllowThreads(__tstate);
13252 if (PyErr_Occurred()) SWIG_fail;
13253 }
13254 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
13255 {
13256 if (temp1)
13257 delete arg1;
13258 }
13259 return resultobj;
13260 fail:
13261 {
13262 if (temp1)
13263 delete arg1;
13264 }
13265 return NULL;
13266 }
13267
13268
13269 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13270 PyObject *resultobj = 0;
13271 wxImage *arg1 = (wxImage *) 0 ;
13272 void *argp1 = 0 ;
13273 int res1 = 0 ;
13274 PyObject *swig_obj[1] ;
13275
13276 if (!args) SWIG_fail;
13277 swig_obj[0] = args;
13278 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
13279 if (!SWIG_IsOK(res1)) {
13280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
13281 }
13282 arg1 = reinterpret_cast< wxImage * >(argp1);
13283 {
13284 PyThreadState* __tstate = wxPyBeginAllowThreads();
13285 delete arg1;
13286
13287 wxPyEndAllowThreads(__tstate);
13288 if (PyErr_Occurred()) SWIG_fail;
13289 }
13290 resultobj = SWIG_Py_Void();
13291 return resultobj;
13292 fail:
13293 return NULL;
13294 }
13295
13296
13297 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13298 PyObject *resultobj = 0;
13299 wxString *arg1 = 0 ;
13300 wxString *arg2 = 0 ;
13301 int arg3 = (int) -1 ;
13302 wxImage *result = 0 ;
13303 bool temp1 = false ;
13304 bool temp2 = false ;
13305 int val3 ;
13306 int ecode3 = 0 ;
13307 PyObject * obj0 = 0 ;
13308 PyObject * obj1 = 0 ;
13309 PyObject * obj2 = 0 ;
13310 char * kwnames[] = {
13311 (char *) "name",(char *) "mimetype",(char *) "index", NULL
13312 };
13313
13314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13315 {
13316 arg1 = wxString_in_helper(obj0);
13317 if (arg1 == NULL) SWIG_fail;
13318 temp1 = true;
13319 }
13320 {
13321 arg2 = wxString_in_helper(obj1);
13322 if (arg2 == NULL) SWIG_fail;
13323 temp2 = true;
13324 }
13325 if (obj2) {
13326 ecode3 = SWIG_AsVal_int(obj2, &val3);
13327 if (!SWIG_IsOK(ecode3)) {
13328 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
13329 }
13330 arg3 = static_cast< int >(val3);
13331 }
13332 {
13333 PyThreadState* __tstate = wxPyBeginAllowThreads();
13334 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
13335 wxPyEndAllowThreads(__tstate);
13336 if (PyErr_Occurred()) SWIG_fail;
13337 }
13338 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13339 {
13340 if (temp1)
13341 delete arg1;
13342 }
13343 {
13344 if (temp2)
13345 delete arg2;
13346 }
13347 return resultobj;
13348 fail:
13349 {
13350 if (temp1)
13351 delete arg1;
13352 }
13353 {
13354 if (temp2)
13355 delete arg2;
13356 }
13357 return NULL;
13358 }
13359
13360
13361 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13362 PyObject *resultobj = 0;
13363 wxInputStream *arg1 = 0 ;
13364 long arg2 = (long) wxBITMAP_TYPE_ANY ;
13365 int arg3 = (int) -1 ;
13366 wxImage *result = 0 ;
13367 wxPyInputStream *temp1 ;
13368 bool created1 ;
13369 long val2 ;
13370 int ecode2 = 0 ;
13371 int val3 ;
13372 int ecode3 = 0 ;
13373 PyObject * obj0 = 0 ;
13374 PyObject * obj1 = 0 ;
13375 PyObject * obj2 = 0 ;
13376 char * kwnames[] = {
13377 (char *) "stream",(char *) "type",(char *) "index", NULL
13378 };
13379
13380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13381 {
13382 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13383 arg1 = temp1->m_wxis;
13384 created1 = false;
13385 } else {
13386 PyErr_Clear(); // clear the failure of the wxPyConvert above
13387 arg1 = wxPyCBInputStream_create(obj0, false);
13388 if (arg1 == NULL) {
13389 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13390 SWIG_fail;
13391 }
13392 created1 = true;
13393 }
13394 }
13395 if (obj1) {
13396 ecode2 = SWIG_AsVal_long(obj1, &val2);
13397 if (!SWIG_IsOK(ecode2)) {
13398 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
13399 }
13400 arg2 = static_cast< long >(val2);
13401 }
13402 if (obj2) {
13403 ecode3 = SWIG_AsVal_int(obj2, &val3);
13404 if (!SWIG_IsOK(ecode3)) {
13405 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
13406 }
13407 arg3 = static_cast< int >(val3);
13408 }
13409 {
13410 PyThreadState* __tstate = wxPyBeginAllowThreads();
13411 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
13412 wxPyEndAllowThreads(__tstate);
13413 if (PyErr_Occurred()) SWIG_fail;
13414 }
13415 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13416 {
13417 if (created1) delete arg1;
13418 }
13419 return resultobj;
13420 fail:
13421 {
13422 if (created1) delete arg1;
13423 }
13424 return NULL;
13425 }
13426
13427
13428 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13429 PyObject *resultobj = 0;
13430 wxInputStream *arg1 = 0 ;
13431 wxString *arg2 = 0 ;
13432 int arg3 = (int) -1 ;
13433 wxImage *result = 0 ;
13434 wxPyInputStream *temp1 ;
13435 bool created1 ;
13436 bool temp2 = false ;
13437 int val3 ;
13438 int ecode3 = 0 ;
13439 PyObject * obj0 = 0 ;
13440 PyObject * obj1 = 0 ;
13441 PyObject * obj2 = 0 ;
13442 char * kwnames[] = {
13443 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
13444 };
13445
13446 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13447 {
13448 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13449 arg1 = temp1->m_wxis;
13450 created1 = false;
13451 } else {
13452 PyErr_Clear(); // clear the failure of the wxPyConvert above
13453 arg1 = wxPyCBInputStream_create(obj0, false);
13454 if (arg1 == NULL) {
13455 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13456 SWIG_fail;
13457 }
13458 created1 = true;
13459 }
13460 }
13461 {
13462 arg2 = wxString_in_helper(obj1);
13463 if (arg2 == NULL) SWIG_fail;
13464 temp2 = true;
13465 }
13466 if (obj2) {
13467 ecode3 = SWIG_AsVal_int(obj2, &val3);
13468 if (!SWIG_IsOK(ecode3)) {
13469 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
13470 }
13471 arg3 = static_cast< int >(val3);
13472 }
13473 {
13474 PyThreadState* __tstate = wxPyBeginAllowThreads();
13475 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
13476 wxPyEndAllowThreads(__tstate);
13477 if (PyErr_Occurred()) SWIG_fail;
13478 }
13479 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13480 {
13481 if (created1) delete arg1;
13482 }
13483 {
13484 if (temp2)
13485 delete arg2;
13486 }
13487 return resultobj;
13488 fail:
13489 {
13490 if (created1) delete arg1;
13491 }
13492 {
13493 if (temp2)
13494 delete arg2;
13495 }
13496 return NULL;
13497 }
13498
13499
13500 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13501 PyObject *resultobj = 0;
13502 int arg1 = (int) 0 ;
13503 int arg2 = (int) 0 ;
13504 bool arg3 = (bool) true ;
13505 wxImage *result = 0 ;
13506 int val1 ;
13507 int ecode1 = 0 ;
13508 int val2 ;
13509 int ecode2 = 0 ;
13510 bool val3 ;
13511 int ecode3 = 0 ;
13512 PyObject * obj0 = 0 ;
13513 PyObject * obj1 = 0 ;
13514 PyObject * obj2 = 0 ;
13515 char * kwnames[] = {
13516 (char *) "width",(char *) "height",(char *) "clear", NULL
13517 };
13518
13519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13520 if (obj0) {
13521 ecode1 = SWIG_AsVal_int(obj0, &val1);
13522 if (!SWIG_IsOK(ecode1)) {
13523 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
13524 }
13525 arg1 = static_cast< int >(val1);
13526 }
13527 if (obj1) {
13528 ecode2 = SWIG_AsVal_int(obj1, &val2);
13529 if (!SWIG_IsOK(ecode2)) {
13530 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
13531 }
13532 arg2 = static_cast< int >(val2);
13533 }
13534 if (obj2) {
13535 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13536 if (!SWIG_IsOK(ecode3)) {
13537 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
13538 }
13539 arg3 = static_cast< bool >(val3);
13540 }
13541 {
13542 PyThreadState* __tstate = wxPyBeginAllowThreads();
13543 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
13544 wxPyEndAllowThreads(__tstate);
13545 if (PyErr_Occurred()) SWIG_fail;
13546 }
13547 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13548 return resultobj;
13549 fail:
13550 return NULL;
13551 }
13552
13553
13554 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13555 PyObject *resultobj = 0;
13556 wxBitmap *arg1 = 0 ;
13557 wxImage *result = 0 ;
13558 void *argp1 = 0 ;
13559 int res1 = 0 ;
13560 PyObject * obj0 = 0 ;
13561 char * kwnames[] = {
13562 (char *) "bitmap", NULL
13563 };
13564
13565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
13566 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
13567 if (!SWIG_IsOK(res1)) {
13568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13569 }
13570 if (!argp1) {
13571 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13572 }
13573 arg1 = reinterpret_cast< wxBitmap * >(argp1);
13574 {
13575 if (!wxPyCheckForApp()) SWIG_fail;
13576 PyThreadState* __tstate = wxPyBeginAllowThreads();
13577 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
13578 wxPyEndAllowThreads(__tstate);
13579 if (PyErr_Occurred()) SWIG_fail;
13580 }
13581 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13582 return resultobj;
13583 fail:
13584 return NULL;
13585 }
13586
13587
13588 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13589 PyObject *resultobj = 0;
13590 int arg1 ;
13591 int arg2 ;
13592 buffer arg3 ;
13593 int arg4 ;
13594 wxImage *result = 0 ;
13595 int val1 ;
13596 int ecode1 = 0 ;
13597 int val2 ;
13598 int ecode2 = 0 ;
13599 Py_ssize_t temp3 ;
13600 PyObject * obj0 = 0 ;
13601 PyObject * obj1 = 0 ;
13602 PyObject * obj2 = 0 ;
13603 char * kwnames[] = {
13604 (char *) "width",(char *) "height",(char *) "data", NULL
13605 };
13606
13607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13608 ecode1 = SWIG_AsVal_int(obj0, &val1);
13609 if (!SWIG_IsOK(ecode1)) {
13610 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
13611 }
13612 arg1 = static_cast< int >(val1);
13613 ecode2 = SWIG_AsVal_int(obj1, &val2);
13614 if (!SWIG_IsOK(ecode2)) {
13615 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
13616 }
13617 arg2 = static_cast< int >(val2);
13618 {
13619 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
13620 arg4 = (int)temp3;
13621 }
13622 {
13623 PyThreadState* __tstate = wxPyBeginAllowThreads();
13624 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
13625 wxPyEndAllowThreads(__tstate);
13626 if (PyErr_Occurred()) SWIG_fail;
13627 }
13628 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13629 return resultobj;
13630 fail:
13631 return NULL;
13632 }
13633
13634
13635 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13636 PyObject *resultobj = 0;
13637 int arg1 ;
13638 int arg2 ;
13639 buffer arg3 ;
13640 int arg4 ;
13641 buffer arg5 ;
13642 int arg6 ;
13643 wxImage *result = 0 ;
13644 int val1 ;
13645 int ecode1 = 0 ;
13646 int val2 ;
13647 int ecode2 = 0 ;
13648 Py_ssize_t temp3 ;
13649 Py_ssize_t temp5 ;
13650 PyObject * obj0 = 0 ;
13651 PyObject * obj1 = 0 ;
13652 PyObject * obj2 = 0 ;
13653 PyObject * obj3 = 0 ;
13654 char * kwnames[] = {
13655 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
13656 };
13657
13658 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13659 ecode1 = SWIG_AsVal_int(obj0, &val1);
13660 if (!SWIG_IsOK(ecode1)) {
13661 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
13662 }
13663 arg1 = static_cast< int >(val1);
13664 ecode2 = SWIG_AsVal_int(obj1, &val2);
13665 if (!SWIG_IsOK(ecode2)) {
13666 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
13667 }
13668 arg2 = static_cast< int >(val2);
13669 {
13670 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
13671 arg4 = (int)temp3;
13672 }
13673 {
13674 if (obj3 != Py_None) {
13675 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
13676 arg6 = (int)temp5;
13677 }
13678 }
13679 {
13680 PyThreadState* __tstate = wxPyBeginAllowThreads();
13681 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
13682 wxPyEndAllowThreads(__tstate);
13683 if (PyErr_Occurred()) SWIG_fail;
13684 }
13685 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13686 return resultobj;
13687 fail:
13688 return NULL;
13689 }
13690
13691
13692 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13693 PyObject *resultobj = 0;
13694 wxImage *arg1 = (wxImage *) 0 ;
13695 int arg2 ;
13696 int arg3 ;
13697 bool arg4 = (bool) true ;
13698 void *argp1 = 0 ;
13699 int res1 = 0 ;
13700 int val2 ;
13701 int ecode2 = 0 ;
13702 int val3 ;
13703 int ecode3 = 0 ;
13704 bool val4 ;
13705 int ecode4 = 0 ;
13706 PyObject * obj0 = 0 ;
13707 PyObject * obj1 = 0 ;
13708 PyObject * obj2 = 0 ;
13709 PyObject * obj3 = 0 ;
13710 char * kwnames[] = {
13711 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
13712 };
13713
13714 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13715 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13716 if (!SWIG_IsOK(res1)) {
13717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
13718 }
13719 arg1 = reinterpret_cast< wxImage * >(argp1);
13720 ecode2 = SWIG_AsVal_int(obj1, &val2);
13721 if (!SWIG_IsOK(ecode2)) {
13722 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
13723 }
13724 arg2 = static_cast< int >(val2);
13725 ecode3 = SWIG_AsVal_int(obj2, &val3);
13726 if (!SWIG_IsOK(ecode3)) {
13727 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
13728 }
13729 arg3 = static_cast< int >(val3);
13730 if (obj3) {
13731 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13732 if (!SWIG_IsOK(ecode4)) {
13733 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
13734 }
13735 arg4 = static_cast< bool >(val4);
13736 }
13737 {
13738 PyThreadState* __tstate = wxPyBeginAllowThreads();
13739 (arg1)->Create(arg2,arg3,arg4);
13740 wxPyEndAllowThreads(__tstate);
13741 if (PyErr_Occurred()) SWIG_fail;
13742 }
13743 resultobj = SWIG_Py_Void();
13744 return resultobj;
13745 fail:
13746 return NULL;
13747 }
13748
13749
13750 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13751 PyObject *resultobj = 0;
13752 wxImage *arg1 = (wxImage *) 0 ;
13753 void *argp1 = 0 ;
13754 int res1 = 0 ;
13755 PyObject *swig_obj[1] ;
13756
13757 if (!args) SWIG_fail;
13758 swig_obj[0] = args;
13759 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13760 if (!SWIG_IsOK(res1)) {
13761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
13762 }
13763 arg1 = reinterpret_cast< wxImage * >(argp1);
13764 {
13765 PyThreadState* __tstate = wxPyBeginAllowThreads();
13766 (arg1)->Destroy();
13767 wxPyEndAllowThreads(__tstate);
13768 if (PyErr_Occurred()) SWIG_fail;
13769 }
13770 resultobj = SWIG_Py_Void();
13771 return resultobj;
13772 fail:
13773 return NULL;
13774 }
13775
13776
13777 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13778 PyObject *resultobj = 0;
13779 wxImage *arg1 = (wxImage *) 0 ;
13780 int arg2 ;
13781 int arg3 ;
13782 SwigValueWrapper<wxImage > result;
13783 void *argp1 = 0 ;
13784 int res1 = 0 ;
13785 int val2 ;
13786 int ecode2 = 0 ;
13787 int val3 ;
13788 int ecode3 = 0 ;
13789 PyObject * obj0 = 0 ;
13790 PyObject * obj1 = 0 ;
13791 PyObject * obj2 = 0 ;
13792 char * kwnames[] = {
13793 (char *) "self",(char *) "width",(char *) "height", NULL
13794 };
13795
13796 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13797 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13798 if (!SWIG_IsOK(res1)) {
13799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
13800 }
13801 arg1 = reinterpret_cast< wxImage * >(argp1);
13802 ecode2 = SWIG_AsVal_int(obj1, &val2);
13803 if (!SWIG_IsOK(ecode2)) {
13804 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
13805 }
13806 arg2 = static_cast< int >(val2);
13807 ecode3 = SWIG_AsVal_int(obj2, &val3);
13808 if (!SWIG_IsOK(ecode3)) {
13809 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
13810 }
13811 arg3 = static_cast< int >(val3);
13812 {
13813 PyThreadState* __tstate = wxPyBeginAllowThreads();
13814 result = (arg1)->Scale(arg2,arg3);
13815 wxPyEndAllowThreads(__tstate);
13816 if (PyErr_Occurred()) SWIG_fail;
13817 }
13818 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13819 return resultobj;
13820 fail:
13821 return NULL;
13822 }
13823
13824
13825 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13826 PyObject *resultobj = 0;
13827 wxImage *arg1 = (wxImage *) 0 ;
13828 int arg2 ;
13829 int arg3 ;
13830 SwigValueWrapper<wxImage > result;
13831 void *argp1 = 0 ;
13832 int res1 = 0 ;
13833 int val2 ;
13834 int ecode2 = 0 ;
13835 int val3 ;
13836 int ecode3 = 0 ;
13837 PyObject * obj0 = 0 ;
13838 PyObject * obj1 = 0 ;
13839 PyObject * obj2 = 0 ;
13840 char * kwnames[] = {
13841 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
13842 };
13843
13844 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13845 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13846 if (!SWIG_IsOK(res1)) {
13847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
13848 }
13849 arg1 = reinterpret_cast< wxImage * >(argp1);
13850 ecode2 = SWIG_AsVal_int(obj1, &val2);
13851 if (!SWIG_IsOK(ecode2)) {
13852 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
13853 }
13854 arg2 = static_cast< int >(val2);
13855 ecode3 = SWIG_AsVal_int(obj2, &val3);
13856 if (!SWIG_IsOK(ecode3)) {
13857 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
13858 }
13859 arg3 = static_cast< int >(val3);
13860 {
13861 PyThreadState* __tstate = wxPyBeginAllowThreads();
13862 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
13863 wxPyEndAllowThreads(__tstate);
13864 if (PyErr_Occurred()) SWIG_fail;
13865 }
13866 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13867 return resultobj;
13868 fail:
13869 return NULL;
13870 }
13871
13872
13873 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13874 PyObject *resultobj = 0;
13875 wxImage *arg1 = (wxImage *) 0 ;
13876 int arg2 ;
13877 int arg3 ;
13878 wxImage *result = 0 ;
13879 void *argp1 = 0 ;
13880 int res1 = 0 ;
13881 int val2 ;
13882 int ecode2 = 0 ;
13883 int val3 ;
13884 int ecode3 = 0 ;
13885 PyObject * obj0 = 0 ;
13886 PyObject * obj1 = 0 ;
13887 PyObject * obj2 = 0 ;
13888 char * kwnames[] = {
13889 (char *) "self",(char *) "width",(char *) "height", NULL
13890 };
13891
13892 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13893 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13894 if (!SWIG_IsOK(res1)) {
13895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
13896 }
13897 arg1 = reinterpret_cast< wxImage * >(argp1);
13898 ecode2 = SWIG_AsVal_int(obj1, &val2);
13899 if (!SWIG_IsOK(ecode2)) {
13900 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
13901 }
13902 arg2 = static_cast< int >(val2);
13903 ecode3 = SWIG_AsVal_int(obj2, &val3);
13904 if (!SWIG_IsOK(ecode3)) {
13905 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
13906 }
13907 arg3 = static_cast< int >(val3);
13908 {
13909 PyThreadState* __tstate = wxPyBeginAllowThreads();
13910 {
13911 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
13912 result = (wxImage *) &_result_ref;
13913 }
13914 wxPyEndAllowThreads(__tstate);
13915 if (PyErr_Occurred()) SWIG_fail;
13916 }
13917 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13918 return resultobj;
13919 fail:
13920 return NULL;
13921 }
13922
13923
13924 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13925 PyObject *resultobj = 0;
13926 wxImage *arg1 = (wxImage *) 0 ;
13927 wxSize *arg2 = 0 ;
13928 wxPoint *arg3 = 0 ;
13929 int arg4 = (int) -1 ;
13930 int arg5 = (int) -1 ;
13931 int arg6 = (int) -1 ;
13932 wxImage *result = 0 ;
13933 void *argp1 = 0 ;
13934 int res1 = 0 ;
13935 wxSize temp2 ;
13936 wxPoint temp3 ;
13937 int val4 ;
13938 int ecode4 = 0 ;
13939 int val5 ;
13940 int ecode5 = 0 ;
13941 int val6 ;
13942 int ecode6 = 0 ;
13943 PyObject * obj0 = 0 ;
13944 PyObject * obj1 = 0 ;
13945 PyObject * obj2 = 0 ;
13946 PyObject * obj3 = 0 ;
13947 PyObject * obj4 = 0 ;
13948 PyObject * obj5 = 0 ;
13949 char * kwnames[] = {
13950 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
13951 };
13952
13953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13955 if (!SWIG_IsOK(res1)) {
13956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
13957 }
13958 arg1 = reinterpret_cast< wxImage * >(argp1);
13959 {
13960 arg2 = &temp2;
13961 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
13962 }
13963 {
13964 arg3 = &temp3;
13965 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13966 }
13967 if (obj3) {
13968 ecode4 = SWIG_AsVal_int(obj3, &val4);
13969 if (!SWIG_IsOK(ecode4)) {
13970 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
13971 }
13972 arg4 = static_cast< int >(val4);
13973 }
13974 if (obj4) {
13975 ecode5 = SWIG_AsVal_int(obj4, &val5);
13976 if (!SWIG_IsOK(ecode5)) {
13977 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
13978 }
13979 arg5 = static_cast< int >(val5);
13980 }
13981 if (obj5) {
13982 ecode6 = SWIG_AsVal_int(obj5, &val6);
13983 if (!SWIG_IsOK(ecode6)) {
13984 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
13985 }
13986 arg6 = static_cast< int >(val6);
13987 }
13988 {
13989 PyThreadState* __tstate = wxPyBeginAllowThreads();
13990 {
13991 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
13992 result = (wxImage *) &_result_ref;
13993 }
13994 wxPyEndAllowThreads(__tstate);
13995 if (PyErr_Occurred()) SWIG_fail;
13996 }
13997 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13998 return resultobj;
13999 fail:
14000 return NULL;
14001 }
14002
14003
14004 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14005 PyObject *resultobj = 0;
14006 wxImage *arg1 = (wxImage *) 0 ;
14007 int arg2 ;
14008 int arg3 ;
14009 byte arg4 ;
14010 byte arg5 ;
14011 byte arg6 ;
14012 void *argp1 = 0 ;
14013 int res1 = 0 ;
14014 int val2 ;
14015 int ecode2 = 0 ;
14016 int val3 ;
14017 int ecode3 = 0 ;
14018 unsigned char val4 ;
14019 int ecode4 = 0 ;
14020 unsigned char val5 ;
14021 int ecode5 = 0 ;
14022 unsigned char val6 ;
14023 int ecode6 = 0 ;
14024 PyObject * obj0 = 0 ;
14025 PyObject * obj1 = 0 ;
14026 PyObject * obj2 = 0 ;
14027 PyObject * obj3 = 0 ;
14028 PyObject * obj4 = 0 ;
14029 PyObject * obj5 = 0 ;
14030 char * kwnames[] = {
14031 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
14032 };
14033
14034 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
14035 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14036 if (!SWIG_IsOK(res1)) {
14037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
14038 }
14039 arg1 = reinterpret_cast< wxImage * >(argp1);
14040 ecode2 = SWIG_AsVal_int(obj1, &val2);
14041 if (!SWIG_IsOK(ecode2)) {
14042 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
14043 }
14044 arg2 = static_cast< int >(val2);
14045 ecode3 = SWIG_AsVal_int(obj2, &val3);
14046 if (!SWIG_IsOK(ecode3)) {
14047 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
14048 }
14049 arg3 = static_cast< int >(val3);
14050 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14051 if (!SWIG_IsOK(ecode4)) {
14052 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
14053 }
14054 arg4 = static_cast< byte >(val4);
14055 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
14056 if (!SWIG_IsOK(ecode5)) {
14057 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
14058 }
14059 arg5 = static_cast< byte >(val5);
14060 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
14061 if (!SWIG_IsOK(ecode6)) {
14062 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
14063 }
14064 arg6 = static_cast< byte >(val6);
14065 {
14066 PyThreadState* __tstate = wxPyBeginAllowThreads();
14067 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
14068 wxPyEndAllowThreads(__tstate);
14069 if (PyErr_Occurred()) SWIG_fail;
14070 }
14071 resultobj = SWIG_Py_Void();
14072 return resultobj;
14073 fail:
14074 return NULL;
14075 }
14076
14077
14078 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14079 PyObject *resultobj = 0;
14080 wxImage *arg1 = (wxImage *) 0 ;
14081 wxRect *arg2 = 0 ;
14082 byte arg3 ;
14083 byte arg4 ;
14084 byte arg5 ;
14085 void *argp1 = 0 ;
14086 int res1 = 0 ;
14087 wxRect temp2 ;
14088 unsigned char val3 ;
14089 int ecode3 = 0 ;
14090 unsigned char val4 ;
14091 int ecode4 = 0 ;
14092 unsigned char val5 ;
14093 int ecode5 = 0 ;
14094 PyObject * obj0 = 0 ;
14095 PyObject * obj1 = 0 ;
14096 PyObject * obj2 = 0 ;
14097 PyObject * obj3 = 0 ;
14098 PyObject * obj4 = 0 ;
14099 char * kwnames[] = {
14100 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
14101 };
14102
14103 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
14104 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14105 if (!SWIG_IsOK(res1)) {
14106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
14107 }
14108 arg1 = reinterpret_cast< wxImage * >(argp1);
14109 {
14110 arg2 = &temp2;
14111 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
14112 }
14113 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14114 if (!SWIG_IsOK(ecode3)) {
14115 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
14116 }
14117 arg3 = static_cast< byte >(val3);
14118 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14119 if (!SWIG_IsOK(ecode4)) {
14120 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
14121 }
14122 arg4 = static_cast< byte >(val4);
14123 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
14124 if (!SWIG_IsOK(ecode5)) {
14125 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
14126 }
14127 arg5 = static_cast< byte >(val5);
14128 {
14129 PyThreadState* __tstate = wxPyBeginAllowThreads();
14130 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
14131 wxPyEndAllowThreads(__tstate);
14132 if (PyErr_Occurred()) SWIG_fail;
14133 }
14134 resultobj = SWIG_Py_Void();
14135 return resultobj;
14136 fail:
14137 return NULL;
14138 }
14139
14140
14141 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14142 PyObject *resultobj = 0;
14143 wxImage *arg1 = (wxImage *) 0 ;
14144 int arg2 ;
14145 int arg3 ;
14146 byte result;
14147 void *argp1 = 0 ;
14148 int res1 = 0 ;
14149 int val2 ;
14150 int ecode2 = 0 ;
14151 int val3 ;
14152 int ecode3 = 0 ;
14153 PyObject * obj0 = 0 ;
14154 PyObject * obj1 = 0 ;
14155 PyObject * obj2 = 0 ;
14156 char * kwnames[] = {
14157 (char *) "self",(char *) "x",(char *) "y", NULL
14158 };
14159
14160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14162 if (!SWIG_IsOK(res1)) {
14163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
14164 }
14165 arg1 = reinterpret_cast< wxImage * >(argp1);
14166 ecode2 = SWIG_AsVal_int(obj1, &val2);
14167 if (!SWIG_IsOK(ecode2)) {
14168 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
14169 }
14170 arg2 = static_cast< int >(val2);
14171 ecode3 = SWIG_AsVal_int(obj2, &val3);
14172 if (!SWIG_IsOK(ecode3)) {
14173 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
14174 }
14175 arg3 = static_cast< int >(val3);
14176 {
14177 PyThreadState* __tstate = wxPyBeginAllowThreads();
14178 result = (byte)(arg1)->GetRed(arg2,arg3);
14179 wxPyEndAllowThreads(__tstate);
14180 if (PyErr_Occurred()) SWIG_fail;
14181 }
14182 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14183 return resultobj;
14184 fail:
14185 return NULL;
14186 }
14187
14188
14189 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14190 PyObject *resultobj = 0;
14191 wxImage *arg1 = (wxImage *) 0 ;
14192 int arg2 ;
14193 int arg3 ;
14194 byte result;
14195 void *argp1 = 0 ;
14196 int res1 = 0 ;
14197 int val2 ;
14198 int ecode2 = 0 ;
14199 int val3 ;
14200 int ecode3 = 0 ;
14201 PyObject * obj0 = 0 ;
14202 PyObject * obj1 = 0 ;
14203 PyObject * obj2 = 0 ;
14204 char * kwnames[] = {
14205 (char *) "self",(char *) "x",(char *) "y", NULL
14206 };
14207
14208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14209 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14210 if (!SWIG_IsOK(res1)) {
14211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
14212 }
14213 arg1 = reinterpret_cast< wxImage * >(argp1);
14214 ecode2 = SWIG_AsVal_int(obj1, &val2);
14215 if (!SWIG_IsOK(ecode2)) {
14216 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
14217 }
14218 arg2 = static_cast< int >(val2);
14219 ecode3 = SWIG_AsVal_int(obj2, &val3);
14220 if (!SWIG_IsOK(ecode3)) {
14221 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
14222 }
14223 arg3 = static_cast< int >(val3);
14224 {
14225 PyThreadState* __tstate = wxPyBeginAllowThreads();
14226 result = (byte)(arg1)->GetGreen(arg2,arg3);
14227 wxPyEndAllowThreads(__tstate);
14228 if (PyErr_Occurred()) SWIG_fail;
14229 }
14230 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14231 return resultobj;
14232 fail:
14233 return NULL;
14234 }
14235
14236
14237 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14238 PyObject *resultobj = 0;
14239 wxImage *arg1 = (wxImage *) 0 ;
14240 int arg2 ;
14241 int arg3 ;
14242 byte result;
14243 void *argp1 = 0 ;
14244 int res1 = 0 ;
14245 int val2 ;
14246 int ecode2 = 0 ;
14247 int val3 ;
14248 int ecode3 = 0 ;
14249 PyObject * obj0 = 0 ;
14250 PyObject * obj1 = 0 ;
14251 PyObject * obj2 = 0 ;
14252 char * kwnames[] = {
14253 (char *) "self",(char *) "x",(char *) "y", NULL
14254 };
14255
14256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14258 if (!SWIG_IsOK(res1)) {
14259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
14260 }
14261 arg1 = reinterpret_cast< wxImage * >(argp1);
14262 ecode2 = SWIG_AsVal_int(obj1, &val2);
14263 if (!SWIG_IsOK(ecode2)) {
14264 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
14265 }
14266 arg2 = static_cast< int >(val2);
14267 ecode3 = SWIG_AsVal_int(obj2, &val3);
14268 if (!SWIG_IsOK(ecode3)) {
14269 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
14270 }
14271 arg3 = static_cast< int >(val3);
14272 {
14273 PyThreadState* __tstate = wxPyBeginAllowThreads();
14274 result = (byte)(arg1)->GetBlue(arg2,arg3);
14275 wxPyEndAllowThreads(__tstate);
14276 if (PyErr_Occurred()) SWIG_fail;
14277 }
14278 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14279 return resultobj;
14280 fail:
14281 return NULL;
14282 }
14283
14284
14285 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14286 PyObject *resultobj = 0;
14287 wxImage *arg1 = (wxImage *) 0 ;
14288 int arg2 ;
14289 int arg3 ;
14290 byte arg4 ;
14291 void *argp1 = 0 ;
14292 int res1 = 0 ;
14293 int val2 ;
14294 int ecode2 = 0 ;
14295 int val3 ;
14296 int ecode3 = 0 ;
14297 unsigned char val4 ;
14298 int ecode4 = 0 ;
14299 PyObject * obj0 = 0 ;
14300 PyObject * obj1 = 0 ;
14301 PyObject * obj2 = 0 ;
14302 PyObject * obj3 = 0 ;
14303 char * kwnames[] = {
14304 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
14305 };
14306
14307 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14308 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14309 if (!SWIG_IsOK(res1)) {
14310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14311 }
14312 arg1 = reinterpret_cast< wxImage * >(argp1);
14313 ecode2 = SWIG_AsVal_int(obj1, &val2);
14314 if (!SWIG_IsOK(ecode2)) {
14315 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
14316 }
14317 arg2 = static_cast< int >(val2);
14318 ecode3 = SWIG_AsVal_int(obj2, &val3);
14319 if (!SWIG_IsOK(ecode3)) {
14320 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
14321 }
14322 arg3 = static_cast< int >(val3);
14323 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14324 if (!SWIG_IsOK(ecode4)) {
14325 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
14326 }
14327 arg4 = static_cast< byte >(val4);
14328 {
14329 PyThreadState* __tstate = wxPyBeginAllowThreads();
14330 (arg1)->SetAlpha(arg2,arg3,arg4);
14331 wxPyEndAllowThreads(__tstate);
14332 if (PyErr_Occurred()) SWIG_fail;
14333 }
14334 resultobj = SWIG_Py_Void();
14335 return resultobj;
14336 fail:
14337 return NULL;
14338 }
14339
14340
14341 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14342 PyObject *resultobj = 0;
14343 wxImage *arg1 = (wxImage *) 0 ;
14344 int arg2 ;
14345 int arg3 ;
14346 byte result;
14347 void *argp1 = 0 ;
14348 int res1 = 0 ;
14349 int val2 ;
14350 int ecode2 = 0 ;
14351 int val3 ;
14352 int ecode3 = 0 ;
14353 PyObject * obj0 = 0 ;
14354 PyObject * obj1 = 0 ;
14355 PyObject * obj2 = 0 ;
14356 char * kwnames[] = {
14357 (char *) "self",(char *) "x",(char *) "y", NULL
14358 };
14359
14360 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14361 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14362 if (!SWIG_IsOK(res1)) {
14363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14364 }
14365 arg1 = reinterpret_cast< wxImage * >(argp1);
14366 ecode2 = SWIG_AsVal_int(obj1, &val2);
14367 if (!SWIG_IsOK(ecode2)) {
14368 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
14369 }
14370 arg2 = static_cast< int >(val2);
14371 ecode3 = SWIG_AsVal_int(obj2, &val3);
14372 if (!SWIG_IsOK(ecode3)) {
14373 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
14374 }
14375 arg3 = static_cast< int >(val3);
14376 {
14377 PyThreadState* __tstate = wxPyBeginAllowThreads();
14378 result = (byte)(arg1)->GetAlpha(arg2,arg3);
14379 wxPyEndAllowThreads(__tstate);
14380 if (PyErr_Occurred()) SWIG_fail;
14381 }
14382 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14383 return resultobj;
14384 fail:
14385 return NULL;
14386 }
14387
14388
14389 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14390 PyObject *resultobj = 0;
14391 wxImage *arg1 = (wxImage *) 0 ;
14392 bool result;
14393 void *argp1 = 0 ;
14394 int res1 = 0 ;
14395 PyObject *swig_obj[1] ;
14396
14397 if (!args) SWIG_fail;
14398 swig_obj[0] = args;
14399 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14400 if (!SWIG_IsOK(res1)) {
14401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14402 }
14403 arg1 = reinterpret_cast< wxImage * >(argp1);
14404 {
14405 PyThreadState* __tstate = wxPyBeginAllowThreads();
14406 result = (bool)(arg1)->HasAlpha();
14407 wxPyEndAllowThreads(__tstate);
14408 if (PyErr_Occurred()) SWIG_fail;
14409 }
14410 {
14411 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14412 }
14413 return resultobj;
14414 fail:
14415 return NULL;
14416 }
14417
14418
14419 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14420 PyObject *resultobj = 0;
14421 wxImage *arg1 = (wxImage *) 0 ;
14422 void *argp1 = 0 ;
14423 int res1 = 0 ;
14424 PyObject *swig_obj[1] ;
14425
14426 if (!args) SWIG_fail;
14427 swig_obj[0] = args;
14428 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14429 if (!SWIG_IsOK(res1)) {
14430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14431 }
14432 arg1 = reinterpret_cast< wxImage * >(argp1);
14433 {
14434 PyThreadState* __tstate = wxPyBeginAllowThreads();
14435 (arg1)->InitAlpha();
14436 wxPyEndAllowThreads(__tstate);
14437 if (PyErr_Occurred()) SWIG_fail;
14438 }
14439 resultobj = SWIG_Py_Void();
14440 return resultobj;
14441 fail:
14442 return NULL;
14443 }
14444
14445
14446 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14447 PyObject *resultobj = 0;
14448 wxImage *arg1 = (wxImage *) 0 ;
14449 int arg2 ;
14450 int arg3 ;
14451 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14452 bool result;
14453 void *argp1 = 0 ;
14454 int res1 = 0 ;
14455 int val2 ;
14456 int ecode2 = 0 ;
14457 int val3 ;
14458 int ecode3 = 0 ;
14459 unsigned char val4 ;
14460 int ecode4 = 0 ;
14461 PyObject * obj0 = 0 ;
14462 PyObject * obj1 = 0 ;
14463 PyObject * obj2 = 0 ;
14464 PyObject * obj3 = 0 ;
14465 char * kwnames[] = {
14466 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
14467 };
14468
14469 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14470 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14471 if (!SWIG_IsOK(res1)) {
14472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
14473 }
14474 arg1 = reinterpret_cast< wxImage * >(argp1);
14475 ecode2 = SWIG_AsVal_int(obj1, &val2);
14476 if (!SWIG_IsOK(ecode2)) {
14477 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
14478 }
14479 arg2 = static_cast< int >(val2);
14480 ecode3 = SWIG_AsVal_int(obj2, &val3);
14481 if (!SWIG_IsOK(ecode3)) {
14482 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
14483 }
14484 arg3 = static_cast< int >(val3);
14485 if (obj3) {
14486 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14487 if (!SWIG_IsOK(ecode4)) {
14488 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
14489 }
14490 arg4 = static_cast< byte >(val4);
14491 }
14492 {
14493 PyThreadState* __tstate = wxPyBeginAllowThreads();
14494 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
14495 wxPyEndAllowThreads(__tstate);
14496 if (PyErr_Occurred()) SWIG_fail;
14497 }
14498 {
14499 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14500 }
14501 return resultobj;
14502 fail:
14503 return NULL;
14504 }
14505
14506
14507 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14508 PyObject *resultobj = 0;
14509 wxImage *arg1 = (wxImage *) 0 ;
14510 byte *arg2 = (byte *) 0 ;
14511 byte *arg3 = (byte *) 0 ;
14512 byte *arg4 = (byte *) 0 ;
14513 byte arg5 = (byte) 0 ;
14514 byte arg6 = (byte) 0 ;
14515 byte arg7 = (byte) 0 ;
14516 bool result;
14517 void *argp1 = 0 ;
14518 int res1 = 0 ;
14519 byte temp2 ;
14520 int res2 = SWIG_TMPOBJ ;
14521 byte temp3 ;
14522 int res3 = SWIG_TMPOBJ ;
14523 byte temp4 ;
14524 int res4 = SWIG_TMPOBJ ;
14525 unsigned char val5 ;
14526 int ecode5 = 0 ;
14527 unsigned char val6 ;
14528 int ecode6 = 0 ;
14529 unsigned char val7 ;
14530 int ecode7 = 0 ;
14531 PyObject * obj0 = 0 ;
14532 PyObject * obj1 = 0 ;
14533 PyObject * obj2 = 0 ;
14534 PyObject * obj3 = 0 ;
14535 char * kwnames[] = {
14536 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14537 };
14538
14539 arg2 = &temp2;
14540 arg3 = &temp3;
14541 arg4 = &temp4;
14542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14543 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14544 if (!SWIG_IsOK(res1)) {
14545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
14546 }
14547 arg1 = reinterpret_cast< wxImage * >(argp1);
14548 if (obj1) {
14549 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14550 if (!SWIG_IsOK(ecode5)) {
14551 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14552 }
14553 arg5 = static_cast< byte >(val5);
14554 }
14555 if (obj2) {
14556 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14557 if (!SWIG_IsOK(ecode6)) {
14558 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14559 }
14560 arg6 = static_cast< byte >(val6);
14561 }
14562 if (obj3) {
14563 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14564 if (!SWIG_IsOK(ecode7)) {
14565 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14566 }
14567 arg7 = static_cast< byte >(val7);
14568 }
14569 {
14570 PyThreadState* __tstate = wxPyBeginAllowThreads();
14571 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14572 wxPyEndAllowThreads(__tstate);
14573 if (PyErr_Occurred()) SWIG_fail;
14574 }
14575 {
14576 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14577 }
14578 if (SWIG_IsTmpObj(res2)) {
14579 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14580 } else {
14581 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14582 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14583 }
14584 if (SWIG_IsTmpObj(res3)) {
14585 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14586 } else {
14587 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14588 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14589 }
14590 if (SWIG_IsTmpObj(res4)) {
14591 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14592 } else {
14593 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14594 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14595 }
14596 return resultobj;
14597 fail:
14598 return NULL;
14599 }
14600
14601
14602 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14603 PyObject *resultobj = 0;
14604 wxImage *arg1 = (wxImage *) 0 ;
14605 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14606 bool result;
14607 void *argp1 = 0 ;
14608 int res1 = 0 ;
14609 unsigned char val2 ;
14610 int ecode2 = 0 ;
14611 PyObject * obj0 = 0 ;
14612 PyObject * obj1 = 0 ;
14613 char * kwnames[] = {
14614 (char *) "self",(char *) "threshold", NULL
14615 };
14616
14617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
14618 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14619 if (!SWIG_IsOK(res1)) {
14620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
14621 }
14622 arg1 = reinterpret_cast< wxImage * >(argp1);
14623 if (obj1) {
14624 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14625 if (!SWIG_IsOK(ecode2)) {
14626 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
14627 }
14628 arg2 = static_cast< byte >(val2);
14629 }
14630 {
14631 PyThreadState* __tstate = wxPyBeginAllowThreads();
14632 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
14633 wxPyEndAllowThreads(__tstate);
14634 if (PyErr_Occurred()) SWIG_fail;
14635 }
14636 {
14637 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14638 }
14639 return resultobj;
14640 fail:
14641 return NULL;
14642 }
14643
14644
14645 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14646 PyObject *resultobj = 0;
14647 wxImage *arg1 = (wxImage *) 0 ;
14648 byte arg2 ;
14649 byte arg3 ;
14650 byte arg4 ;
14651 bool result;
14652 void *argp1 = 0 ;
14653 int res1 = 0 ;
14654 unsigned char val2 ;
14655 int ecode2 = 0 ;
14656 unsigned char val3 ;
14657 int ecode3 = 0 ;
14658 unsigned char val4 ;
14659 int ecode4 = 0 ;
14660 PyObject * obj0 = 0 ;
14661 PyObject * obj1 = 0 ;
14662 PyObject * obj2 = 0 ;
14663 PyObject * obj3 = 0 ;
14664 char * kwnames[] = {
14665 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
14666 };
14667
14668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14669 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14670 if (!SWIG_IsOK(res1)) {
14671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14672 }
14673 arg1 = reinterpret_cast< wxImage * >(argp1);
14674 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14675 if (!SWIG_IsOK(ecode2)) {
14676 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
14677 }
14678 arg2 = static_cast< byte >(val2);
14679 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14680 if (!SWIG_IsOK(ecode3)) {
14681 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
14682 }
14683 arg3 = static_cast< byte >(val3);
14684 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14685 if (!SWIG_IsOK(ecode4)) {
14686 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
14687 }
14688 arg4 = static_cast< byte >(val4);
14689 {
14690 PyThreadState* __tstate = wxPyBeginAllowThreads();
14691 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
14692 wxPyEndAllowThreads(__tstate);
14693 if (PyErr_Occurred()) SWIG_fail;
14694 }
14695 {
14696 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14697 }
14698 return resultobj;
14699 fail:
14700 return NULL;
14701 }
14702
14703
14704 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14705 PyObject *resultobj = 0;
14706 wxImage *arg1 = (wxImage *) 0 ;
14707 wxImage *arg2 = 0 ;
14708 byte arg3 ;
14709 byte arg4 ;
14710 byte arg5 ;
14711 bool result;
14712 void *argp1 = 0 ;
14713 int res1 = 0 ;
14714 void *argp2 = 0 ;
14715 int res2 = 0 ;
14716 unsigned char val3 ;
14717 int ecode3 = 0 ;
14718 unsigned char val4 ;
14719 int ecode4 = 0 ;
14720 unsigned char val5 ;
14721 int ecode5 = 0 ;
14722 PyObject * obj0 = 0 ;
14723 PyObject * obj1 = 0 ;
14724 PyObject * obj2 = 0 ;
14725 PyObject * obj3 = 0 ;
14726 PyObject * obj4 = 0 ;
14727 char * kwnames[] = {
14728 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
14729 };
14730
14731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
14732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14733 if (!SWIG_IsOK(res1)) {
14734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
14735 }
14736 arg1 = reinterpret_cast< wxImage * >(argp1);
14737 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
14738 if (!SWIG_IsOK(res2)) {
14739 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14740 }
14741 if (!argp2) {
14742 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14743 }
14744 arg2 = reinterpret_cast< wxImage * >(argp2);
14745 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14746 if (!SWIG_IsOK(ecode3)) {
14747 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
14748 }
14749 arg3 = static_cast< byte >(val3);
14750 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14751 if (!SWIG_IsOK(ecode4)) {
14752 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
14753 }
14754 arg4 = static_cast< byte >(val4);
14755 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
14756 if (!SWIG_IsOK(ecode5)) {
14757 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
14758 }
14759 arg5 = static_cast< byte >(val5);
14760 {
14761 PyThreadState* __tstate = wxPyBeginAllowThreads();
14762 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
14763 wxPyEndAllowThreads(__tstate);
14764 if (PyErr_Occurred()) SWIG_fail;
14765 }
14766 {
14767 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14768 }
14769 return resultobj;
14770 fail:
14771 return NULL;
14772 }
14773
14774
14775 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14776 PyObject *resultobj = 0;
14777 wxString *arg1 = 0 ;
14778 bool result;
14779 bool temp1 = false ;
14780 PyObject * obj0 = 0 ;
14781 char * kwnames[] = {
14782 (char *) "filename", NULL
14783 };
14784
14785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
14786 {
14787 arg1 = wxString_in_helper(obj0);
14788 if (arg1 == NULL) SWIG_fail;
14789 temp1 = true;
14790 }
14791 {
14792 PyThreadState* __tstate = wxPyBeginAllowThreads();
14793 result = (bool)wxImage::CanRead((wxString const &)*arg1);
14794 wxPyEndAllowThreads(__tstate);
14795 if (PyErr_Occurred()) SWIG_fail;
14796 }
14797 {
14798 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14799 }
14800 {
14801 if (temp1)
14802 delete arg1;
14803 }
14804 return resultobj;
14805 fail:
14806 {
14807 if (temp1)
14808 delete arg1;
14809 }
14810 return NULL;
14811 }
14812
14813
14814 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14815 PyObject *resultobj = 0;
14816 wxString *arg1 = 0 ;
14817 long arg2 = (long) wxBITMAP_TYPE_ANY ;
14818 int result;
14819 bool temp1 = false ;
14820 long val2 ;
14821 int ecode2 = 0 ;
14822 PyObject * obj0 = 0 ;
14823 PyObject * obj1 = 0 ;
14824 char * kwnames[] = {
14825 (char *) "filename",(char *) "type", NULL
14826 };
14827
14828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
14829 {
14830 arg1 = wxString_in_helper(obj0);
14831 if (arg1 == NULL) SWIG_fail;
14832 temp1 = true;
14833 }
14834 if (obj1) {
14835 ecode2 = SWIG_AsVal_long(obj1, &val2);
14836 if (!SWIG_IsOK(ecode2)) {
14837 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
14838 }
14839 arg2 = static_cast< long >(val2);
14840 }
14841 {
14842 PyThreadState* __tstate = wxPyBeginAllowThreads();
14843 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
14844 wxPyEndAllowThreads(__tstate);
14845 if (PyErr_Occurred()) SWIG_fail;
14846 }
14847 resultobj = SWIG_From_int(static_cast< int >(result));
14848 {
14849 if (temp1)
14850 delete arg1;
14851 }
14852 return resultobj;
14853 fail:
14854 {
14855 if (temp1)
14856 delete arg1;
14857 }
14858 return NULL;
14859 }
14860
14861
14862 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14863 PyObject *resultobj = 0;
14864 wxImage *arg1 = (wxImage *) 0 ;
14865 wxString *arg2 = 0 ;
14866 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14867 int arg4 = (int) -1 ;
14868 bool result;
14869 void *argp1 = 0 ;
14870 int res1 = 0 ;
14871 bool temp2 = false ;
14872 long val3 ;
14873 int ecode3 = 0 ;
14874 int val4 ;
14875 int ecode4 = 0 ;
14876 PyObject * obj0 = 0 ;
14877 PyObject * obj1 = 0 ;
14878 PyObject * obj2 = 0 ;
14879 PyObject * obj3 = 0 ;
14880 char * kwnames[] = {
14881 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
14882 };
14883
14884 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14885 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14886 if (!SWIG_IsOK(res1)) {
14887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
14888 }
14889 arg1 = reinterpret_cast< wxImage * >(argp1);
14890 {
14891 arg2 = wxString_in_helper(obj1);
14892 if (arg2 == NULL) SWIG_fail;
14893 temp2 = true;
14894 }
14895 if (obj2) {
14896 ecode3 = SWIG_AsVal_long(obj2, &val3);
14897 if (!SWIG_IsOK(ecode3)) {
14898 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
14899 }
14900 arg3 = static_cast< long >(val3);
14901 }
14902 if (obj3) {
14903 ecode4 = SWIG_AsVal_int(obj3, &val4);
14904 if (!SWIG_IsOK(ecode4)) {
14905 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
14906 }
14907 arg4 = static_cast< int >(val4);
14908 }
14909 {
14910 PyThreadState* __tstate = wxPyBeginAllowThreads();
14911 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
14912 wxPyEndAllowThreads(__tstate);
14913 if (PyErr_Occurred()) SWIG_fail;
14914 }
14915 {
14916 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14917 }
14918 {
14919 if (temp2)
14920 delete arg2;
14921 }
14922 return resultobj;
14923 fail:
14924 {
14925 if (temp2)
14926 delete arg2;
14927 }
14928 return NULL;
14929 }
14930
14931
14932 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14933 PyObject *resultobj = 0;
14934 wxImage *arg1 = (wxImage *) 0 ;
14935 wxString *arg2 = 0 ;
14936 wxString *arg3 = 0 ;
14937 int arg4 = (int) -1 ;
14938 bool result;
14939 void *argp1 = 0 ;
14940 int res1 = 0 ;
14941 bool temp2 = false ;
14942 bool temp3 = false ;
14943 int val4 ;
14944 int ecode4 = 0 ;
14945 PyObject * obj0 = 0 ;
14946 PyObject * obj1 = 0 ;
14947 PyObject * obj2 = 0 ;
14948 PyObject * obj3 = 0 ;
14949 char * kwnames[] = {
14950 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
14951 };
14952
14953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14955 if (!SWIG_IsOK(res1)) {
14956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14957 }
14958 arg1 = reinterpret_cast< wxImage * >(argp1);
14959 {
14960 arg2 = wxString_in_helper(obj1);
14961 if (arg2 == NULL) SWIG_fail;
14962 temp2 = true;
14963 }
14964 {
14965 arg3 = wxString_in_helper(obj2);
14966 if (arg3 == NULL) SWIG_fail;
14967 temp3 = true;
14968 }
14969 if (obj3) {
14970 ecode4 = SWIG_AsVal_int(obj3, &val4);
14971 if (!SWIG_IsOK(ecode4)) {
14972 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
14973 }
14974 arg4 = static_cast< int >(val4);
14975 }
14976 {
14977 PyThreadState* __tstate = wxPyBeginAllowThreads();
14978 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14979 wxPyEndAllowThreads(__tstate);
14980 if (PyErr_Occurred()) SWIG_fail;
14981 }
14982 {
14983 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14984 }
14985 {
14986 if (temp2)
14987 delete arg2;
14988 }
14989 {
14990 if (temp3)
14991 delete arg3;
14992 }
14993 return resultobj;
14994 fail:
14995 {
14996 if (temp2)
14997 delete arg2;
14998 }
14999 {
15000 if (temp3)
15001 delete arg3;
15002 }
15003 return NULL;
15004 }
15005
15006
15007 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15008 PyObject *resultobj = 0;
15009 wxImage *arg1 = (wxImage *) 0 ;
15010 wxString *arg2 = 0 ;
15011 int arg3 ;
15012 bool result;
15013 void *argp1 = 0 ;
15014 int res1 = 0 ;
15015 bool temp2 = false ;
15016 int val3 ;
15017 int ecode3 = 0 ;
15018 PyObject * obj0 = 0 ;
15019 PyObject * obj1 = 0 ;
15020 PyObject * obj2 = 0 ;
15021 char * kwnames[] = {
15022 (char *) "self",(char *) "name",(char *) "type", NULL
15023 };
15024
15025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15026 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15027 if (!SWIG_IsOK(res1)) {
15028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
15029 }
15030 arg1 = reinterpret_cast< wxImage * >(argp1);
15031 {
15032 arg2 = wxString_in_helper(obj1);
15033 if (arg2 == NULL) SWIG_fail;
15034 temp2 = true;
15035 }
15036 ecode3 = SWIG_AsVal_int(obj2, &val3);
15037 if (!SWIG_IsOK(ecode3)) {
15038 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
15039 }
15040 arg3 = static_cast< int >(val3);
15041 {
15042 PyThreadState* __tstate = wxPyBeginAllowThreads();
15043 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
15044 wxPyEndAllowThreads(__tstate);
15045 if (PyErr_Occurred()) SWIG_fail;
15046 }
15047 {
15048 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15049 }
15050 {
15051 if (temp2)
15052 delete arg2;
15053 }
15054 return resultobj;
15055 fail:
15056 {
15057 if (temp2)
15058 delete arg2;
15059 }
15060 return NULL;
15061 }
15062
15063
15064 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15065 PyObject *resultobj = 0;
15066 wxImage *arg1 = (wxImage *) 0 ;
15067 wxString *arg2 = 0 ;
15068 wxString *arg3 = 0 ;
15069 bool result;
15070 void *argp1 = 0 ;
15071 int res1 = 0 ;
15072 bool temp2 = false ;
15073 bool temp3 = false ;
15074 PyObject * obj0 = 0 ;
15075 PyObject * obj1 = 0 ;
15076 PyObject * obj2 = 0 ;
15077 char * kwnames[] = {
15078 (char *) "self",(char *) "name",(char *) "mimetype", NULL
15079 };
15080
15081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15082 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15083 if (!SWIG_IsOK(res1)) {
15084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
15085 }
15086 arg1 = reinterpret_cast< wxImage * >(argp1);
15087 {
15088 arg2 = wxString_in_helper(obj1);
15089 if (arg2 == NULL) SWIG_fail;
15090 temp2 = true;
15091 }
15092 {
15093 arg3 = wxString_in_helper(obj2);
15094 if (arg3 == NULL) SWIG_fail;
15095 temp3 = true;
15096 }
15097 {
15098 PyThreadState* __tstate = wxPyBeginAllowThreads();
15099 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
15100 wxPyEndAllowThreads(__tstate);
15101 if (PyErr_Occurred()) SWIG_fail;
15102 }
15103 {
15104 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15105 }
15106 {
15107 if (temp2)
15108 delete arg2;
15109 }
15110 {
15111 if (temp3)
15112 delete arg3;
15113 }
15114 return resultobj;
15115 fail:
15116 {
15117 if (temp2)
15118 delete arg2;
15119 }
15120 {
15121 if (temp3)
15122 delete arg3;
15123 }
15124 return NULL;
15125 }
15126
15127
15128 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15129 PyObject *resultobj = 0;
15130 wxInputStream *arg1 = 0 ;
15131 bool result;
15132 wxPyInputStream *temp1 ;
15133 bool created1 ;
15134 PyObject * obj0 = 0 ;
15135 char * kwnames[] = {
15136 (char *) "stream", NULL
15137 };
15138
15139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
15140 {
15141 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
15142 arg1 = temp1->m_wxis;
15143 created1 = false;
15144 } else {
15145 PyErr_Clear(); // clear the failure of the wxPyConvert above
15146 arg1 = wxPyCBInputStream_create(obj0, false);
15147 if (arg1 == NULL) {
15148 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15149 SWIG_fail;
15150 }
15151 created1 = true;
15152 }
15153 }
15154 {
15155 PyThreadState* __tstate = wxPyBeginAllowThreads();
15156 result = (bool)wxImage::CanRead(*arg1);
15157 wxPyEndAllowThreads(__tstate);
15158 if (PyErr_Occurred()) SWIG_fail;
15159 }
15160 {
15161 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15162 }
15163 {
15164 if (created1) delete arg1;
15165 }
15166 return resultobj;
15167 fail:
15168 {
15169 if (created1) delete arg1;
15170 }
15171 return NULL;
15172 }
15173
15174
15175 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15176 PyObject *resultobj = 0;
15177 wxImage *arg1 = (wxImage *) 0 ;
15178 wxInputStream *arg2 = 0 ;
15179 long arg3 = (long) wxBITMAP_TYPE_ANY ;
15180 int arg4 = (int) -1 ;
15181 bool result;
15182 void *argp1 = 0 ;
15183 int res1 = 0 ;
15184 wxPyInputStream *temp2 ;
15185 bool created2 ;
15186 long val3 ;
15187 int ecode3 = 0 ;
15188 int val4 ;
15189 int ecode4 = 0 ;
15190 PyObject * obj0 = 0 ;
15191 PyObject * obj1 = 0 ;
15192 PyObject * obj2 = 0 ;
15193 PyObject * obj3 = 0 ;
15194 char * kwnames[] = {
15195 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
15196 };
15197
15198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15199 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15200 if (!SWIG_IsOK(res1)) {
15201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
15202 }
15203 arg1 = reinterpret_cast< wxImage * >(argp1);
15204 {
15205 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
15206 arg2 = temp2->m_wxis;
15207 created2 = false;
15208 } else {
15209 PyErr_Clear(); // clear the failure of the wxPyConvert above
15210 arg2 = wxPyCBInputStream_create(obj1, false);
15211 if (arg2 == NULL) {
15212 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15213 SWIG_fail;
15214 }
15215 created2 = true;
15216 }
15217 }
15218 if (obj2) {
15219 ecode3 = SWIG_AsVal_long(obj2, &val3);
15220 if (!SWIG_IsOK(ecode3)) {
15221 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
15222 }
15223 arg3 = static_cast< long >(val3);
15224 }
15225 if (obj3) {
15226 ecode4 = SWIG_AsVal_int(obj3, &val4);
15227 if (!SWIG_IsOK(ecode4)) {
15228 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
15229 }
15230 arg4 = static_cast< int >(val4);
15231 }
15232 {
15233 PyThreadState* __tstate = wxPyBeginAllowThreads();
15234 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
15235 wxPyEndAllowThreads(__tstate);
15236 if (PyErr_Occurred()) SWIG_fail;
15237 }
15238 {
15239 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15240 }
15241 {
15242 if (created2) delete arg2;
15243 }
15244 return resultobj;
15245 fail:
15246 {
15247 if (created2) delete arg2;
15248 }
15249 return NULL;
15250 }
15251
15252
15253 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15254 PyObject *resultobj = 0;
15255 wxImage *arg1 = (wxImage *) 0 ;
15256 wxInputStream *arg2 = 0 ;
15257 wxString *arg3 = 0 ;
15258 int arg4 = (int) -1 ;
15259 bool result;
15260 void *argp1 = 0 ;
15261 int res1 = 0 ;
15262 wxPyInputStream *temp2 ;
15263 bool created2 ;
15264 bool temp3 = false ;
15265 int val4 ;
15266 int ecode4 = 0 ;
15267 PyObject * obj0 = 0 ;
15268 PyObject * obj1 = 0 ;
15269 PyObject * obj2 = 0 ;
15270 PyObject * obj3 = 0 ;
15271 char * kwnames[] = {
15272 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
15273 };
15274
15275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15276 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15277 if (!SWIG_IsOK(res1)) {
15278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
15279 }
15280 arg1 = reinterpret_cast< wxImage * >(argp1);
15281 {
15282 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
15283 arg2 = temp2->m_wxis;
15284 created2 = false;
15285 } else {
15286 PyErr_Clear(); // clear the failure of the wxPyConvert above
15287 arg2 = wxPyCBInputStream_create(obj1, false);
15288 if (arg2 == NULL) {
15289 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15290 SWIG_fail;
15291 }
15292 created2 = true;
15293 }
15294 }
15295 {
15296 arg3 = wxString_in_helper(obj2);
15297 if (arg3 == NULL) SWIG_fail;
15298 temp3 = true;
15299 }
15300 if (obj3) {
15301 ecode4 = SWIG_AsVal_int(obj3, &val4);
15302 if (!SWIG_IsOK(ecode4)) {
15303 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
15304 }
15305 arg4 = static_cast< int >(val4);
15306 }
15307 {
15308 PyThreadState* __tstate = wxPyBeginAllowThreads();
15309 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
15310 wxPyEndAllowThreads(__tstate);
15311 if (PyErr_Occurred()) SWIG_fail;
15312 }
15313 {
15314 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15315 }
15316 {
15317 if (created2) delete arg2;
15318 }
15319 {
15320 if (temp3)
15321 delete arg3;
15322 }
15323 return resultobj;
15324 fail:
15325 {
15326 if (created2) delete arg2;
15327 }
15328 {
15329 if (temp3)
15330 delete arg3;
15331 }
15332 return NULL;
15333 }
15334
15335
15336 SWIGINTERN PyObject *_wrap_Image_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15337 PyObject *resultobj = 0;
15338 wxImage *arg1 = (wxImage *) 0 ;
15339 bool result;
15340 void *argp1 = 0 ;
15341 int res1 = 0 ;
15342 PyObject *swig_obj[1] ;
15343
15344 if (!args) SWIG_fail;
15345 swig_obj[0] = args;
15346 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15347 if (!SWIG_IsOK(res1)) {
15348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Ok" "', expected argument " "1"" of type '" "wxImage *""'");
15349 }
15350 arg1 = reinterpret_cast< wxImage * >(argp1);
15351 {
15352 PyThreadState* __tstate = wxPyBeginAllowThreads();
15353 result = (bool)(arg1)->Ok();
15354 wxPyEndAllowThreads(__tstate);
15355 if (PyErr_Occurred()) SWIG_fail;
15356 }
15357 {
15358 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15359 }
15360 return resultobj;
15361 fail:
15362 return NULL;
15363 }
15364
15365
15366 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15367 PyObject *resultobj = 0;
15368 wxImage *arg1 = (wxImage *) 0 ;
15369 int result;
15370 void *argp1 = 0 ;
15371 int res1 = 0 ;
15372 PyObject *swig_obj[1] ;
15373
15374 if (!args) SWIG_fail;
15375 swig_obj[0] = args;
15376 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15377 if (!SWIG_IsOK(res1)) {
15378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
15379 }
15380 arg1 = reinterpret_cast< wxImage * >(argp1);
15381 {
15382 PyThreadState* __tstate = wxPyBeginAllowThreads();
15383 result = (int)(arg1)->GetWidth();
15384 wxPyEndAllowThreads(__tstate);
15385 if (PyErr_Occurred()) SWIG_fail;
15386 }
15387 resultobj = SWIG_From_int(static_cast< int >(result));
15388 return resultobj;
15389 fail:
15390 return NULL;
15391 }
15392
15393
15394 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15395 PyObject *resultobj = 0;
15396 wxImage *arg1 = (wxImage *) 0 ;
15397 int result;
15398 void *argp1 = 0 ;
15399 int res1 = 0 ;
15400 PyObject *swig_obj[1] ;
15401
15402 if (!args) SWIG_fail;
15403 swig_obj[0] = args;
15404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15405 if (!SWIG_IsOK(res1)) {
15406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
15407 }
15408 arg1 = reinterpret_cast< wxImage * >(argp1);
15409 {
15410 PyThreadState* __tstate = wxPyBeginAllowThreads();
15411 result = (int)(arg1)->GetHeight();
15412 wxPyEndAllowThreads(__tstate);
15413 if (PyErr_Occurred()) SWIG_fail;
15414 }
15415 resultobj = SWIG_From_int(static_cast< int >(result));
15416 return resultobj;
15417 fail:
15418 return NULL;
15419 }
15420
15421
15422 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15423 PyObject *resultobj = 0;
15424 wxImage *arg1 = (wxImage *) 0 ;
15425 wxSize result;
15426 void *argp1 = 0 ;
15427 int res1 = 0 ;
15428 PyObject *swig_obj[1] ;
15429
15430 if (!args) SWIG_fail;
15431 swig_obj[0] = args;
15432 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15433 if (!SWIG_IsOK(res1)) {
15434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
15435 }
15436 arg1 = reinterpret_cast< wxImage * >(argp1);
15437 {
15438 PyThreadState* __tstate = wxPyBeginAllowThreads();
15439 result = wxImage_GetSize(arg1);
15440 wxPyEndAllowThreads(__tstate);
15441 if (PyErr_Occurred()) SWIG_fail;
15442 }
15443 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
15444 return resultobj;
15445 fail:
15446 return NULL;
15447 }
15448
15449
15450 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15451 PyObject *resultobj = 0;
15452 wxImage *arg1 = (wxImage *) 0 ;
15453 wxRect *arg2 = 0 ;
15454 SwigValueWrapper<wxImage > result;
15455 void *argp1 = 0 ;
15456 int res1 = 0 ;
15457 wxRect temp2 ;
15458 PyObject * obj0 = 0 ;
15459 PyObject * obj1 = 0 ;
15460 char * kwnames[] = {
15461 (char *) "self",(char *) "rect", NULL
15462 };
15463
15464 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
15465 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15466 if (!SWIG_IsOK(res1)) {
15467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
15468 }
15469 arg1 = reinterpret_cast< wxImage * >(argp1);
15470 {
15471 arg2 = &temp2;
15472 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
15473 }
15474 {
15475 PyThreadState* __tstate = wxPyBeginAllowThreads();
15476 result = (arg1)->GetSubImage((wxRect const &)*arg2);
15477 wxPyEndAllowThreads(__tstate);
15478 if (PyErr_Occurred()) SWIG_fail;
15479 }
15480 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15481 return resultobj;
15482 fail:
15483 return NULL;
15484 }
15485
15486
15487 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15488 PyObject *resultobj = 0;
15489 wxImage *arg1 = (wxImage *) 0 ;
15490 wxSize *arg2 = 0 ;
15491 wxPoint *arg3 = 0 ;
15492 int arg4 = (int) -1 ;
15493 int arg5 = (int) -1 ;
15494 int arg6 = (int) -1 ;
15495 SwigValueWrapper<wxImage > result;
15496 void *argp1 = 0 ;
15497 int res1 = 0 ;
15498 wxSize temp2 ;
15499 wxPoint temp3 ;
15500 int val4 ;
15501 int ecode4 = 0 ;
15502 int val5 ;
15503 int ecode5 = 0 ;
15504 int val6 ;
15505 int ecode6 = 0 ;
15506 PyObject * obj0 = 0 ;
15507 PyObject * obj1 = 0 ;
15508 PyObject * obj2 = 0 ;
15509 PyObject * obj3 = 0 ;
15510 PyObject * obj4 = 0 ;
15511 PyObject * obj5 = 0 ;
15512 char * kwnames[] = {
15513 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
15514 };
15515
15516 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
15517 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15518 if (!SWIG_IsOK(res1)) {
15519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
15520 }
15521 arg1 = reinterpret_cast< wxImage * >(argp1);
15522 {
15523 arg2 = &temp2;
15524 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
15525 }
15526 {
15527 arg3 = &temp3;
15528 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15529 }
15530 if (obj3) {
15531 ecode4 = SWIG_AsVal_int(obj3, &val4);
15532 if (!SWIG_IsOK(ecode4)) {
15533 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
15534 }
15535 arg4 = static_cast< int >(val4);
15536 }
15537 if (obj4) {
15538 ecode5 = SWIG_AsVal_int(obj4, &val5);
15539 if (!SWIG_IsOK(ecode5)) {
15540 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
15541 }
15542 arg5 = static_cast< int >(val5);
15543 }
15544 if (obj5) {
15545 ecode6 = SWIG_AsVal_int(obj5, &val6);
15546 if (!SWIG_IsOK(ecode6)) {
15547 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
15548 }
15549 arg6 = static_cast< int >(val6);
15550 }
15551 {
15552 PyThreadState* __tstate = wxPyBeginAllowThreads();
15553 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
15554 wxPyEndAllowThreads(__tstate);
15555 if (PyErr_Occurred()) SWIG_fail;
15556 }
15557 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15558 return resultobj;
15559 fail:
15560 return NULL;
15561 }
15562
15563
15564 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15565 PyObject *resultobj = 0;
15566 wxImage *arg1 = (wxImage *) 0 ;
15567 SwigValueWrapper<wxImage > result;
15568 void *argp1 = 0 ;
15569 int res1 = 0 ;
15570 PyObject *swig_obj[1] ;
15571
15572 if (!args) SWIG_fail;
15573 swig_obj[0] = args;
15574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15575 if (!SWIG_IsOK(res1)) {
15576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
15577 }
15578 arg1 = reinterpret_cast< wxImage * >(argp1);
15579 {
15580 PyThreadState* __tstate = wxPyBeginAllowThreads();
15581 result = (arg1)->Copy();
15582 wxPyEndAllowThreads(__tstate);
15583 if (PyErr_Occurred()) SWIG_fail;
15584 }
15585 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15586 return resultobj;
15587 fail:
15588 return NULL;
15589 }
15590
15591
15592 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15593 PyObject *resultobj = 0;
15594 wxImage *arg1 = (wxImage *) 0 ;
15595 wxImage *arg2 = 0 ;
15596 int arg3 ;
15597 int arg4 ;
15598 void *argp1 = 0 ;
15599 int res1 = 0 ;
15600 void *argp2 = 0 ;
15601 int res2 = 0 ;
15602 int val3 ;
15603 int ecode3 = 0 ;
15604 int val4 ;
15605 int ecode4 = 0 ;
15606 PyObject * obj0 = 0 ;
15607 PyObject * obj1 = 0 ;
15608 PyObject * obj2 = 0 ;
15609 PyObject * obj3 = 0 ;
15610 char * kwnames[] = {
15611 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
15612 };
15613
15614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15615 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15616 if (!SWIG_IsOK(res1)) {
15617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
15618 }
15619 arg1 = reinterpret_cast< wxImage * >(argp1);
15620 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
15621 if (!SWIG_IsOK(res2)) {
15622 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15623 }
15624 if (!argp2) {
15625 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15626 }
15627 arg2 = reinterpret_cast< wxImage * >(argp2);
15628 ecode3 = SWIG_AsVal_int(obj2, &val3);
15629 if (!SWIG_IsOK(ecode3)) {
15630 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
15631 }
15632 arg3 = static_cast< int >(val3);
15633 ecode4 = SWIG_AsVal_int(obj3, &val4);
15634 if (!SWIG_IsOK(ecode4)) {
15635 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
15636 }
15637 arg4 = static_cast< int >(val4);
15638 {
15639 PyThreadState* __tstate = wxPyBeginAllowThreads();
15640 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
15641 wxPyEndAllowThreads(__tstate);
15642 if (PyErr_Occurred()) SWIG_fail;
15643 }
15644 resultobj = SWIG_Py_Void();
15645 return resultobj;
15646 fail:
15647 return NULL;
15648 }
15649
15650
15651 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15652 PyObject *resultobj = 0;
15653 wxImage *arg1 = (wxImage *) 0 ;
15654 PyObject *result = 0 ;
15655 void *argp1 = 0 ;
15656 int res1 = 0 ;
15657 PyObject *swig_obj[1] ;
15658
15659 if (!args) SWIG_fail;
15660 swig_obj[0] = args;
15661 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15662 if (!SWIG_IsOK(res1)) {
15663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
15664 }
15665 arg1 = reinterpret_cast< wxImage * >(argp1);
15666 {
15667 PyThreadState* __tstate = wxPyBeginAllowThreads();
15668 result = (PyObject *)wxImage_GetData(arg1);
15669 wxPyEndAllowThreads(__tstate);
15670 if (PyErr_Occurred()) SWIG_fail;
15671 }
15672 resultobj = result;
15673 return resultobj;
15674 fail:
15675 return NULL;
15676 }
15677
15678
15679 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15680 PyObject *resultobj = 0;
15681 wxImage *arg1 = (wxImage *) 0 ;
15682 buffer arg2 ;
15683 int arg3 ;
15684 void *argp1 = 0 ;
15685 int res1 = 0 ;
15686 Py_ssize_t temp2 ;
15687 PyObject * obj0 = 0 ;
15688 PyObject * obj1 = 0 ;
15689 char * kwnames[] = {
15690 (char *) "self",(char *) "data", NULL
15691 };
15692
15693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
15694 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15695 if (!SWIG_IsOK(res1)) {
15696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
15697 }
15698 arg1 = reinterpret_cast< wxImage * >(argp1);
15699 {
15700 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
15701 arg3 = (int)temp2;
15702 }
15703 {
15704 PyThreadState* __tstate = wxPyBeginAllowThreads();
15705 wxImage_SetData(arg1,arg2,arg3);
15706 wxPyEndAllowThreads(__tstate);
15707 if (PyErr_Occurred()) SWIG_fail;
15708 }
15709 resultobj = SWIG_Py_Void();
15710 return resultobj;
15711 fail:
15712 return NULL;
15713 }
15714
15715
15716 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15717 PyObject *resultobj = 0;
15718 wxImage *arg1 = (wxImage *) 0 ;
15719 PyObject *result = 0 ;
15720 void *argp1 = 0 ;
15721 int res1 = 0 ;
15722 PyObject *swig_obj[1] ;
15723
15724 if (!args) SWIG_fail;
15725 swig_obj[0] = args;
15726 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15727 if (!SWIG_IsOK(res1)) {
15728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15729 }
15730 arg1 = reinterpret_cast< wxImage * >(argp1);
15731 {
15732 PyThreadState* __tstate = wxPyBeginAllowThreads();
15733 result = (PyObject *)wxImage_GetDataBuffer(arg1);
15734 wxPyEndAllowThreads(__tstate);
15735 if (PyErr_Occurred()) SWIG_fail;
15736 }
15737 resultobj = result;
15738 return resultobj;
15739 fail:
15740 return NULL;
15741 }
15742
15743
15744 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15745 PyObject *resultobj = 0;
15746 wxImage *arg1 = (wxImage *) 0 ;
15747 buffer arg2 ;
15748 int arg3 ;
15749 void *argp1 = 0 ;
15750 int res1 = 0 ;
15751 Py_ssize_t temp2 ;
15752 PyObject * obj0 = 0 ;
15753 PyObject * obj1 = 0 ;
15754 char * kwnames[] = {
15755 (char *) "self",(char *) "data", NULL
15756 };
15757
15758 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15759 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15760 if (!SWIG_IsOK(res1)) {
15761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15762 }
15763 arg1 = reinterpret_cast< wxImage * >(argp1);
15764 {
15765 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
15766 arg3 = (int)temp2;
15767 }
15768 {
15769 PyThreadState* __tstate = wxPyBeginAllowThreads();
15770 wxImage_SetDataBuffer(arg1,arg2,arg3);
15771 wxPyEndAllowThreads(__tstate);
15772 if (PyErr_Occurred()) SWIG_fail;
15773 }
15774 resultobj = SWIG_Py_Void();
15775 return resultobj;
15776 fail:
15777 return NULL;
15778 }
15779
15780
15781 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15782 PyObject *resultobj = 0;
15783 wxImage *arg1 = (wxImage *) 0 ;
15784 PyObject *result = 0 ;
15785 void *argp1 = 0 ;
15786 int res1 = 0 ;
15787 PyObject *swig_obj[1] ;
15788
15789 if (!args) SWIG_fail;
15790 swig_obj[0] = args;
15791 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15792 if (!SWIG_IsOK(res1)) {
15793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15794 }
15795 arg1 = reinterpret_cast< wxImage * >(argp1);
15796 {
15797 PyThreadState* __tstate = wxPyBeginAllowThreads();
15798 result = (PyObject *)wxImage_GetAlphaData(arg1);
15799 wxPyEndAllowThreads(__tstate);
15800 if (PyErr_Occurred()) SWIG_fail;
15801 }
15802 resultobj = result;
15803 return resultobj;
15804 fail:
15805 return NULL;
15806 }
15807
15808
15809 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15810 PyObject *resultobj = 0;
15811 wxImage *arg1 = (wxImage *) 0 ;
15812 buffer arg2 ;
15813 int arg3 ;
15814 void *argp1 = 0 ;
15815 int res1 = 0 ;
15816 Py_ssize_t temp2 ;
15817 PyObject * obj0 = 0 ;
15818 PyObject * obj1 = 0 ;
15819 char * kwnames[] = {
15820 (char *) "self",(char *) "alpha", NULL
15821 };
15822
15823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
15824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15825 if (!SWIG_IsOK(res1)) {
15826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15827 }
15828 arg1 = reinterpret_cast< wxImage * >(argp1);
15829 {
15830 if (obj1 != Py_None) {
15831 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
15832 arg3 = (int)temp2;
15833 }
15834 }
15835 {
15836 PyThreadState* __tstate = wxPyBeginAllowThreads();
15837 wxImage_SetAlphaData(arg1,arg2,arg3);
15838 wxPyEndAllowThreads(__tstate);
15839 if (PyErr_Occurred()) SWIG_fail;
15840 }
15841 resultobj = SWIG_Py_Void();
15842 return resultobj;
15843 fail:
15844 return NULL;
15845 }
15846
15847
15848 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15849 PyObject *resultobj = 0;
15850 wxImage *arg1 = (wxImage *) 0 ;
15851 PyObject *result = 0 ;
15852 void *argp1 = 0 ;
15853 int res1 = 0 ;
15854 PyObject *swig_obj[1] ;
15855
15856 if (!args) SWIG_fail;
15857 swig_obj[0] = args;
15858 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15859 if (!SWIG_IsOK(res1)) {
15860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15861 }
15862 arg1 = reinterpret_cast< wxImage * >(argp1);
15863 {
15864 PyThreadState* __tstate = wxPyBeginAllowThreads();
15865 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
15866 wxPyEndAllowThreads(__tstate);
15867 if (PyErr_Occurred()) SWIG_fail;
15868 }
15869 resultobj = result;
15870 return resultobj;
15871 fail:
15872 return NULL;
15873 }
15874
15875
15876 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15877 PyObject *resultobj = 0;
15878 wxImage *arg1 = (wxImage *) 0 ;
15879 buffer arg2 ;
15880 int arg3 ;
15881 void *argp1 = 0 ;
15882 int res1 = 0 ;
15883 Py_ssize_t temp2 ;
15884 PyObject * obj0 = 0 ;
15885 PyObject * obj1 = 0 ;
15886 char * kwnames[] = {
15887 (char *) "self",(char *) "alpha", NULL
15888 };
15889
15890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15891 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15892 if (!SWIG_IsOK(res1)) {
15893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15894 }
15895 arg1 = reinterpret_cast< wxImage * >(argp1);
15896 {
15897 if (obj1 != Py_None) {
15898 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
15899 arg3 = (int)temp2;
15900 }
15901 }
15902 {
15903 PyThreadState* __tstate = wxPyBeginAllowThreads();
15904 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
15905 wxPyEndAllowThreads(__tstate);
15906 if (PyErr_Occurred()) SWIG_fail;
15907 }
15908 resultobj = SWIG_Py_Void();
15909 return resultobj;
15910 fail:
15911 return NULL;
15912 }
15913
15914
15915 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15916 PyObject *resultobj = 0;
15917 wxImage *arg1 = (wxImage *) 0 ;
15918 byte arg2 ;
15919 byte arg3 ;
15920 byte arg4 ;
15921 void *argp1 = 0 ;
15922 int res1 = 0 ;
15923 unsigned char val2 ;
15924 int ecode2 = 0 ;
15925 unsigned char val3 ;
15926 int ecode3 = 0 ;
15927 unsigned char val4 ;
15928 int ecode4 = 0 ;
15929 PyObject * obj0 = 0 ;
15930 PyObject * obj1 = 0 ;
15931 PyObject * obj2 = 0 ;
15932 PyObject * obj3 = 0 ;
15933 char * kwnames[] = {
15934 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
15935 };
15936
15937 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15938 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15939 if (!SWIG_IsOK(res1)) {
15940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
15941 }
15942 arg1 = reinterpret_cast< wxImage * >(argp1);
15943 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15944 if (!SWIG_IsOK(ecode2)) {
15945 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
15946 }
15947 arg2 = static_cast< byte >(val2);
15948 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15949 if (!SWIG_IsOK(ecode3)) {
15950 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
15951 }
15952 arg3 = static_cast< byte >(val3);
15953 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15954 if (!SWIG_IsOK(ecode4)) {
15955 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
15956 }
15957 arg4 = static_cast< byte >(val4);
15958 {
15959 PyThreadState* __tstate = wxPyBeginAllowThreads();
15960 (arg1)->SetMaskColour(arg2,arg3,arg4);
15961 wxPyEndAllowThreads(__tstate);
15962 if (PyErr_Occurred()) SWIG_fail;
15963 }
15964 resultobj = SWIG_Py_Void();
15965 return resultobj;
15966 fail:
15967 return NULL;
15968 }
15969
15970
15971 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15972 PyObject *resultobj = 0;
15973 wxImage *arg1 = (wxImage *) 0 ;
15974 byte *arg2 = (byte *) 0 ;
15975 byte *arg3 = (byte *) 0 ;
15976 byte *arg4 = (byte *) 0 ;
15977 void *argp1 = 0 ;
15978 int res1 = 0 ;
15979 byte temp2 ;
15980 int res2 = SWIG_TMPOBJ ;
15981 byte temp3 ;
15982 int res3 = SWIG_TMPOBJ ;
15983 byte temp4 ;
15984 int res4 = SWIG_TMPOBJ ;
15985 PyObject *swig_obj[1] ;
15986
15987 arg2 = &temp2;
15988 arg3 = &temp3;
15989 arg4 = &temp4;
15990 if (!args) SWIG_fail;
15991 swig_obj[0] = args;
15992 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15993 if (!SWIG_IsOK(res1)) {
15994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
15995 }
15996 arg1 = reinterpret_cast< wxImage * >(argp1);
15997 {
15998 PyThreadState* __tstate = wxPyBeginAllowThreads();
15999 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
16000 wxPyEndAllowThreads(__tstate);
16001 if (PyErr_Occurred()) SWIG_fail;
16002 }
16003 resultobj = SWIG_Py_Void();
16004 if (SWIG_IsTmpObj(res2)) {
16005 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
16006 } else {
16007 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16008 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
16009 }
16010 if (SWIG_IsTmpObj(res3)) {
16011 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
16012 } else {
16013 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16014 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
16015 }
16016 if (SWIG_IsTmpObj(res4)) {
16017 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
16018 } else {
16019 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16020 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
16021 }
16022 return resultobj;
16023 fail:
16024 return NULL;
16025 }
16026
16027
16028 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16029 PyObject *resultobj = 0;
16030 wxImage *arg1 = (wxImage *) 0 ;
16031 byte result;
16032 void *argp1 = 0 ;
16033 int res1 = 0 ;
16034 PyObject *swig_obj[1] ;
16035
16036 if (!args) SWIG_fail;
16037 swig_obj[0] = args;
16038 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16039 if (!SWIG_IsOK(res1)) {
16040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
16041 }
16042 arg1 = reinterpret_cast< wxImage * >(argp1);
16043 {
16044 PyThreadState* __tstate = wxPyBeginAllowThreads();
16045 result = (byte)(arg1)->GetMaskRed();
16046 wxPyEndAllowThreads(__tstate);
16047 if (PyErr_Occurred()) SWIG_fail;
16048 }
16049 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16050 return resultobj;
16051 fail:
16052 return NULL;
16053 }
16054
16055
16056 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16057 PyObject *resultobj = 0;
16058 wxImage *arg1 = (wxImage *) 0 ;
16059 byte result;
16060 void *argp1 = 0 ;
16061 int res1 = 0 ;
16062 PyObject *swig_obj[1] ;
16063
16064 if (!args) SWIG_fail;
16065 swig_obj[0] = args;
16066 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16067 if (!SWIG_IsOK(res1)) {
16068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
16069 }
16070 arg1 = reinterpret_cast< wxImage * >(argp1);
16071 {
16072 PyThreadState* __tstate = wxPyBeginAllowThreads();
16073 result = (byte)(arg1)->GetMaskGreen();
16074 wxPyEndAllowThreads(__tstate);
16075 if (PyErr_Occurred()) SWIG_fail;
16076 }
16077 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16078 return resultobj;
16079 fail:
16080 return NULL;
16081 }
16082
16083
16084 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16085 PyObject *resultobj = 0;
16086 wxImage *arg1 = (wxImage *) 0 ;
16087 byte result;
16088 void *argp1 = 0 ;
16089 int res1 = 0 ;
16090 PyObject *swig_obj[1] ;
16091
16092 if (!args) SWIG_fail;
16093 swig_obj[0] = args;
16094 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16095 if (!SWIG_IsOK(res1)) {
16096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
16097 }
16098 arg1 = reinterpret_cast< wxImage * >(argp1);
16099 {
16100 PyThreadState* __tstate = wxPyBeginAllowThreads();
16101 result = (byte)(arg1)->GetMaskBlue();
16102 wxPyEndAllowThreads(__tstate);
16103 if (PyErr_Occurred()) SWIG_fail;
16104 }
16105 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16106 return resultobj;
16107 fail:
16108 return NULL;
16109 }
16110
16111
16112 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16113 PyObject *resultobj = 0;
16114 wxImage *arg1 = (wxImage *) 0 ;
16115 bool arg2 = (bool) true ;
16116 void *argp1 = 0 ;
16117 int res1 = 0 ;
16118 bool val2 ;
16119 int ecode2 = 0 ;
16120 PyObject * obj0 = 0 ;
16121 PyObject * obj1 = 0 ;
16122 char * kwnames[] = {
16123 (char *) "self",(char *) "mask", NULL
16124 };
16125
16126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
16127 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16128 if (!SWIG_IsOK(res1)) {
16129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
16130 }
16131 arg1 = reinterpret_cast< wxImage * >(argp1);
16132 if (obj1) {
16133 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16134 if (!SWIG_IsOK(ecode2)) {
16135 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
16136 }
16137 arg2 = static_cast< bool >(val2);
16138 }
16139 {
16140 PyThreadState* __tstate = wxPyBeginAllowThreads();
16141 (arg1)->SetMask(arg2);
16142 wxPyEndAllowThreads(__tstate);
16143 if (PyErr_Occurred()) SWIG_fail;
16144 }
16145 resultobj = SWIG_Py_Void();
16146 return resultobj;
16147 fail:
16148 return NULL;
16149 }
16150
16151
16152 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16153 PyObject *resultobj = 0;
16154 wxImage *arg1 = (wxImage *) 0 ;
16155 bool result;
16156 void *argp1 = 0 ;
16157 int res1 = 0 ;
16158 PyObject *swig_obj[1] ;
16159
16160 if (!args) SWIG_fail;
16161 swig_obj[0] = args;
16162 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16163 if (!SWIG_IsOK(res1)) {
16164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
16165 }
16166 arg1 = reinterpret_cast< wxImage * >(argp1);
16167 {
16168 PyThreadState* __tstate = wxPyBeginAllowThreads();
16169 result = (bool)(arg1)->HasMask();
16170 wxPyEndAllowThreads(__tstate);
16171 if (PyErr_Occurred()) SWIG_fail;
16172 }
16173 {
16174 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16175 }
16176 return resultobj;
16177 fail:
16178 return NULL;
16179 }
16180
16181
16182 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16183 PyObject *resultobj = 0;
16184 wxImage *arg1 = (wxImage *) 0 ;
16185 double arg2 ;
16186 wxPoint *arg3 = 0 ;
16187 bool arg4 = (bool) true ;
16188 wxPoint *arg5 = (wxPoint *) NULL ;
16189 SwigValueWrapper<wxImage > result;
16190 void *argp1 = 0 ;
16191 int res1 = 0 ;
16192 double val2 ;
16193 int ecode2 = 0 ;
16194 wxPoint temp3 ;
16195 bool val4 ;
16196 int ecode4 = 0 ;
16197 void *argp5 = 0 ;
16198 int res5 = 0 ;
16199 PyObject * obj0 = 0 ;
16200 PyObject * obj1 = 0 ;
16201 PyObject * obj2 = 0 ;
16202 PyObject * obj3 = 0 ;
16203 PyObject * obj4 = 0 ;
16204 char * kwnames[] = {
16205 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
16206 };
16207
16208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
16209 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16210 if (!SWIG_IsOK(res1)) {
16211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
16212 }
16213 arg1 = reinterpret_cast< wxImage * >(argp1);
16214 ecode2 = SWIG_AsVal_double(obj1, &val2);
16215 if (!SWIG_IsOK(ecode2)) {
16216 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
16217 }
16218 arg2 = static_cast< double >(val2);
16219 {
16220 arg3 = &temp3;
16221 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
16222 }
16223 if (obj3) {
16224 ecode4 = SWIG_AsVal_bool(obj3, &val4);
16225 if (!SWIG_IsOK(ecode4)) {
16226 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
16227 }
16228 arg4 = static_cast< bool >(val4);
16229 }
16230 if (obj4) {
16231 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
16232 if (!SWIG_IsOK(res5)) {
16233 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
16234 }
16235 arg5 = reinterpret_cast< wxPoint * >(argp5);
16236 }
16237 {
16238 PyThreadState* __tstate = wxPyBeginAllowThreads();
16239 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
16240 wxPyEndAllowThreads(__tstate);
16241 if (PyErr_Occurred()) SWIG_fail;
16242 }
16243 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16244 return resultobj;
16245 fail:
16246 return NULL;
16247 }
16248
16249
16250 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16251 PyObject *resultobj = 0;
16252 wxImage *arg1 = (wxImage *) 0 ;
16253 bool arg2 = (bool) true ;
16254 SwigValueWrapper<wxImage > result;
16255 void *argp1 = 0 ;
16256 int res1 = 0 ;
16257 bool val2 ;
16258 int ecode2 = 0 ;
16259 PyObject * obj0 = 0 ;
16260 PyObject * obj1 = 0 ;
16261 char * kwnames[] = {
16262 (char *) "self",(char *) "clockwise", NULL
16263 };
16264
16265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
16266 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16267 if (!SWIG_IsOK(res1)) {
16268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
16269 }
16270 arg1 = reinterpret_cast< wxImage * >(argp1);
16271 if (obj1) {
16272 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16273 if (!SWIG_IsOK(ecode2)) {
16274 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
16275 }
16276 arg2 = static_cast< bool >(val2);
16277 }
16278 {
16279 PyThreadState* __tstate = wxPyBeginAllowThreads();
16280 result = (arg1)->Rotate90(arg2);
16281 wxPyEndAllowThreads(__tstate);
16282 if (PyErr_Occurred()) SWIG_fail;
16283 }
16284 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16285 return resultobj;
16286 fail:
16287 return NULL;
16288 }
16289
16290
16291 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16292 PyObject *resultobj = 0;
16293 wxImage *arg1 = (wxImage *) 0 ;
16294 bool arg2 = (bool) true ;
16295 SwigValueWrapper<wxImage > result;
16296 void *argp1 = 0 ;
16297 int res1 = 0 ;
16298 bool val2 ;
16299 int ecode2 = 0 ;
16300 PyObject * obj0 = 0 ;
16301 PyObject * obj1 = 0 ;
16302 char * kwnames[] = {
16303 (char *) "self",(char *) "horizontally", NULL
16304 };
16305
16306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
16307 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16308 if (!SWIG_IsOK(res1)) {
16309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
16310 }
16311 arg1 = reinterpret_cast< wxImage * >(argp1);
16312 if (obj1) {
16313 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16314 if (!SWIG_IsOK(ecode2)) {
16315 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
16316 }
16317 arg2 = static_cast< bool >(val2);
16318 }
16319 {
16320 PyThreadState* __tstate = wxPyBeginAllowThreads();
16321 result = (arg1)->Mirror(arg2);
16322 wxPyEndAllowThreads(__tstate);
16323 if (PyErr_Occurred()) SWIG_fail;
16324 }
16325 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16326 return resultobj;
16327 fail:
16328 return NULL;
16329 }
16330
16331
16332 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16333 PyObject *resultobj = 0;
16334 wxImage *arg1 = (wxImage *) 0 ;
16335 byte arg2 ;
16336 byte arg3 ;
16337 byte arg4 ;
16338 byte arg5 ;
16339 byte arg6 ;
16340 byte arg7 ;
16341 void *argp1 = 0 ;
16342 int res1 = 0 ;
16343 unsigned char val2 ;
16344 int ecode2 = 0 ;
16345 unsigned char val3 ;
16346 int ecode3 = 0 ;
16347 unsigned char val4 ;
16348 int ecode4 = 0 ;
16349 unsigned char val5 ;
16350 int ecode5 = 0 ;
16351 unsigned char val6 ;
16352 int ecode6 = 0 ;
16353 unsigned char val7 ;
16354 int ecode7 = 0 ;
16355 PyObject * obj0 = 0 ;
16356 PyObject * obj1 = 0 ;
16357 PyObject * obj2 = 0 ;
16358 PyObject * obj3 = 0 ;
16359 PyObject * obj4 = 0 ;
16360 PyObject * obj5 = 0 ;
16361 PyObject * obj6 = 0 ;
16362 char * kwnames[] = {
16363 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
16364 };
16365
16366 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
16367 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16368 if (!SWIG_IsOK(res1)) {
16369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
16370 }
16371 arg1 = reinterpret_cast< wxImage * >(argp1);
16372 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16373 if (!SWIG_IsOK(ecode2)) {
16374 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
16375 }
16376 arg2 = static_cast< byte >(val2);
16377 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16378 if (!SWIG_IsOK(ecode3)) {
16379 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
16380 }
16381 arg3 = static_cast< byte >(val3);
16382 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16383 if (!SWIG_IsOK(ecode4)) {
16384 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
16385 }
16386 arg4 = static_cast< byte >(val4);
16387 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16388 if (!SWIG_IsOK(ecode5)) {
16389 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
16390 }
16391 arg5 = static_cast< byte >(val5);
16392 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
16393 if (!SWIG_IsOK(ecode6)) {
16394 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
16395 }
16396 arg6 = static_cast< byte >(val6);
16397 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
16398 if (!SWIG_IsOK(ecode7)) {
16399 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
16400 }
16401 arg7 = static_cast< byte >(val7);
16402 {
16403 PyThreadState* __tstate = wxPyBeginAllowThreads();
16404 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
16405 wxPyEndAllowThreads(__tstate);
16406 if (PyErr_Occurred()) SWIG_fail;
16407 }
16408 resultobj = SWIG_Py_Void();
16409 return resultobj;
16410 fail:
16411 return NULL;
16412 }
16413
16414
16415 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16416 PyObject *resultobj = 0;
16417 wxImage *arg1 = (wxImage *) 0 ;
16418 double arg2 = (double) 0.299 ;
16419 double arg3 = (double) 0.587 ;
16420 double arg4 = (double) 0.114 ;
16421 SwigValueWrapper<wxImage > result;
16422 void *argp1 = 0 ;
16423 int res1 = 0 ;
16424 double val2 ;
16425 int ecode2 = 0 ;
16426 double val3 ;
16427 int ecode3 = 0 ;
16428 double val4 ;
16429 int ecode4 = 0 ;
16430 PyObject * obj0 = 0 ;
16431 PyObject * obj1 = 0 ;
16432 PyObject * obj2 = 0 ;
16433 PyObject * obj3 = 0 ;
16434 char * kwnames[] = {
16435 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
16436 };
16437
16438 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16439 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16440 if (!SWIG_IsOK(res1)) {
16441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
16442 }
16443 arg1 = reinterpret_cast< wxImage * >(argp1);
16444 if (obj1) {
16445 ecode2 = SWIG_AsVal_double(obj1, &val2);
16446 if (!SWIG_IsOK(ecode2)) {
16447 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
16448 }
16449 arg2 = static_cast< double >(val2);
16450 }
16451 if (obj2) {
16452 ecode3 = SWIG_AsVal_double(obj2, &val3);
16453 if (!SWIG_IsOK(ecode3)) {
16454 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
16455 }
16456 arg3 = static_cast< double >(val3);
16457 }
16458 if (obj3) {
16459 ecode4 = SWIG_AsVal_double(obj3, &val4);
16460 if (!SWIG_IsOK(ecode4)) {
16461 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
16462 }
16463 arg4 = static_cast< double >(val4);
16464 }
16465 {
16466 PyThreadState* __tstate = wxPyBeginAllowThreads();
16467 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
16468 wxPyEndAllowThreads(__tstate);
16469 if (PyErr_Occurred()) SWIG_fail;
16470 }
16471 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16472 return resultobj;
16473 fail:
16474 return NULL;
16475 }
16476
16477
16478 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16479 PyObject *resultobj = 0;
16480 wxImage *arg1 = (wxImage *) 0 ;
16481 byte arg2 ;
16482 byte arg3 ;
16483 byte arg4 ;
16484 SwigValueWrapper<wxImage > result;
16485 void *argp1 = 0 ;
16486 int res1 = 0 ;
16487 unsigned char val2 ;
16488 int ecode2 = 0 ;
16489 unsigned char val3 ;
16490 int ecode3 = 0 ;
16491 unsigned char val4 ;
16492 int ecode4 = 0 ;
16493 PyObject * obj0 = 0 ;
16494 PyObject * obj1 = 0 ;
16495 PyObject * obj2 = 0 ;
16496 PyObject * obj3 = 0 ;
16497 char * kwnames[] = {
16498 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
16499 };
16500
16501 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16502 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16503 if (!SWIG_IsOK(res1)) {
16504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
16505 }
16506 arg1 = reinterpret_cast< wxImage * >(argp1);
16507 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16508 if (!SWIG_IsOK(ecode2)) {
16509 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
16510 }
16511 arg2 = static_cast< byte >(val2);
16512 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16513 if (!SWIG_IsOK(ecode3)) {
16514 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
16515 }
16516 arg3 = static_cast< byte >(val3);
16517 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16518 if (!SWIG_IsOK(ecode4)) {
16519 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
16520 }
16521 arg4 = static_cast< byte >(val4);
16522 {
16523 PyThreadState* __tstate = wxPyBeginAllowThreads();
16524 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
16525 wxPyEndAllowThreads(__tstate);
16526 if (PyErr_Occurred()) SWIG_fail;
16527 }
16528 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16529 return resultobj;
16530 fail:
16531 return NULL;
16532 }
16533
16534
16535 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16536 PyObject *resultobj = 0;
16537 wxImage *arg1 = (wxImage *) 0 ;
16538 wxString *arg2 = 0 ;
16539 wxString *arg3 = 0 ;
16540 void *argp1 = 0 ;
16541 int res1 = 0 ;
16542 bool temp2 = false ;
16543 bool temp3 = false ;
16544 PyObject * obj0 = 0 ;
16545 PyObject * obj1 = 0 ;
16546 PyObject * obj2 = 0 ;
16547 char * kwnames[] = {
16548 (char *) "self",(char *) "name",(char *) "value", NULL
16549 };
16550
16551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16552 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16553 if (!SWIG_IsOK(res1)) {
16554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
16555 }
16556 arg1 = reinterpret_cast< wxImage * >(argp1);
16557 {
16558 arg2 = wxString_in_helper(obj1);
16559 if (arg2 == NULL) SWIG_fail;
16560 temp2 = true;
16561 }
16562 {
16563 arg3 = wxString_in_helper(obj2);
16564 if (arg3 == NULL) SWIG_fail;
16565 temp3 = true;
16566 }
16567 {
16568 PyThreadState* __tstate = wxPyBeginAllowThreads();
16569 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
16570 wxPyEndAllowThreads(__tstate);
16571 if (PyErr_Occurred()) SWIG_fail;
16572 }
16573 resultobj = SWIG_Py_Void();
16574 {
16575 if (temp2)
16576 delete arg2;
16577 }
16578 {
16579 if (temp3)
16580 delete arg3;
16581 }
16582 return resultobj;
16583 fail:
16584 {
16585 if (temp2)
16586 delete arg2;
16587 }
16588 {
16589 if (temp3)
16590 delete arg3;
16591 }
16592 return NULL;
16593 }
16594
16595
16596 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16597 PyObject *resultobj = 0;
16598 wxImage *arg1 = (wxImage *) 0 ;
16599 wxString *arg2 = 0 ;
16600 int arg3 ;
16601 void *argp1 = 0 ;
16602 int res1 = 0 ;
16603 bool temp2 = false ;
16604 int val3 ;
16605 int ecode3 = 0 ;
16606 PyObject * obj0 = 0 ;
16607 PyObject * obj1 = 0 ;
16608 PyObject * obj2 = 0 ;
16609 char * kwnames[] = {
16610 (char *) "self",(char *) "name",(char *) "value", NULL
16611 };
16612
16613 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16614 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16615 if (!SWIG_IsOK(res1)) {
16616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
16617 }
16618 arg1 = reinterpret_cast< wxImage * >(argp1);
16619 {
16620 arg2 = wxString_in_helper(obj1);
16621 if (arg2 == NULL) SWIG_fail;
16622 temp2 = true;
16623 }
16624 ecode3 = SWIG_AsVal_int(obj2, &val3);
16625 if (!SWIG_IsOK(ecode3)) {
16626 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
16627 }
16628 arg3 = static_cast< int >(val3);
16629 {
16630 PyThreadState* __tstate = wxPyBeginAllowThreads();
16631 (arg1)->SetOption((wxString const &)*arg2,arg3);
16632 wxPyEndAllowThreads(__tstate);
16633 if (PyErr_Occurred()) SWIG_fail;
16634 }
16635 resultobj = SWIG_Py_Void();
16636 {
16637 if (temp2)
16638 delete arg2;
16639 }
16640 return resultobj;
16641 fail:
16642 {
16643 if (temp2)
16644 delete arg2;
16645 }
16646 return NULL;
16647 }
16648
16649
16650 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16651 PyObject *resultobj = 0;
16652 wxImage *arg1 = (wxImage *) 0 ;
16653 wxString *arg2 = 0 ;
16654 wxString result;
16655 void *argp1 = 0 ;
16656 int res1 = 0 ;
16657 bool temp2 = false ;
16658 PyObject * obj0 = 0 ;
16659 PyObject * obj1 = 0 ;
16660 char * kwnames[] = {
16661 (char *) "self",(char *) "name", NULL
16662 };
16663
16664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
16665 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16666 if (!SWIG_IsOK(res1)) {
16667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16668 }
16669 arg1 = reinterpret_cast< wxImage * >(argp1);
16670 {
16671 arg2 = wxString_in_helper(obj1);
16672 if (arg2 == NULL) SWIG_fail;
16673 temp2 = true;
16674 }
16675 {
16676 PyThreadState* __tstate = wxPyBeginAllowThreads();
16677 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
16678 wxPyEndAllowThreads(__tstate);
16679 if (PyErr_Occurred()) SWIG_fail;
16680 }
16681 {
16682 #if wxUSE_UNICODE
16683 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16684 #else
16685 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16686 #endif
16687 }
16688 {
16689 if (temp2)
16690 delete arg2;
16691 }
16692 return resultobj;
16693 fail:
16694 {
16695 if (temp2)
16696 delete arg2;
16697 }
16698 return NULL;
16699 }
16700
16701
16702 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16703 PyObject *resultobj = 0;
16704 wxImage *arg1 = (wxImage *) 0 ;
16705 wxString *arg2 = 0 ;
16706 int result;
16707 void *argp1 = 0 ;
16708 int res1 = 0 ;
16709 bool temp2 = false ;
16710 PyObject * obj0 = 0 ;
16711 PyObject * obj1 = 0 ;
16712 char * kwnames[] = {
16713 (char *) "self",(char *) "name", NULL
16714 };
16715
16716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
16717 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16718 if (!SWIG_IsOK(res1)) {
16719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
16720 }
16721 arg1 = reinterpret_cast< wxImage * >(argp1);
16722 {
16723 arg2 = wxString_in_helper(obj1);
16724 if (arg2 == NULL) SWIG_fail;
16725 temp2 = true;
16726 }
16727 {
16728 PyThreadState* __tstate = wxPyBeginAllowThreads();
16729 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
16730 wxPyEndAllowThreads(__tstate);
16731 if (PyErr_Occurred()) SWIG_fail;
16732 }
16733 resultobj = SWIG_From_int(static_cast< int >(result));
16734 {
16735 if (temp2)
16736 delete arg2;
16737 }
16738 return resultobj;
16739 fail:
16740 {
16741 if (temp2)
16742 delete arg2;
16743 }
16744 return NULL;
16745 }
16746
16747
16748 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16749 PyObject *resultobj = 0;
16750 wxImage *arg1 = (wxImage *) 0 ;
16751 wxString *arg2 = 0 ;
16752 bool result;
16753 void *argp1 = 0 ;
16754 int res1 = 0 ;
16755 bool temp2 = false ;
16756 PyObject * obj0 = 0 ;
16757 PyObject * obj1 = 0 ;
16758 char * kwnames[] = {
16759 (char *) "self",(char *) "name", NULL
16760 };
16761
16762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
16763 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16764 if (!SWIG_IsOK(res1)) {
16765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16766 }
16767 arg1 = reinterpret_cast< wxImage * >(argp1);
16768 {
16769 arg2 = wxString_in_helper(obj1);
16770 if (arg2 == NULL) SWIG_fail;
16771 temp2 = true;
16772 }
16773 {
16774 PyThreadState* __tstate = wxPyBeginAllowThreads();
16775 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
16776 wxPyEndAllowThreads(__tstate);
16777 if (PyErr_Occurred()) SWIG_fail;
16778 }
16779 {
16780 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16781 }
16782 {
16783 if (temp2)
16784 delete arg2;
16785 }
16786 return resultobj;
16787 fail:
16788 {
16789 if (temp2)
16790 delete arg2;
16791 }
16792 return NULL;
16793 }
16794
16795
16796 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16797 PyObject *resultobj = 0;
16798 wxImage *arg1 = (wxImage *) 0 ;
16799 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
16800 unsigned long result;
16801 void *argp1 = 0 ;
16802 int res1 = 0 ;
16803 unsigned long val2 ;
16804 int ecode2 = 0 ;
16805 PyObject * obj0 = 0 ;
16806 PyObject * obj1 = 0 ;
16807 char * kwnames[] = {
16808 (char *) "self",(char *) "stopafter", NULL
16809 };
16810
16811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
16812 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16813 if (!SWIG_IsOK(res1)) {
16814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
16815 }
16816 arg1 = reinterpret_cast< wxImage * >(argp1);
16817 if (obj1) {
16818 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
16819 if (!SWIG_IsOK(ecode2)) {
16820 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
16821 }
16822 arg2 = static_cast< unsigned long >(val2);
16823 }
16824 {
16825 PyThreadState* __tstate = wxPyBeginAllowThreads();
16826 result = (unsigned long)(arg1)->CountColours(arg2);
16827 wxPyEndAllowThreads(__tstate);
16828 if (PyErr_Occurred()) SWIG_fail;
16829 }
16830 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16831 return resultobj;
16832 fail:
16833 return NULL;
16834 }
16835
16836
16837 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16838 PyObject *resultobj = 0;
16839 wxImage *arg1 = (wxImage *) 0 ;
16840 wxImageHistogram *arg2 = 0 ;
16841 unsigned long result;
16842 void *argp1 = 0 ;
16843 int res1 = 0 ;
16844 void *argp2 = 0 ;
16845 int res2 = 0 ;
16846 PyObject * obj0 = 0 ;
16847 PyObject * obj1 = 0 ;
16848 char * kwnames[] = {
16849 (char *) "self",(char *) "h", NULL
16850 };
16851
16852 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
16853 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16854 if (!SWIG_IsOK(res1)) {
16855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
16856 }
16857 arg1 = reinterpret_cast< wxImage * >(argp1);
16858 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
16859 if (!SWIG_IsOK(res2)) {
16860 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16861 }
16862 if (!argp2) {
16863 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16864 }
16865 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
16866 {
16867 PyThreadState* __tstate = wxPyBeginAllowThreads();
16868 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
16869 wxPyEndAllowThreads(__tstate);
16870 if (PyErr_Occurred()) SWIG_fail;
16871 }
16872 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16873 return resultobj;
16874 fail:
16875 return NULL;
16876 }
16877
16878
16879 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16880 PyObject *resultobj = 0;
16881 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16882 void *argp1 = 0 ;
16883 int res1 = 0 ;
16884 PyObject * obj0 = 0 ;
16885 char * kwnames[] = {
16886 (char *) "handler", NULL
16887 };
16888
16889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
16890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16891 if (!SWIG_IsOK(res1)) {
16892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16893 }
16894 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16895 {
16896 PyThreadState* __tstate = wxPyBeginAllowThreads();
16897 wxImage::AddHandler(arg1);
16898 wxPyEndAllowThreads(__tstate);
16899 if (PyErr_Occurred()) SWIG_fail;
16900 }
16901 resultobj = SWIG_Py_Void();
16902 return resultobj;
16903 fail:
16904 return NULL;
16905 }
16906
16907
16908 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16909 PyObject *resultobj = 0;
16910 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16911 void *argp1 = 0 ;
16912 int res1 = 0 ;
16913 PyObject * obj0 = 0 ;
16914 char * kwnames[] = {
16915 (char *) "handler", NULL
16916 };
16917
16918 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
16919 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16920 if (!SWIG_IsOK(res1)) {
16921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16922 }
16923 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16924 {
16925 PyThreadState* __tstate = wxPyBeginAllowThreads();
16926 wxImage::InsertHandler(arg1);
16927 wxPyEndAllowThreads(__tstate);
16928 if (PyErr_Occurred()) SWIG_fail;
16929 }
16930 resultobj = SWIG_Py_Void();
16931 return resultobj;
16932 fail:
16933 return NULL;
16934 }
16935
16936
16937 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16938 PyObject *resultobj = 0;
16939 wxString *arg1 = 0 ;
16940 bool result;
16941 bool temp1 = false ;
16942 PyObject * obj0 = 0 ;
16943 char * kwnames[] = {
16944 (char *) "name", NULL
16945 };
16946
16947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
16948 {
16949 arg1 = wxString_in_helper(obj0);
16950 if (arg1 == NULL) SWIG_fail;
16951 temp1 = true;
16952 }
16953 {
16954 PyThreadState* __tstate = wxPyBeginAllowThreads();
16955 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
16956 wxPyEndAllowThreads(__tstate);
16957 if (PyErr_Occurred()) SWIG_fail;
16958 }
16959 {
16960 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16961 }
16962 {
16963 if (temp1)
16964 delete arg1;
16965 }
16966 return resultobj;
16967 fail:
16968 {
16969 if (temp1)
16970 delete arg1;
16971 }
16972 return NULL;
16973 }
16974
16975
16976 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16977 PyObject *resultobj = 0;
16978 PyObject *result = 0 ;
16979
16980 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
16981 {
16982 PyThreadState* __tstate = wxPyBeginAllowThreads();
16983 result = (PyObject *)wxImage_GetHandlers();
16984 wxPyEndAllowThreads(__tstate);
16985 if (PyErr_Occurred()) SWIG_fail;
16986 }
16987 resultobj = result;
16988 return resultobj;
16989 fail:
16990 return NULL;
16991 }
16992
16993
16994 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16995 PyObject *resultobj = 0;
16996 wxString result;
16997
16998 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
16999 {
17000 PyThreadState* __tstate = wxPyBeginAllowThreads();
17001 result = wxImage::GetImageExtWildcard();
17002 wxPyEndAllowThreads(__tstate);
17003 if (PyErr_Occurred()) SWIG_fail;
17004 }
17005 {
17006 #if wxUSE_UNICODE
17007 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17008 #else
17009 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17010 #endif
17011 }
17012 return resultobj;
17013 fail:
17014 return NULL;
17015 }
17016
17017
17018 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17019 PyObject *resultobj = 0;
17020 wxImage *arg1 = (wxImage *) 0 ;
17021 int arg2 = (int) -1 ;
17022 wxBitmap result;
17023 void *argp1 = 0 ;
17024 int res1 = 0 ;
17025 int val2 ;
17026 int ecode2 = 0 ;
17027 PyObject * obj0 = 0 ;
17028 PyObject * obj1 = 0 ;
17029 char * kwnames[] = {
17030 (char *) "self",(char *) "depth", NULL
17031 };
17032
17033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
17034 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17035 if (!SWIG_IsOK(res1)) {
17036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
17037 }
17038 arg1 = reinterpret_cast< wxImage * >(argp1);
17039 if (obj1) {
17040 ecode2 = SWIG_AsVal_int(obj1, &val2);
17041 if (!SWIG_IsOK(ecode2)) {
17042 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
17043 }
17044 arg2 = static_cast< int >(val2);
17045 }
17046 {
17047 if (!wxPyCheckForApp()) SWIG_fail;
17048 PyThreadState* __tstate = wxPyBeginAllowThreads();
17049 result = wxImage_ConvertToBitmap(arg1,arg2);
17050 wxPyEndAllowThreads(__tstate);
17051 if (PyErr_Occurred()) SWIG_fail;
17052 }
17053 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
17054 return resultobj;
17055 fail:
17056 return NULL;
17057 }
17058
17059
17060 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17061 PyObject *resultobj = 0;
17062 wxImage *arg1 = (wxImage *) 0 ;
17063 byte arg2 ;
17064 byte arg3 ;
17065 byte arg4 ;
17066 wxBitmap result;
17067 void *argp1 = 0 ;
17068 int res1 = 0 ;
17069 unsigned char val2 ;
17070 int ecode2 = 0 ;
17071 unsigned char val3 ;
17072 int ecode3 = 0 ;
17073 unsigned char val4 ;
17074 int ecode4 = 0 ;
17075 PyObject * obj0 = 0 ;
17076 PyObject * obj1 = 0 ;
17077 PyObject * obj2 = 0 ;
17078 PyObject * obj3 = 0 ;
17079 char * kwnames[] = {
17080 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
17081 };
17082
17083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17085 if (!SWIG_IsOK(res1)) {
17086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
17087 }
17088 arg1 = reinterpret_cast< wxImage * >(argp1);
17089 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
17090 if (!SWIG_IsOK(ecode2)) {
17091 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
17092 }
17093 arg2 = static_cast< byte >(val2);
17094 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
17095 if (!SWIG_IsOK(ecode3)) {
17096 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
17097 }
17098 arg3 = static_cast< byte >(val3);
17099 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17100 if (!SWIG_IsOK(ecode4)) {
17101 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
17102 }
17103 arg4 = static_cast< byte >(val4);
17104 {
17105 if (!wxPyCheckForApp()) SWIG_fail;
17106 PyThreadState* __tstate = wxPyBeginAllowThreads();
17107 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
17108 wxPyEndAllowThreads(__tstate);
17109 if (PyErr_Occurred()) SWIG_fail;
17110 }
17111 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
17112 return resultobj;
17113 fail:
17114 return NULL;
17115 }
17116
17117
17118 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17119 PyObject *resultobj = 0;
17120 wxImage *arg1 = (wxImage *) 0 ;
17121 double arg2 ;
17122 void *argp1 = 0 ;
17123 int res1 = 0 ;
17124 double val2 ;
17125 int ecode2 = 0 ;
17126 PyObject * obj0 = 0 ;
17127 PyObject * obj1 = 0 ;
17128 char * kwnames[] = {
17129 (char *) "self",(char *) "angle", NULL
17130 };
17131
17132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
17133 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17134 if (!SWIG_IsOK(res1)) {
17135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
17136 }
17137 arg1 = reinterpret_cast< wxImage * >(argp1);
17138 ecode2 = SWIG_AsVal_double(obj1, &val2);
17139 if (!SWIG_IsOK(ecode2)) {
17140 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
17141 }
17142 arg2 = static_cast< double >(val2);
17143 {
17144 PyThreadState* __tstate = wxPyBeginAllowThreads();
17145 (arg1)->RotateHue(arg2);
17146 wxPyEndAllowThreads(__tstate);
17147 if (PyErr_Occurred()) SWIG_fail;
17148 }
17149 resultobj = SWIG_Py_Void();
17150 return resultobj;
17151 fail:
17152 return NULL;
17153 }
17154
17155
17156 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17157 PyObject *resultobj = 0;
17158 wxImage_RGBValue arg1 ;
17159 wxImage_HSVValue result;
17160 void *argp1 ;
17161 int res1 = 0 ;
17162 PyObject * obj0 = 0 ;
17163 char * kwnames[] = {
17164 (char *) "rgb", NULL
17165 };
17166
17167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
17168 {
17169 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
17170 if (!SWIG_IsOK(res1)) {
17171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
17172 }
17173 if (!argp1) {
17174 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
17175 } else {
17176 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
17177 arg1 = *temp;
17178 if (SWIG_IsNewObj(res1)) delete temp;
17179 }
17180 }
17181 {
17182 PyThreadState* __tstate = wxPyBeginAllowThreads();
17183 result = wxImage::RGBtoHSV(arg1);
17184 wxPyEndAllowThreads(__tstate);
17185 if (PyErr_Occurred()) SWIG_fail;
17186 }
17187 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
17188 return resultobj;
17189 fail:
17190 return NULL;
17191 }
17192
17193
17194 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17195 PyObject *resultobj = 0;
17196 wxImage_HSVValue arg1 ;
17197 wxImage_RGBValue result;
17198 void *argp1 ;
17199 int res1 = 0 ;
17200 PyObject * obj0 = 0 ;
17201 char * kwnames[] = {
17202 (char *) "hsv", NULL
17203 };
17204
17205 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
17206 {
17207 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
17208 if (!SWIG_IsOK(res1)) {
17209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
17210 }
17211 if (!argp1) {
17212 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
17213 } else {
17214 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
17215 arg1 = *temp;
17216 if (SWIG_IsNewObj(res1)) delete temp;
17217 }
17218 }
17219 {
17220 PyThreadState* __tstate = wxPyBeginAllowThreads();
17221 result = wxImage::HSVtoRGB(arg1);
17222 wxPyEndAllowThreads(__tstate);
17223 if (PyErr_Occurred()) SWIG_fail;
17224 }
17225 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
17226 return resultobj;
17227 fail:
17228 return NULL;
17229 }
17230
17231
17232 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17233 PyObject *obj;
17234 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17235 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
17236 return SWIG_Py_Void();
17237 }
17238
17239 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17240 return SWIG_Python_InitShadowInstance(args);
17241 }
17242
17243 SWIGINTERN PyObject *_wrap__ImageFromBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17244 PyObject *resultobj = 0;
17245 int arg1 ;
17246 int arg2 ;
17247 buffer arg3 ;
17248 int arg4 ;
17249 buffer arg5 = (buffer) NULL ;
17250 int arg6 = (int) 0 ;
17251 wxImage *result = 0 ;
17252 int val1 ;
17253 int ecode1 = 0 ;
17254 int val2 ;
17255 int ecode2 = 0 ;
17256 Py_ssize_t temp3 ;
17257 Py_ssize_t temp5 ;
17258 PyObject * obj0 = 0 ;
17259 PyObject * obj1 = 0 ;
17260 PyObject * obj2 = 0 ;
17261 PyObject * obj3 = 0 ;
17262 char * kwnames[] = {
17263 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
17264 };
17265
17266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:_ImageFromBuffer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17267 ecode1 = SWIG_AsVal_int(obj0, &val1);
17268 if (!SWIG_IsOK(ecode1)) {
17269 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_ImageFromBuffer" "', expected argument " "1"" of type '" "int""'");
17270 }
17271 arg1 = static_cast< int >(val1);
17272 ecode2 = SWIG_AsVal_int(obj1, &val2);
17273 if (!SWIG_IsOK(ecode2)) {
17274 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_ImageFromBuffer" "', expected argument " "2"" of type '" "int""'");
17275 }
17276 arg2 = static_cast< int >(val2);
17277 {
17278 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
17279 arg4 = (int)temp3;
17280 }
17281 if (obj3) {
17282 {
17283 if (obj3 != Py_None) {
17284 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
17285 arg6 = (int)temp5;
17286 }
17287 }
17288 }
17289 {
17290 PyThreadState* __tstate = wxPyBeginAllowThreads();
17291 result = (wxImage *)_ImageFromBuffer(arg1,arg2,arg3,arg4,arg5,arg6);
17292 wxPyEndAllowThreads(__tstate);
17293 if (PyErr_Occurred()) SWIG_fail;
17294 }
17295 {
17296 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
17297 }
17298 return resultobj;
17299 fail:
17300 return NULL;
17301 }
17302
17303
17304 SWIGINTERN int NullImage_set(PyObject *) {
17305 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
17306 return 1;
17307 }
17308
17309
17310 SWIGINTERN PyObject *NullImage_get(void) {
17311 PyObject *pyobj = 0;
17312
17313 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
17314 return pyobj;
17315 }
17316
17317
17318 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
17319 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
17320 return 1;
17321 }
17322
17323
17324 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
17325 PyObject *pyobj = 0;
17326
17327 {
17328 #if wxUSE_UNICODE
17329 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
17330 #else
17331 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
17332 #endif
17333 }
17334 return pyobj;
17335 }
17336
17337
17338 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
17339 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
17340 return 1;
17341 }
17342
17343
17344 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
17345 PyObject *pyobj = 0;
17346
17347 {
17348 #if wxUSE_UNICODE
17349 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
17350 #else
17351 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
17352 #endif
17353 }
17354 return pyobj;
17355 }
17356
17357
17358 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
17359 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
17360 return 1;
17361 }
17362
17363
17364 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
17365 PyObject *pyobj = 0;
17366
17367 {
17368 #if wxUSE_UNICODE
17369 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
17370 #else
17371 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
17372 #endif
17373 }
17374 return pyobj;
17375 }
17376
17377
17378 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
17379 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
17380 return 1;
17381 }
17382
17383
17384 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
17385 PyObject *pyobj = 0;
17386
17387 {
17388 #if wxUSE_UNICODE
17389 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17390 #else
17391 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17392 #endif
17393 }
17394 return pyobj;
17395 }
17396
17397
17398 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
17399 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
17400 return 1;
17401 }
17402
17403
17404 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
17405 PyObject *pyobj = 0;
17406
17407 {
17408 #if wxUSE_UNICODE
17409 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17410 #else
17411 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17412 #endif
17413 }
17414 return pyobj;
17415 }
17416
17417
17418 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
17419 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
17420 return 1;
17421 }
17422
17423
17424 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
17425 PyObject *pyobj = 0;
17426
17427 {
17428 #if wxUSE_UNICODE
17429 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17430 #else
17431 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17432 #endif
17433 }
17434 return pyobj;
17435 }
17436
17437
17438 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
17439 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
17440 return 1;
17441 }
17442
17443
17444 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
17445 PyObject *pyobj = 0;
17446
17447 {
17448 #if wxUSE_UNICODE
17449 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17450 #else
17451 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17452 #endif
17453 }
17454 return pyobj;
17455 }
17456
17457
17458 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
17459 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
17460 return 1;
17461 }
17462
17463
17464 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
17465 PyObject *pyobj = 0;
17466
17467 {
17468 #if wxUSE_UNICODE
17469 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17470 #else
17471 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17472 #endif
17473 }
17474 return pyobj;
17475 }
17476
17477
17478 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
17479 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
17480 return 1;
17481 }
17482
17483
17484 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
17485 PyObject *pyobj = 0;
17486
17487 {
17488 #if wxUSE_UNICODE
17489 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17490 #else
17491 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17492 #endif
17493 }
17494 return pyobj;
17495 }
17496
17497
17498 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
17499 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
17500 return 1;
17501 }
17502
17503
17504 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
17505 PyObject *pyobj = 0;
17506
17507 {
17508 #if wxUSE_UNICODE
17509 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17510 #else
17511 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17512 #endif
17513 }
17514 return pyobj;
17515 }
17516
17517
17518 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
17519 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
17520 return 1;
17521 }
17522
17523
17524 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
17525 PyObject *pyobj = 0;
17526
17527 {
17528 #if wxUSE_UNICODE
17529 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17530 #else
17531 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17532 #endif
17533 }
17534 return pyobj;
17535 }
17536
17537
17538 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
17539 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
17540 return 1;
17541 }
17542
17543
17544 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
17545 PyObject *pyobj = 0;
17546
17547 {
17548 #if wxUSE_UNICODE
17549 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17550 #else
17551 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17552 #endif
17553 }
17554 return pyobj;
17555 }
17556
17557
17558 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
17559 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
17560 return 1;
17561 }
17562
17563
17564 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
17565 PyObject *pyobj = 0;
17566
17567 {
17568 #if wxUSE_UNICODE
17569 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17570 #else
17571 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17572 #endif
17573 }
17574 return pyobj;
17575 }
17576
17577
17578 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
17579 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
17580 return 1;
17581 }
17582
17583
17584 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
17585 PyObject *pyobj = 0;
17586
17587 {
17588 #if wxUSE_UNICODE
17589 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17590 #else
17591 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17592 #endif
17593 }
17594 return pyobj;
17595 }
17596
17597
17598 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
17599 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
17600 return 1;
17601 }
17602
17603
17604 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
17605 PyObject *pyobj = 0;
17606
17607 {
17608 #if wxUSE_UNICODE
17609 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17610 #else
17611 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17612 #endif
17613 }
17614 return pyobj;
17615 }
17616
17617
17618 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17619 PyObject *resultobj = 0;
17620 wxBMPHandler *result = 0 ;
17621
17622 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
17623 {
17624 PyThreadState* __tstate = wxPyBeginAllowThreads();
17625 result = (wxBMPHandler *)new wxBMPHandler();
17626 wxPyEndAllowThreads(__tstate);
17627 if (PyErr_Occurred()) SWIG_fail;
17628 }
17629 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
17630 return resultobj;
17631 fail:
17632 return NULL;
17633 }
17634
17635
17636 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17637 PyObject *obj;
17638 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17639 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
17640 return SWIG_Py_Void();
17641 }
17642
17643 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17644 return SWIG_Python_InitShadowInstance(args);
17645 }
17646
17647 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17648 PyObject *resultobj = 0;
17649 wxICOHandler *result = 0 ;
17650
17651 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
17652 {
17653 PyThreadState* __tstate = wxPyBeginAllowThreads();
17654 result = (wxICOHandler *)new wxICOHandler();
17655 wxPyEndAllowThreads(__tstate);
17656 if (PyErr_Occurred()) SWIG_fail;
17657 }
17658 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
17659 return resultobj;
17660 fail:
17661 return NULL;
17662 }
17663
17664
17665 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17666 PyObject *obj;
17667 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17668 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
17669 return SWIG_Py_Void();
17670 }
17671
17672 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17673 return SWIG_Python_InitShadowInstance(args);
17674 }
17675
17676 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17677 PyObject *resultobj = 0;
17678 wxCURHandler *result = 0 ;
17679
17680 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
17681 {
17682 PyThreadState* __tstate = wxPyBeginAllowThreads();
17683 result = (wxCURHandler *)new wxCURHandler();
17684 wxPyEndAllowThreads(__tstate);
17685 if (PyErr_Occurred()) SWIG_fail;
17686 }
17687 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
17688 return resultobj;
17689 fail:
17690 return NULL;
17691 }
17692
17693
17694 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17695 PyObject *obj;
17696 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17697 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
17698 return SWIG_Py_Void();
17699 }
17700
17701 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17702 return SWIG_Python_InitShadowInstance(args);
17703 }
17704
17705 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17706 PyObject *resultobj = 0;
17707 wxANIHandler *result = 0 ;
17708
17709 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
17710 {
17711 PyThreadState* __tstate = wxPyBeginAllowThreads();
17712 result = (wxANIHandler *)new wxANIHandler();
17713 wxPyEndAllowThreads(__tstate);
17714 if (PyErr_Occurred()) SWIG_fail;
17715 }
17716 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
17717 return resultobj;
17718 fail:
17719 return NULL;
17720 }
17721
17722
17723 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17724 PyObject *obj;
17725 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17726 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
17727 return SWIG_Py_Void();
17728 }
17729
17730 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17731 return SWIG_Python_InitShadowInstance(args);
17732 }
17733
17734 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17735 PyObject *resultobj = 0;
17736 wxPNGHandler *result = 0 ;
17737
17738 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
17739 {
17740 PyThreadState* __tstate = wxPyBeginAllowThreads();
17741 result = (wxPNGHandler *)new wxPNGHandler();
17742 wxPyEndAllowThreads(__tstate);
17743 if (PyErr_Occurred()) SWIG_fail;
17744 }
17745 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
17746 return resultobj;
17747 fail:
17748 return NULL;
17749 }
17750
17751
17752 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17753 PyObject *obj;
17754 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17755 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
17756 return SWIG_Py_Void();
17757 }
17758
17759 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17760 return SWIG_Python_InitShadowInstance(args);
17761 }
17762
17763 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17764 PyObject *resultobj = 0;
17765 wxGIFHandler *result = 0 ;
17766
17767 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
17768 {
17769 PyThreadState* __tstate = wxPyBeginAllowThreads();
17770 result = (wxGIFHandler *)new wxGIFHandler();
17771 wxPyEndAllowThreads(__tstate);
17772 if (PyErr_Occurred()) SWIG_fail;
17773 }
17774 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
17775 return resultobj;
17776 fail:
17777 return NULL;
17778 }
17779
17780
17781 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17782 PyObject *obj;
17783 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17784 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
17785 return SWIG_Py_Void();
17786 }
17787
17788 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17789 return SWIG_Python_InitShadowInstance(args);
17790 }
17791
17792 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17793 PyObject *resultobj = 0;
17794 wxPCXHandler *result = 0 ;
17795
17796 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
17797 {
17798 PyThreadState* __tstate = wxPyBeginAllowThreads();
17799 result = (wxPCXHandler *)new wxPCXHandler();
17800 wxPyEndAllowThreads(__tstate);
17801 if (PyErr_Occurred()) SWIG_fail;
17802 }
17803 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
17804 return resultobj;
17805 fail:
17806 return NULL;
17807 }
17808
17809
17810 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17811 PyObject *obj;
17812 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17813 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
17814 return SWIG_Py_Void();
17815 }
17816
17817 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17818 return SWIG_Python_InitShadowInstance(args);
17819 }
17820
17821 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17822 PyObject *resultobj = 0;
17823 wxJPEGHandler *result = 0 ;
17824
17825 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
17826 {
17827 PyThreadState* __tstate = wxPyBeginAllowThreads();
17828 result = (wxJPEGHandler *)new wxJPEGHandler();
17829 wxPyEndAllowThreads(__tstate);
17830 if (PyErr_Occurred()) SWIG_fail;
17831 }
17832 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
17833 return resultobj;
17834 fail:
17835 return NULL;
17836 }
17837
17838
17839 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17840 PyObject *obj;
17841 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17842 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
17843 return SWIG_Py_Void();
17844 }
17845
17846 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17847 return SWIG_Python_InitShadowInstance(args);
17848 }
17849
17850 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17851 PyObject *resultobj = 0;
17852 wxPNMHandler *result = 0 ;
17853
17854 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
17855 {
17856 PyThreadState* __tstate = wxPyBeginAllowThreads();
17857 result = (wxPNMHandler *)new wxPNMHandler();
17858 wxPyEndAllowThreads(__tstate);
17859 if (PyErr_Occurred()) SWIG_fail;
17860 }
17861 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
17862 return resultobj;
17863 fail:
17864 return NULL;
17865 }
17866
17867
17868 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17869 PyObject *obj;
17870 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17871 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
17872 return SWIG_Py_Void();
17873 }
17874
17875 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17876 return SWIG_Python_InitShadowInstance(args);
17877 }
17878
17879 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17880 PyObject *resultobj = 0;
17881 wxXPMHandler *result = 0 ;
17882
17883 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
17884 {
17885 PyThreadState* __tstate = wxPyBeginAllowThreads();
17886 result = (wxXPMHandler *)new wxXPMHandler();
17887 wxPyEndAllowThreads(__tstate);
17888 if (PyErr_Occurred()) SWIG_fail;
17889 }
17890 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
17891 return resultobj;
17892 fail:
17893 return NULL;
17894 }
17895
17896
17897 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17898 PyObject *obj;
17899 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17900 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
17901 return SWIG_Py_Void();
17902 }
17903
17904 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17905 return SWIG_Python_InitShadowInstance(args);
17906 }
17907
17908 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17909 PyObject *resultobj = 0;
17910 wxTIFFHandler *result = 0 ;
17911
17912 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
17913 {
17914 PyThreadState* __tstate = wxPyBeginAllowThreads();
17915 result = (wxTIFFHandler *)new wxTIFFHandler();
17916 wxPyEndAllowThreads(__tstate);
17917 if (PyErr_Occurred()) SWIG_fail;
17918 }
17919 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
17920 return resultobj;
17921 fail:
17922 return NULL;
17923 }
17924
17925
17926 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17927 PyObject *obj;
17928 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17929 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
17930 return SWIG_Py_Void();
17931 }
17932
17933 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17934 return SWIG_Python_InitShadowInstance(args);
17935 }
17936
17937 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17938 PyObject *resultobj = 0;
17939 wxImage *arg1 = 0 ;
17940 wxImage *arg2 = 0 ;
17941 int arg3 = (int) 236 ;
17942 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
17943 bool result;
17944 void *argp1 = 0 ;
17945 int res1 = 0 ;
17946 void *argp2 = 0 ;
17947 int res2 = 0 ;
17948 int val3 ;
17949 int ecode3 = 0 ;
17950 int val4 ;
17951 int ecode4 = 0 ;
17952 PyObject * obj0 = 0 ;
17953 PyObject * obj1 = 0 ;
17954 PyObject * obj2 = 0 ;
17955 PyObject * obj3 = 0 ;
17956 char * kwnames[] = {
17957 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
17958 };
17959
17960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17961 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
17962 if (!SWIG_IsOK(res1)) {
17963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17964 }
17965 if (!argp1) {
17966 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17967 }
17968 arg1 = reinterpret_cast< wxImage * >(argp1);
17969 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
17970 if (!SWIG_IsOK(res2)) {
17971 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17972 }
17973 if (!argp2) {
17974 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17975 }
17976 arg2 = reinterpret_cast< wxImage * >(argp2);
17977 if (obj2) {
17978 ecode3 = SWIG_AsVal_int(obj2, &val3);
17979 if (!SWIG_IsOK(ecode3)) {
17980 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
17981 }
17982 arg3 = static_cast< int >(val3);
17983 }
17984 if (obj3) {
17985 ecode4 = SWIG_AsVal_int(obj3, &val4);
17986 if (!SWIG_IsOK(ecode4)) {
17987 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
17988 }
17989 arg4 = static_cast< int >(val4);
17990 }
17991 {
17992 PyThreadState* __tstate = wxPyBeginAllowThreads();
17993 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
17994 wxPyEndAllowThreads(__tstate);
17995 if (PyErr_Occurred()) SWIG_fail;
17996 }
17997 {
17998 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17999 }
18000 return resultobj;
18001 fail:
18002 return NULL;
18003 }
18004
18005
18006 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18007 PyObject *obj;
18008 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18009 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
18010 return SWIG_Py_Void();
18011 }
18012
18013 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18014 PyObject *resultobj = 0;
18015 wxEvtHandler *result = 0 ;
18016
18017 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
18018 {
18019 PyThreadState* __tstate = wxPyBeginAllowThreads();
18020 result = (wxEvtHandler *)new wxEvtHandler();
18021 wxPyEndAllowThreads(__tstate);
18022 if (PyErr_Occurred()) SWIG_fail;
18023 }
18024 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
18025 return resultobj;
18026 fail:
18027 return NULL;
18028 }
18029
18030
18031 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18032 PyObject *resultobj = 0;
18033 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18034 wxEvtHandler *result = 0 ;
18035 void *argp1 = 0 ;
18036 int res1 = 0 ;
18037 PyObject *swig_obj[1] ;
18038
18039 if (!args) SWIG_fail;
18040 swig_obj[0] = args;
18041 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18042 if (!SWIG_IsOK(res1)) {
18043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18044 }
18045 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18046 {
18047 PyThreadState* __tstate = wxPyBeginAllowThreads();
18048 result = (wxEvtHandler *)(arg1)->GetNextHandler();
18049 wxPyEndAllowThreads(__tstate);
18050 if (PyErr_Occurred()) SWIG_fail;
18051 }
18052 {
18053 resultobj = wxPyMake_wxObject(result, 0);
18054 }
18055 return resultobj;
18056 fail:
18057 return NULL;
18058 }
18059
18060
18061 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18062 PyObject *resultobj = 0;
18063 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18064 wxEvtHandler *result = 0 ;
18065 void *argp1 = 0 ;
18066 int res1 = 0 ;
18067 PyObject *swig_obj[1] ;
18068
18069 if (!args) SWIG_fail;
18070 swig_obj[0] = args;
18071 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18072 if (!SWIG_IsOK(res1)) {
18073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18074 }
18075 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18076 {
18077 PyThreadState* __tstate = wxPyBeginAllowThreads();
18078 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
18079 wxPyEndAllowThreads(__tstate);
18080 if (PyErr_Occurred()) SWIG_fail;
18081 }
18082 {
18083 resultobj = wxPyMake_wxObject(result, 0);
18084 }
18085 return resultobj;
18086 fail:
18087 return NULL;
18088 }
18089
18090
18091 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18092 PyObject *resultobj = 0;
18093 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18094 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
18095 void *argp1 = 0 ;
18096 int res1 = 0 ;
18097 void *argp2 = 0 ;
18098 int res2 = 0 ;
18099 PyObject * obj0 = 0 ;
18100 PyObject * obj1 = 0 ;
18101 char * kwnames[] = {
18102 (char *) "self",(char *) "handler", NULL
18103 };
18104
18105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
18106 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18107 if (!SWIG_IsOK(res1)) {
18108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18109 }
18110 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18111 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18112 if (!SWIG_IsOK(res2)) {
18113 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
18114 }
18115 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
18116 {
18117 PyThreadState* __tstate = wxPyBeginAllowThreads();
18118 (arg1)->SetNextHandler(arg2);
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_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18130 PyObject *resultobj = 0;
18131 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18132 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
18133 void *argp1 = 0 ;
18134 int res1 = 0 ;
18135 void *argp2 = 0 ;
18136 int res2 = 0 ;
18137 PyObject * obj0 = 0 ;
18138 PyObject * obj1 = 0 ;
18139 char * kwnames[] = {
18140 (char *) "self",(char *) "handler", NULL
18141 };
18142
18143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
18144 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18145 if (!SWIG_IsOK(res1)) {
18146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18147 }
18148 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18149 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18150 if (!SWIG_IsOK(res2)) {
18151 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
18152 }
18153 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
18154 {
18155 PyThreadState* __tstate = wxPyBeginAllowThreads();
18156 (arg1)->SetPreviousHandler(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_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18168 PyObject *resultobj = 0;
18169 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18170 bool 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_wxEvtHandler, 0 | 0 );
18178 if (!SWIG_IsOK(res1)) {
18179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18180 }
18181 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18182 {
18183 PyThreadState* __tstate = wxPyBeginAllowThreads();
18184 result = (bool)(arg1)->GetEvtHandlerEnabled();
18185 wxPyEndAllowThreads(__tstate);
18186 if (PyErr_Occurred()) SWIG_fail;
18187 }
18188 {
18189 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18190 }
18191 return resultobj;
18192 fail:
18193 return NULL;
18194 }
18195
18196
18197 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18198 PyObject *resultobj = 0;
18199 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18200 bool arg2 ;
18201 void *argp1 = 0 ;
18202 int res1 = 0 ;
18203 bool val2 ;
18204 int ecode2 = 0 ;
18205 PyObject * obj0 = 0 ;
18206 PyObject * obj1 = 0 ;
18207 char * kwnames[] = {
18208 (char *) "self",(char *) "enabled", NULL
18209 };
18210
18211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
18212 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18213 if (!SWIG_IsOK(res1)) {
18214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18215 }
18216 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18217 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18218 if (!SWIG_IsOK(ecode2)) {
18219 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
18220 }
18221 arg2 = static_cast< bool >(val2);
18222 {
18223 PyThreadState* __tstate = wxPyBeginAllowThreads();
18224 (arg1)->SetEvtHandlerEnabled(arg2);
18225 wxPyEndAllowThreads(__tstate);
18226 if (PyErr_Occurred()) SWIG_fail;
18227 }
18228 resultobj = SWIG_Py_Void();
18229 return resultobj;
18230 fail:
18231 return NULL;
18232 }
18233
18234
18235 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18236 PyObject *resultobj = 0;
18237 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18238 wxEvent *arg2 = 0 ;
18239 bool result;
18240 void *argp1 = 0 ;
18241 int res1 = 0 ;
18242 void *argp2 = 0 ;
18243 int res2 = 0 ;
18244 PyObject * obj0 = 0 ;
18245 PyObject * obj1 = 0 ;
18246 char * kwnames[] = {
18247 (char *) "self",(char *) "event", NULL
18248 };
18249
18250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18251 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18252 if (!SWIG_IsOK(res1)) {
18253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18254 }
18255 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18256 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
18257 if (!SWIG_IsOK(res2)) {
18258 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18259 }
18260 if (!argp2) {
18261 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18262 }
18263 arg2 = reinterpret_cast< wxEvent * >(argp2);
18264 {
18265 PyThreadState* __tstate = wxPyBeginAllowThreads();
18266 result = (bool)(arg1)->ProcessEvent(*arg2);
18267 wxPyEndAllowThreads(__tstate);
18268 if (PyErr_Occurred()) SWIG_fail;
18269 }
18270 {
18271 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18272 }
18273 return resultobj;
18274 fail:
18275 return NULL;
18276 }
18277
18278
18279 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18280 PyObject *resultobj = 0;
18281 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18282 wxEvent *arg2 = 0 ;
18283 void *argp1 = 0 ;
18284 int res1 = 0 ;
18285 void *argp2 = 0 ;
18286 int res2 = 0 ;
18287 PyObject * obj0 = 0 ;
18288 PyObject * obj1 = 0 ;
18289 char * kwnames[] = {
18290 (char *) "self",(char *) "event", NULL
18291 };
18292
18293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18294 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18295 if (!SWIG_IsOK(res1)) {
18296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18297 }
18298 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18299 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
18300 if (!SWIG_IsOK(res2)) {
18301 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18302 }
18303 if (!argp2) {
18304 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18305 }
18306 arg2 = reinterpret_cast< wxEvent * >(argp2);
18307 {
18308 PyThreadState* __tstate = wxPyBeginAllowThreads();
18309 (arg1)->AddPendingEvent(*arg2);
18310 wxPyEndAllowThreads(__tstate);
18311 if (PyErr_Occurred()) SWIG_fail;
18312 }
18313 resultobj = SWIG_Py_Void();
18314 return resultobj;
18315 fail:
18316 return NULL;
18317 }
18318
18319
18320 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18321 PyObject *resultobj = 0;
18322 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18323 void *argp1 = 0 ;
18324 int res1 = 0 ;
18325 PyObject *swig_obj[1] ;
18326
18327 if (!args) SWIG_fail;
18328 swig_obj[0] = args;
18329 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18330 if (!SWIG_IsOK(res1)) {
18331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18332 }
18333 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18334 {
18335 PyThreadState* __tstate = wxPyBeginAllowThreads();
18336 (arg1)->ProcessPendingEvents();
18337 wxPyEndAllowThreads(__tstate);
18338 if (PyErr_Occurred()) SWIG_fail;
18339 }
18340 resultobj = SWIG_Py_Void();
18341 return resultobj;
18342 fail:
18343 return NULL;
18344 }
18345
18346
18347 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18348 PyObject *resultobj = 0;
18349 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18350 int arg2 ;
18351 int arg3 ;
18352 int arg4 ;
18353 PyObject *arg5 = (PyObject *) 0 ;
18354 void *argp1 = 0 ;
18355 int res1 = 0 ;
18356 int val2 ;
18357 int ecode2 = 0 ;
18358 int val3 ;
18359 int ecode3 = 0 ;
18360 int val4 ;
18361 int ecode4 = 0 ;
18362 PyObject * obj0 = 0 ;
18363 PyObject * obj1 = 0 ;
18364 PyObject * obj2 = 0 ;
18365 PyObject * obj3 = 0 ;
18366 PyObject * obj4 = 0 ;
18367 char * kwnames[] = {
18368 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
18369 };
18370
18371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
18372 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18373 if (!SWIG_IsOK(res1)) {
18374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18375 }
18376 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18377 ecode2 = SWIG_AsVal_int(obj1, &val2);
18378 if (!SWIG_IsOK(ecode2)) {
18379 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
18380 }
18381 arg2 = static_cast< int >(val2);
18382 ecode3 = SWIG_AsVal_int(obj2, &val3);
18383 if (!SWIG_IsOK(ecode3)) {
18384 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
18385 }
18386 arg3 = static_cast< int >(val3);
18387 ecode4 = SWIG_AsVal_int(obj3, &val4);
18388 if (!SWIG_IsOK(ecode4)) {
18389 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
18390 }
18391 arg4 = static_cast< int >(val4);
18392 arg5 = obj4;
18393 {
18394 PyThreadState* __tstate = wxPyBeginAllowThreads();
18395 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
18396 wxPyEndAllowThreads(__tstate);
18397 if (PyErr_Occurred()) SWIG_fail;
18398 }
18399 resultobj = SWIG_Py_Void();
18400 return resultobj;
18401 fail:
18402 return NULL;
18403 }
18404
18405
18406 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18407 PyObject *resultobj = 0;
18408 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18409 int arg2 ;
18410 int arg3 = (int) -1 ;
18411 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
18412 bool result;
18413 void *argp1 = 0 ;
18414 int res1 = 0 ;
18415 int val2 ;
18416 int ecode2 = 0 ;
18417 int val3 ;
18418 int ecode3 = 0 ;
18419 int val4 ;
18420 int ecode4 = 0 ;
18421 PyObject * obj0 = 0 ;
18422 PyObject * obj1 = 0 ;
18423 PyObject * obj2 = 0 ;
18424 PyObject * obj3 = 0 ;
18425 char * kwnames[] = {
18426 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
18427 };
18428
18429 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18430 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18431 if (!SWIG_IsOK(res1)) {
18432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18433 }
18434 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18435 ecode2 = SWIG_AsVal_int(obj1, &val2);
18436 if (!SWIG_IsOK(ecode2)) {
18437 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
18438 }
18439 arg2 = static_cast< int >(val2);
18440 if (obj2) {
18441 ecode3 = SWIG_AsVal_int(obj2, &val3);
18442 if (!SWIG_IsOK(ecode3)) {
18443 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
18444 }
18445 arg3 = static_cast< int >(val3);
18446 }
18447 if (obj3) {
18448 ecode4 = SWIG_AsVal_int(obj3, &val4);
18449 if (!SWIG_IsOK(ecode4)) {
18450 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
18451 }
18452 arg4 = static_cast< wxEventType >(val4);
18453 }
18454 {
18455 PyThreadState* __tstate = wxPyBeginAllowThreads();
18456 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
18457 wxPyEndAllowThreads(__tstate);
18458 if (PyErr_Occurred()) SWIG_fail;
18459 }
18460 {
18461 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18462 }
18463 return resultobj;
18464 fail:
18465 return NULL;
18466 }
18467
18468
18469 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18470 PyObject *resultobj = 0;
18471 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18472 PyObject *arg2 = (PyObject *) 0 ;
18473 bool arg3 = (bool) true ;
18474 void *argp1 = 0 ;
18475 int res1 = 0 ;
18476 bool val3 ;
18477 int ecode3 = 0 ;
18478 PyObject * obj0 = 0 ;
18479 PyObject * obj1 = 0 ;
18480 PyObject * obj2 = 0 ;
18481 char * kwnames[] = {
18482 (char *) "self",(char *) "_self",(char *) "incref", NULL
18483 };
18484
18485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18486 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18487 if (!SWIG_IsOK(res1)) {
18488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18489 }
18490 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18491 arg2 = obj1;
18492 if (obj2) {
18493 ecode3 = SWIG_AsVal_bool(obj2, &val3);
18494 if (!SWIG_IsOK(ecode3)) {
18495 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
18496 }
18497 arg3 = static_cast< bool >(val3);
18498 }
18499 {
18500 PyThreadState* __tstate = wxPyBeginAllowThreads();
18501 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
18502 wxPyEndAllowThreads(__tstate);
18503 if (PyErr_Occurred()) SWIG_fail;
18504 }
18505 resultobj = SWIG_Py_Void();
18506 return resultobj;
18507 fail:
18508 return NULL;
18509 }
18510
18511
18512 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18513 PyObject *obj;
18514 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18515 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
18516 return SWIG_Py_Void();
18517 }
18518
18519 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18520 return SWIG_Python_InitShadowInstance(args);
18521 }
18522
18523 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18524 PyObject *resultobj = 0;
18525 wxEventType result;
18526
18527 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
18528 {
18529 PyThreadState* __tstate = wxPyBeginAllowThreads();
18530 result = (wxEventType)wxNewEventType();
18531 wxPyEndAllowThreads(__tstate);
18532 if (PyErr_Occurred()) SWIG_fail;
18533 }
18534 resultobj = SWIG_From_int(static_cast< int >(result));
18535 return resultobj;
18536 fail:
18537 return NULL;
18538 }
18539
18540
18541 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18542 PyObject *resultobj = 0;
18543 wxEvent *arg1 = (wxEvent *) 0 ;
18544 void *argp1 = 0 ;
18545 int res1 = 0 ;
18546 PyObject *swig_obj[1] ;
18547
18548 if (!args) SWIG_fail;
18549 swig_obj[0] = args;
18550 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
18551 if (!SWIG_IsOK(res1)) {
18552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
18553 }
18554 arg1 = reinterpret_cast< wxEvent * >(argp1);
18555 {
18556 PyThreadState* __tstate = wxPyBeginAllowThreads();
18557 delete arg1;
18558
18559 wxPyEndAllowThreads(__tstate);
18560 if (PyErr_Occurred()) SWIG_fail;
18561 }
18562 resultobj = SWIG_Py_Void();
18563 return resultobj;
18564 fail:
18565 return NULL;
18566 }
18567
18568
18569 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18570 PyObject *resultobj = 0;
18571 wxEvent *arg1 = (wxEvent *) 0 ;
18572 wxEventType arg2 ;
18573 void *argp1 = 0 ;
18574 int res1 = 0 ;
18575 int val2 ;
18576 int ecode2 = 0 ;
18577 PyObject * obj0 = 0 ;
18578 PyObject * obj1 = 0 ;
18579 char * kwnames[] = {
18580 (char *) "self",(char *) "typ", NULL
18581 };
18582
18583 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
18584 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18585 if (!SWIG_IsOK(res1)) {
18586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
18587 }
18588 arg1 = reinterpret_cast< wxEvent * >(argp1);
18589 ecode2 = SWIG_AsVal_int(obj1, &val2);
18590 if (!SWIG_IsOK(ecode2)) {
18591 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
18592 }
18593 arg2 = static_cast< wxEventType >(val2);
18594 {
18595 PyThreadState* __tstate = wxPyBeginAllowThreads();
18596 (arg1)->SetEventType(arg2);
18597 wxPyEndAllowThreads(__tstate);
18598 if (PyErr_Occurred()) SWIG_fail;
18599 }
18600 resultobj = SWIG_Py_Void();
18601 return resultobj;
18602 fail:
18603 return NULL;
18604 }
18605
18606
18607 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18608 PyObject *resultobj = 0;
18609 wxEvent *arg1 = (wxEvent *) 0 ;
18610 wxEventType result;
18611 void *argp1 = 0 ;
18612 int res1 = 0 ;
18613 PyObject *swig_obj[1] ;
18614
18615 if (!args) SWIG_fail;
18616 swig_obj[0] = args;
18617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18618 if (!SWIG_IsOK(res1)) {
18619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
18620 }
18621 arg1 = reinterpret_cast< wxEvent * >(argp1);
18622 {
18623 PyThreadState* __tstate = wxPyBeginAllowThreads();
18624 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
18625 wxPyEndAllowThreads(__tstate);
18626 if (PyErr_Occurred()) SWIG_fail;
18627 }
18628 resultobj = SWIG_From_int(static_cast< int >(result));
18629 return resultobj;
18630 fail:
18631 return NULL;
18632 }
18633
18634
18635 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18636 PyObject *resultobj = 0;
18637 wxEvent *arg1 = (wxEvent *) 0 ;
18638 wxObject *result = 0 ;
18639 void *argp1 = 0 ;
18640 int res1 = 0 ;
18641 PyObject *swig_obj[1] ;
18642
18643 if (!args) SWIG_fail;
18644 swig_obj[0] = args;
18645 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18646 if (!SWIG_IsOK(res1)) {
18647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
18648 }
18649 arg1 = reinterpret_cast< wxEvent * >(argp1);
18650 {
18651 PyThreadState* __tstate = wxPyBeginAllowThreads();
18652 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
18653 wxPyEndAllowThreads(__tstate);
18654 if (PyErr_Occurred()) SWIG_fail;
18655 }
18656 {
18657 resultobj = wxPyMake_wxObject(result, (bool)0);
18658 }
18659 return resultobj;
18660 fail:
18661 return NULL;
18662 }
18663
18664
18665 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18666 PyObject *resultobj = 0;
18667 wxEvent *arg1 = (wxEvent *) 0 ;
18668 wxObject *arg2 = (wxObject *) 0 ;
18669 void *argp1 = 0 ;
18670 int res1 = 0 ;
18671 void *argp2 = 0 ;
18672 int res2 = 0 ;
18673 PyObject * obj0 = 0 ;
18674 PyObject * obj1 = 0 ;
18675 char * kwnames[] = {
18676 (char *) "self",(char *) "obj", NULL
18677 };
18678
18679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
18680 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18681 if (!SWIG_IsOK(res1)) {
18682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
18683 }
18684 arg1 = reinterpret_cast< wxEvent * >(argp1);
18685 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
18686 if (!SWIG_IsOK(res2)) {
18687 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
18688 }
18689 arg2 = reinterpret_cast< wxObject * >(argp2);
18690 {
18691 PyThreadState* __tstate = wxPyBeginAllowThreads();
18692 (arg1)->SetEventObject(arg2);
18693 wxPyEndAllowThreads(__tstate);
18694 if (PyErr_Occurred()) SWIG_fail;
18695 }
18696 resultobj = SWIG_Py_Void();
18697 return resultobj;
18698 fail:
18699 return NULL;
18700 }
18701
18702
18703 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18704 PyObject *resultobj = 0;
18705 wxEvent *arg1 = (wxEvent *) 0 ;
18706 long result;
18707 void *argp1 = 0 ;
18708 int res1 = 0 ;
18709 PyObject *swig_obj[1] ;
18710
18711 if (!args) SWIG_fail;
18712 swig_obj[0] = args;
18713 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18714 if (!SWIG_IsOK(res1)) {
18715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
18716 }
18717 arg1 = reinterpret_cast< wxEvent * >(argp1);
18718 {
18719 PyThreadState* __tstate = wxPyBeginAllowThreads();
18720 result = (long)((wxEvent const *)arg1)->GetTimestamp();
18721 wxPyEndAllowThreads(__tstate);
18722 if (PyErr_Occurred()) SWIG_fail;
18723 }
18724 resultobj = SWIG_From_long(static_cast< long >(result));
18725 return resultobj;
18726 fail:
18727 return NULL;
18728 }
18729
18730
18731 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18732 PyObject *resultobj = 0;
18733 wxEvent *arg1 = (wxEvent *) 0 ;
18734 long arg2 = (long) 0 ;
18735 void *argp1 = 0 ;
18736 int res1 = 0 ;
18737 long val2 ;
18738 int ecode2 = 0 ;
18739 PyObject * obj0 = 0 ;
18740 PyObject * obj1 = 0 ;
18741 char * kwnames[] = {
18742 (char *) "self",(char *) "ts", NULL
18743 };
18744
18745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
18746 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18747 if (!SWIG_IsOK(res1)) {
18748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
18749 }
18750 arg1 = reinterpret_cast< wxEvent * >(argp1);
18751 if (obj1) {
18752 ecode2 = SWIG_AsVal_long(obj1, &val2);
18753 if (!SWIG_IsOK(ecode2)) {
18754 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
18755 }
18756 arg2 = static_cast< long >(val2);
18757 }
18758 {
18759 PyThreadState* __tstate = wxPyBeginAllowThreads();
18760 (arg1)->SetTimestamp(arg2);
18761 wxPyEndAllowThreads(__tstate);
18762 if (PyErr_Occurred()) SWIG_fail;
18763 }
18764 resultobj = SWIG_Py_Void();
18765 return resultobj;
18766 fail:
18767 return NULL;
18768 }
18769
18770
18771 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18772 PyObject *resultobj = 0;
18773 wxEvent *arg1 = (wxEvent *) 0 ;
18774 int result;
18775 void *argp1 = 0 ;
18776 int res1 = 0 ;
18777 PyObject *swig_obj[1] ;
18778
18779 if (!args) SWIG_fail;
18780 swig_obj[0] = args;
18781 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18782 if (!SWIG_IsOK(res1)) {
18783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
18784 }
18785 arg1 = reinterpret_cast< wxEvent * >(argp1);
18786 {
18787 PyThreadState* __tstate = wxPyBeginAllowThreads();
18788 result = (int)((wxEvent const *)arg1)->GetId();
18789 wxPyEndAllowThreads(__tstate);
18790 if (PyErr_Occurred()) SWIG_fail;
18791 }
18792 resultobj = SWIG_From_int(static_cast< int >(result));
18793 return resultobj;
18794 fail:
18795 return NULL;
18796 }
18797
18798
18799 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18800 PyObject *resultobj = 0;
18801 wxEvent *arg1 = (wxEvent *) 0 ;
18802 int arg2 ;
18803 void *argp1 = 0 ;
18804 int res1 = 0 ;
18805 int val2 ;
18806 int ecode2 = 0 ;
18807 PyObject * obj0 = 0 ;
18808 PyObject * obj1 = 0 ;
18809 char * kwnames[] = {
18810 (char *) "self",(char *) "Id", NULL
18811 };
18812
18813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
18814 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18815 if (!SWIG_IsOK(res1)) {
18816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
18817 }
18818 arg1 = reinterpret_cast< wxEvent * >(argp1);
18819 ecode2 = SWIG_AsVal_int(obj1, &val2);
18820 if (!SWIG_IsOK(ecode2)) {
18821 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
18822 }
18823 arg2 = static_cast< int >(val2);
18824 {
18825 PyThreadState* __tstate = wxPyBeginAllowThreads();
18826 (arg1)->SetId(arg2);
18827 wxPyEndAllowThreads(__tstate);
18828 if (PyErr_Occurred()) SWIG_fail;
18829 }
18830 resultobj = SWIG_Py_Void();
18831 return resultobj;
18832 fail:
18833 return NULL;
18834 }
18835
18836
18837 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18838 PyObject *resultobj = 0;
18839 wxEvent *arg1 = (wxEvent *) 0 ;
18840 bool result;
18841 void *argp1 = 0 ;
18842 int res1 = 0 ;
18843 PyObject *swig_obj[1] ;
18844
18845 if (!args) SWIG_fail;
18846 swig_obj[0] = args;
18847 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18848 if (!SWIG_IsOK(res1)) {
18849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
18850 }
18851 arg1 = reinterpret_cast< wxEvent * >(argp1);
18852 {
18853 PyThreadState* __tstate = wxPyBeginAllowThreads();
18854 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
18855 wxPyEndAllowThreads(__tstate);
18856 if (PyErr_Occurred()) SWIG_fail;
18857 }
18858 {
18859 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18860 }
18861 return resultobj;
18862 fail:
18863 return NULL;
18864 }
18865
18866
18867 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18868 PyObject *resultobj = 0;
18869 wxEvent *arg1 = (wxEvent *) 0 ;
18870 bool arg2 = (bool) true ;
18871 void *argp1 = 0 ;
18872 int res1 = 0 ;
18873 bool val2 ;
18874 int ecode2 = 0 ;
18875 PyObject * obj0 = 0 ;
18876 PyObject * obj1 = 0 ;
18877 char * kwnames[] = {
18878 (char *) "self",(char *) "skip", NULL
18879 };
18880
18881 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
18882 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18883 if (!SWIG_IsOK(res1)) {
18884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
18885 }
18886 arg1 = reinterpret_cast< wxEvent * >(argp1);
18887 if (obj1) {
18888 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18889 if (!SWIG_IsOK(ecode2)) {
18890 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
18891 }
18892 arg2 = static_cast< bool >(val2);
18893 }
18894 {
18895 PyThreadState* __tstate = wxPyBeginAllowThreads();
18896 (arg1)->Skip(arg2);
18897 wxPyEndAllowThreads(__tstate);
18898 if (PyErr_Occurred()) SWIG_fail;
18899 }
18900 resultobj = SWIG_Py_Void();
18901 return resultobj;
18902 fail:
18903 return NULL;
18904 }
18905
18906
18907 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18908 PyObject *resultobj = 0;
18909 wxEvent *arg1 = (wxEvent *) 0 ;
18910 bool result;
18911 void *argp1 = 0 ;
18912 int res1 = 0 ;
18913 PyObject *swig_obj[1] ;
18914
18915 if (!args) SWIG_fail;
18916 swig_obj[0] = args;
18917 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18918 if (!SWIG_IsOK(res1)) {
18919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
18920 }
18921 arg1 = reinterpret_cast< wxEvent * >(argp1);
18922 {
18923 PyThreadState* __tstate = wxPyBeginAllowThreads();
18924 result = (bool)((wxEvent const *)arg1)->GetSkipped();
18925 wxPyEndAllowThreads(__tstate);
18926 if (PyErr_Occurred()) SWIG_fail;
18927 }
18928 {
18929 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18930 }
18931 return resultobj;
18932 fail:
18933 return NULL;
18934 }
18935
18936
18937 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18938 PyObject *resultobj = 0;
18939 wxEvent *arg1 = (wxEvent *) 0 ;
18940 bool result;
18941 void *argp1 = 0 ;
18942 int res1 = 0 ;
18943 PyObject *swig_obj[1] ;
18944
18945 if (!args) SWIG_fail;
18946 swig_obj[0] = args;
18947 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18948 if (!SWIG_IsOK(res1)) {
18949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
18950 }
18951 arg1 = reinterpret_cast< wxEvent * >(argp1);
18952 {
18953 PyThreadState* __tstate = wxPyBeginAllowThreads();
18954 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
18955 wxPyEndAllowThreads(__tstate);
18956 if (PyErr_Occurred()) SWIG_fail;
18957 }
18958 {
18959 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18960 }
18961 return resultobj;
18962 fail:
18963 return NULL;
18964 }
18965
18966
18967 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18968 PyObject *resultobj = 0;
18969 wxEvent *arg1 = (wxEvent *) 0 ;
18970 int result;
18971 void *argp1 = 0 ;
18972 int res1 = 0 ;
18973 PyObject *swig_obj[1] ;
18974
18975 if (!args) SWIG_fail;
18976 swig_obj[0] = args;
18977 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18978 if (!SWIG_IsOK(res1)) {
18979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18980 }
18981 arg1 = reinterpret_cast< wxEvent * >(argp1);
18982 {
18983 PyThreadState* __tstate = wxPyBeginAllowThreads();
18984 result = (int)(arg1)->StopPropagation();
18985 wxPyEndAllowThreads(__tstate);
18986 if (PyErr_Occurred()) SWIG_fail;
18987 }
18988 resultobj = SWIG_From_int(static_cast< int >(result));
18989 return resultobj;
18990 fail:
18991 return NULL;
18992 }
18993
18994
18995 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18996 PyObject *resultobj = 0;
18997 wxEvent *arg1 = (wxEvent *) 0 ;
18998 int arg2 ;
18999 void *argp1 = 0 ;
19000 int res1 = 0 ;
19001 int val2 ;
19002 int ecode2 = 0 ;
19003 PyObject * obj0 = 0 ;
19004 PyObject * obj1 = 0 ;
19005 char * kwnames[] = {
19006 (char *) "self",(char *) "propagationLevel", NULL
19007 };
19008
19009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
19010 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19011 if (!SWIG_IsOK(res1)) {
19012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
19013 }
19014 arg1 = reinterpret_cast< wxEvent * >(argp1);
19015 ecode2 = SWIG_AsVal_int(obj1, &val2);
19016 if (!SWIG_IsOK(ecode2)) {
19017 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
19018 }
19019 arg2 = static_cast< int >(val2);
19020 {
19021 PyThreadState* __tstate = wxPyBeginAllowThreads();
19022 (arg1)->ResumePropagation(arg2);
19023 wxPyEndAllowThreads(__tstate);
19024 if (PyErr_Occurred()) SWIG_fail;
19025 }
19026 resultobj = SWIG_Py_Void();
19027 return resultobj;
19028 fail:
19029 return NULL;
19030 }
19031
19032
19033 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19034 PyObject *resultobj = 0;
19035 wxEvent *arg1 = (wxEvent *) 0 ;
19036 wxEvent *result = 0 ;
19037 void *argp1 = 0 ;
19038 int res1 = 0 ;
19039 PyObject *swig_obj[1] ;
19040
19041 if (!args) SWIG_fail;
19042 swig_obj[0] = args;
19043 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19044 if (!SWIG_IsOK(res1)) {
19045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
19046 }
19047 arg1 = reinterpret_cast< wxEvent * >(argp1);
19048 {
19049 PyThreadState* __tstate = wxPyBeginAllowThreads();
19050 result = (wxEvent *)(arg1)->Clone();
19051 wxPyEndAllowThreads(__tstate);
19052 if (PyErr_Occurred()) SWIG_fail;
19053 }
19054 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
19055 return resultobj;
19056 fail:
19057 return NULL;
19058 }
19059
19060
19061 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19062 PyObject *obj;
19063 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19064 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
19065 return SWIG_Py_Void();
19066 }
19067
19068 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19069 PyObject *resultobj = 0;
19070 wxEvent *arg1 = 0 ;
19071 wxPropagationDisabler *result = 0 ;
19072 void *argp1 = 0 ;
19073 int res1 = 0 ;
19074 PyObject * obj0 = 0 ;
19075 char * kwnames[] = {
19076 (char *) "event", NULL
19077 };
19078
19079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
19080 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
19081 if (!SWIG_IsOK(res1)) {
19082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
19083 }
19084 if (!argp1) {
19085 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
19086 }
19087 arg1 = reinterpret_cast< wxEvent * >(argp1);
19088 {
19089 PyThreadState* __tstate = wxPyBeginAllowThreads();
19090 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
19091 wxPyEndAllowThreads(__tstate);
19092 if (PyErr_Occurred()) SWIG_fail;
19093 }
19094 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
19095 return resultobj;
19096 fail:
19097 return NULL;
19098 }
19099
19100
19101 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19102 PyObject *resultobj = 0;
19103 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
19104 void *argp1 = 0 ;
19105 int res1 = 0 ;
19106 PyObject *swig_obj[1] ;
19107
19108 if (!args) SWIG_fail;
19109 swig_obj[0] = args;
19110 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
19111 if (!SWIG_IsOK(res1)) {
19112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
19113 }
19114 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
19115 {
19116 PyThreadState* __tstate = wxPyBeginAllowThreads();
19117 delete arg1;
19118
19119 wxPyEndAllowThreads(__tstate);
19120 if (PyErr_Occurred()) SWIG_fail;
19121 }
19122 resultobj = SWIG_Py_Void();
19123 return resultobj;
19124 fail:
19125 return NULL;
19126 }
19127
19128
19129 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19130 PyObject *obj;
19131 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19132 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
19133 return SWIG_Py_Void();
19134 }
19135
19136 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19137 return SWIG_Python_InitShadowInstance(args);
19138 }
19139
19140 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19141 PyObject *resultobj = 0;
19142 wxEvent *arg1 = 0 ;
19143 wxPropagateOnce *result = 0 ;
19144 void *argp1 = 0 ;
19145 int res1 = 0 ;
19146 PyObject * obj0 = 0 ;
19147 char * kwnames[] = {
19148 (char *) "event", NULL
19149 };
19150
19151 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
19152 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
19153 if (!SWIG_IsOK(res1)) {
19154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
19155 }
19156 if (!argp1) {
19157 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
19158 }
19159 arg1 = reinterpret_cast< wxEvent * >(argp1);
19160 {
19161 PyThreadState* __tstate = wxPyBeginAllowThreads();
19162 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
19163 wxPyEndAllowThreads(__tstate);
19164 if (PyErr_Occurred()) SWIG_fail;
19165 }
19166 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
19167 return resultobj;
19168 fail:
19169 return NULL;
19170 }
19171
19172
19173 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19174 PyObject *resultobj = 0;
19175 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
19176 void *argp1 = 0 ;
19177 int res1 = 0 ;
19178 PyObject *swig_obj[1] ;
19179
19180 if (!args) SWIG_fail;
19181 swig_obj[0] = args;
19182 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
19183 if (!SWIG_IsOK(res1)) {
19184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
19185 }
19186 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
19187 {
19188 PyThreadState* __tstate = wxPyBeginAllowThreads();
19189 delete arg1;
19190
19191 wxPyEndAllowThreads(__tstate);
19192 if (PyErr_Occurred()) SWIG_fail;
19193 }
19194 resultobj = SWIG_Py_Void();
19195 return resultobj;
19196 fail:
19197 return NULL;
19198 }
19199
19200
19201 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19202 PyObject *obj;
19203 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19204 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
19205 return SWIG_Py_Void();
19206 }
19207
19208 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19209 return SWIG_Python_InitShadowInstance(args);
19210 }
19211
19212 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19213 PyObject *resultobj = 0;
19214 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19215 int arg2 = (int) 0 ;
19216 wxCommandEvent *result = 0 ;
19217 int val1 ;
19218 int ecode1 = 0 ;
19219 int val2 ;
19220 int ecode2 = 0 ;
19221 PyObject * obj0 = 0 ;
19222 PyObject * obj1 = 0 ;
19223 char * kwnames[] = {
19224 (char *) "commandType",(char *) "winid", NULL
19225 };
19226
19227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19228 if (obj0) {
19229 ecode1 = SWIG_AsVal_int(obj0, &val1);
19230 if (!SWIG_IsOK(ecode1)) {
19231 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19232 }
19233 arg1 = static_cast< wxEventType >(val1);
19234 }
19235 if (obj1) {
19236 ecode2 = SWIG_AsVal_int(obj1, &val2);
19237 if (!SWIG_IsOK(ecode2)) {
19238 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
19239 }
19240 arg2 = static_cast< int >(val2);
19241 }
19242 {
19243 PyThreadState* __tstate = wxPyBeginAllowThreads();
19244 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
19245 wxPyEndAllowThreads(__tstate);
19246 if (PyErr_Occurred()) SWIG_fail;
19247 }
19248 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
19249 return resultobj;
19250 fail:
19251 return NULL;
19252 }
19253
19254
19255 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19256 PyObject *resultobj = 0;
19257 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19258 int result;
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_wxCommandEvent, 0 | 0 );
19266 if (!SWIG_IsOK(res1)) {
19267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19268 }
19269 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19270 {
19271 PyThreadState* __tstate = wxPyBeginAllowThreads();
19272 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
19273 wxPyEndAllowThreads(__tstate);
19274 if (PyErr_Occurred()) SWIG_fail;
19275 }
19276 resultobj = SWIG_From_int(static_cast< int >(result));
19277 return resultobj;
19278 fail:
19279 return NULL;
19280 }
19281
19282
19283 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19284 PyObject *resultobj = 0;
19285 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19286 wxString *arg2 = 0 ;
19287 void *argp1 = 0 ;
19288 int res1 = 0 ;
19289 bool temp2 = false ;
19290 PyObject * obj0 = 0 ;
19291 PyObject * obj1 = 0 ;
19292 char * kwnames[] = {
19293 (char *) "self",(char *) "s", NULL
19294 };
19295
19296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
19297 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19298 if (!SWIG_IsOK(res1)) {
19299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19300 }
19301 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19302 {
19303 arg2 = wxString_in_helper(obj1);
19304 if (arg2 == NULL) SWIG_fail;
19305 temp2 = true;
19306 }
19307 {
19308 PyThreadState* __tstate = wxPyBeginAllowThreads();
19309 (arg1)->SetString((wxString const &)*arg2);
19310 wxPyEndAllowThreads(__tstate);
19311 if (PyErr_Occurred()) SWIG_fail;
19312 }
19313 resultobj = SWIG_Py_Void();
19314 {
19315 if (temp2)
19316 delete arg2;
19317 }
19318 return resultobj;
19319 fail:
19320 {
19321 if (temp2)
19322 delete arg2;
19323 }
19324 return NULL;
19325 }
19326
19327
19328 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19329 PyObject *resultobj = 0;
19330 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19331 wxString result;
19332 void *argp1 = 0 ;
19333 int res1 = 0 ;
19334 PyObject *swig_obj[1] ;
19335
19336 if (!args) SWIG_fail;
19337 swig_obj[0] = args;
19338 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19339 if (!SWIG_IsOK(res1)) {
19340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19341 }
19342 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19343 {
19344 PyThreadState* __tstate = wxPyBeginAllowThreads();
19345 result = ((wxCommandEvent const *)arg1)->GetString();
19346 wxPyEndAllowThreads(__tstate);
19347 if (PyErr_Occurred()) SWIG_fail;
19348 }
19349 {
19350 #if wxUSE_UNICODE
19351 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19352 #else
19353 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19354 #endif
19355 }
19356 return resultobj;
19357 fail:
19358 return NULL;
19359 }
19360
19361
19362 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19363 PyObject *resultobj = 0;
19364 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19365 bool result;
19366 void *argp1 = 0 ;
19367 int res1 = 0 ;
19368 PyObject *swig_obj[1] ;
19369
19370 if (!args) SWIG_fail;
19371 swig_obj[0] = args;
19372 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19373 if (!SWIG_IsOK(res1)) {
19374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19375 }
19376 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19377 {
19378 PyThreadState* __tstate = wxPyBeginAllowThreads();
19379 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
19380 wxPyEndAllowThreads(__tstate);
19381 if (PyErr_Occurred()) SWIG_fail;
19382 }
19383 {
19384 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19385 }
19386 return resultobj;
19387 fail:
19388 return NULL;
19389 }
19390
19391
19392 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19393 PyObject *resultobj = 0;
19394 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19395 bool result;
19396 void *argp1 = 0 ;
19397 int res1 = 0 ;
19398 PyObject *swig_obj[1] ;
19399
19400 if (!args) SWIG_fail;
19401 swig_obj[0] = args;
19402 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19403 if (!SWIG_IsOK(res1)) {
19404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19405 }
19406 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19407 {
19408 PyThreadState* __tstate = wxPyBeginAllowThreads();
19409 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
19410 wxPyEndAllowThreads(__tstate);
19411 if (PyErr_Occurred()) SWIG_fail;
19412 }
19413 {
19414 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19415 }
19416 return resultobj;
19417 fail:
19418 return NULL;
19419 }
19420
19421
19422 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19423 PyObject *resultobj = 0;
19424 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19425 long arg2 ;
19426 void *argp1 = 0 ;
19427 int res1 = 0 ;
19428 long val2 ;
19429 int ecode2 = 0 ;
19430 PyObject * obj0 = 0 ;
19431 PyObject * obj1 = 0 ;
19432 char * kwnames[] = {
19433 (char *) "self",(char *) "extraLong", NULL
19434 };
19435
19436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
19437 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19438 if (!SWIG_IsOK(res1)) {
19439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19440 }
19441 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19442 ecode2 = SWIG_AsVal_long(obj1, &val2);
19443 if (!SWIG_IsOK(ecode2)) {
19444 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
19445 }
19446 arg2 = static_cast< long >(val2);
19447 {
19448 PyThreadState* __tstate = wxPyBeginAllowThreads();
19449 (arg1)->SetExtraLong(arg2);
19450 wxPyEndAllowThreads(__tstate);
19451 if (PyErr_Occurred()) SWIG_fail;
19452 }
19453 resultobj = SWIG_Py_Void();
19454 return resultobj;
19455 fail:
19456 return NULL;
19457 }
19458
19459
19460 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19461 PyObject *resultobj = 0;
19462 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19463 long result;
19464 void *argp1 = 0 ;
19465 int res1 = 0 ;
19466 PyObject *swig_obj[1] ;
19467
19468 if (!args) SWIG_fail;
19469 swig_obj[0] = args;
19470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19471 if (!SWIG_IsOK(res1)) {
19472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19473 }
19474 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19475 {
19476 PyThreadState* __tstate = wxPyBeginAllowThreads();
19477 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
19478 wxPyEndAllowThreads(__tstate);
19479 if (PyErr_Occurred()) SWIG_fail;
19480 }
19481 resultobj = SWIG_From_long(static_cast< long >(result));
19482 return resultobj;
19483 fail:
19484 return NULL;
19485 }
19486
19487
19488 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19489 PyObject *resultobj = 0;
19490 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19491 int arg2 ;
19492 void *argp1 = 0 ;
19493 int res1 = 0 ;
19494 int val2 ;
19495 int ecode2 = 0 ;
19496 PyObject * obj0 = 0 ;
19497 PyObject * obj1 = 0 ;
19498 char * kwnames[] = {
19499 (char *) "self",(char *) "i", NULL
19500 };
19501
19502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
19503 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19504 if (!SWIG_IsOK(res1)) {
19505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19506 }
19507 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19508 ecode2 = SWIG_AsVal_int(obj1, &val2);
19509 if (!SWIG_IsOK(ecode2)) {
19510 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
19511 }
19512 arg2 = static_cast< int >(val2);
19513 {
19514 PyThreadState* __tstate = wxPyBeginAllowThreads();
19515 (arg1)->SetInt(arg2);
19516 wxPyEndAllowThreads(__tstate);
19517 if (PyErr_Occurred()) SWIG_fail;
19518 }
19519 resultobj = SWIG_Py_Void();
19520 return resultobj;
19521 fail:
19522 return NULL;
19523 }
19524
19525
19526 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19527 PyObject *resultobj = 0;
19528 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19529 int result;
19530 void *argp1 = 0 ;
19531 int res1 = 0 ;
19532 PyObject *swig_obj[1] ;
19533
19534 if (!args) SWIG_fail;
19535 swig_obj[0] = args;
19536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19537 if (!SWIG_IsOK(res1)) {
19538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19539 }
19540 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19541 {
19542 PyThreadState* __tstate = wxPyBeginAllowThreads();
19543 result = (int)((wxCommandEvent const *)arg1)->GetInt();
19544 wxPyEndAllowThreads(__tstate);
19545 if (PyErr_Occurred()) SWIG_fail;
19546 }
19547 resultobj = SWIG_From_int(static_cast< int >(result));
19548 return resultobj;
19549 fail:
19550 return NULL;
19551 }
19552
19553
19554 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19555 PyObject *resultobj = 0;
19556 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19557 PyObject *result = 0 ;
19558 void *argp1 = 0 ;
19559 int res1 = 0 ;
19560 PyObject *swig_obj[1] ;
19561
19562 if (!args) SWIG_fail;
19563 swig_obj[0] = args;
19564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19565 if (!SWIG_IsOK(res1)) {
19566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19567 }
19568 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19569 {
19570 PyThreadState* __tstate = wxPyBeginAllowThreads();
19571 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
19572 wxPyEndAllowThreads(__tstate);
19573 if (PyErr_Occurred()) SWIG_fail;
19574 }
19575 resultobj = result;
19576 return resultobj;
19577 fail:
19578 return NULL;
19579 }
19580
19581
19582 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19583 PyObject *resultobj = 0;
19584 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19585 PyObject *arg2 = (PyObject *) 0 ;
19586 void *argp1 = 0 ;
19587 int res1 = 0 ;
19588 PyObject * obj0 = 0 ;
19589 PyObject * obj1 = 0 ;
19590 char * kwnames[] = {
19591 (char *) "self",(char *) "clientData", NULL
19592 };
19593
19594 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
19595 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19596 if (!SWIG_IsOK(res1)) {
19597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19598 }
19599 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19600 arg2 = obj1;
19601 {
19602 PyThreadState* __tstate = wxPyBeginAllowThreads();
19603 wxCommandEvent_SetClientData(arg1,arg2);
19604 wxPyEndAllowThreads(__tstate);
19605 if (PyErr_Occurred()) SWIG_fail;
19606 }
19607 resultobj = SWIG_Py_Void();
19608 return resultobj;
19609 fail:
19610 return NULL;
19611 }
19612
19613
19614 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19615 PyObject *resultobj = 0;
19616 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19617 wxEvent *result = 0 ;
19618 void *argp1 = 0 ;
19619 int res1 = 0 ;
19620 PyObject *swig_obj[1] ;
19621
19622 if (!args) SWIG_fail;
19623 swig_obj[0] = args;
19624 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19625 if (!SWIG_IsOK(res1)) {
19626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19627 }
19628 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19629 {
19630 PyThreadState* __tstate = wxPyBeginAllowThreads();
19631 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
19632 wxPyEndAllowThreads(__tstate);
19633 if (PyErr_Occurred()) SWIG_fail;
19634 }
19635 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
19636 return resultobj;
19637 fail:
19638 return NULL;
19639 }
19640
19641
19642 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19643 PyObject *obj;
19644 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19645 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
19646 return SWIG_Py_Void();
19647 }
19648
19649 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19650 return SWIG_Python_InitShadowInstance(args);
19651 }
19652
19653 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19654 PyObject *resultobj = 0;
19655 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19656 int arg2 = (int) 0 ;
19657 wxNotifyEvent *result = 0 ;
19658 int val1 ;
19659 int ecode1 = 0 ;
19660 int val2 ;
19661 int ecode2 = 0 ;
19662 PyObject * obj0 = 0 ;
19663 PyObject * obj1 = 0 ;
19664 char * kwnames[] = {
19665 (char *) "commandType",(char *) "winid", NULL
19666 };
19667
19668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19669 if (obj0) {
19670 ecode1 = SWIG_AsVal_int(obj0, &val1);
19671 if (!SWIG_IsOK(ecode1)) {
19672 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19673 }
19674 arg1 = static_cast< wxEventType >(val1);
19675 }
19676 if (obj1) {
19677 ecode2 = SWIG_AsVal_int(obj1, &val2);
19678 if (!SWIG_IsOK(ecode2)) {
19679 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
19680 }
19681 arg2 = static_cast< int >(val2);
19682 }
19683 {
19684 PyThreadState* __tstate = wxPyBeginAllowThreads();
19685 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
19686 wxPyEndAllowThreads(__tstate);
19687 if (PyErr_Occurred()) SWIG_fail;
19688 }
19689 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
19690 return resultobj;
19691 fail:
19692 return NULL;
19693 }
19694
19695
19696 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19697 PyObject *resultobj = 0;
19698 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19699 void *argp1 = 0 ;
19700 int res1 = 0 ;
19701 PyObject *swig_obj[1] ;
19702
19703 if (!args) SWIG_fail;
19704 swig_obj[0] = args;
19705 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19706 if (!SWIG_IsOK(res1)) {
19707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19708 }
19709 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19710 {
19711 PyThreadState* __tstate = wxPyBeginAllowThreads();
19712 (arg1)->Veto();
19713 wxPyEndAllowThreads(__tstate);
19714 if (PyErr_Occurred()) SWIG_fail;
19715 }
19716 resultobj = SWIG_Py_Void();
19717 return resultobj;
19718 fail:
19719 return NULL;
19720 }
19721
19722
19723 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19724 PyObject *resultobj = 0;
19725 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19726 void *argp1 = 0 ;
19727 int res1 = 0 ;
19728 PyObject *swig_obj[1] ;
19729
19730 if (!args) SWIG_fail;
19731 swig_obj[0] = args;
19732 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19733 if (!SWIG_IsOK(res1)) {
19734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19735 }
19736 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19737 {
19738 PyThreadState* __tstate = wxPyBeginAllowThreads();
19739 (arg1)->Allow();
19740 wxPyEndAllowThreads(__tstate);
19741 if (PyErr_Occurred()) SWIG_fail;
19742 }
19743 resultobj = SWIG_Py_Void();
19744 return resultobj;
19745 fail:
19746 return NULL;
19747 }
19748
19749
19750 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19751 PyObject *resultobj = 0;
19752 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19753 bool result;
19754 void *argp1 = 0 ;
19755 int res1 = 0 ;
19756 PyObject *swig_obj[1] ;
19757
19758 if (!args) SWIG_fail;
19759 swig_obj[0] = args;
19760 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19761 if (!SWIG_IsOK(res1)) {
19762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19763 }
19764 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19765 {
19766 PyThreadState* __tstate = wxPyBeginAllowThreads();
19767 result = (bool)(arg1)->IsAllowed();
19768 wxPyEndAllowThreads(__tstate);
19769 if (PyErr_Occurred()) SWIG_fail;
19770 }
19771 {
19772 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19773 }
19774 return resultobj;
19775 fail:
19776 return NULL;
19777 }
19778
19779
19780 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19781 PyObject *obj;
19782 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19783 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
19784 return SWIG_Py_Void();
19785 }
19786
19787 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19788 return SWIG_Python_InitShadowInstance(args);
19789 }
19790
19791 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19792 PyObject *resultobj = 0;
19793 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19794 int arg2 = (int) 0 ;
19795 int arg3 = (int) 0 ;
19796 int arg4 = (int) 0 ;
19797 wxScrollEvent *result = 0 ;
19798 int val1 ;
19799 int ecode1 = 0 ;
19800 int val2 ;
19801 int ecode2 = 0 ;
19802 int val3 ;
19803 int ecode3 = 0 ;
19804 int val4 ;
19805 int ecode4 = 0 ;
19806 PyObject * obj0 = 0 ;
19807 PyObject * obj1 = 0 ;
19808 PyObject * obj2 = 0 ;
19809 PyObject * obj3 = 0 ;
19810 char * kwnames[] = {
19811 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
19812 };
19813
19814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19815 if (obj0) {
19816 ecode1 = SWIG_AsVal_int(obj0, &val1);
19817 if (!SWIG_IsOK(ecode1)) {
19818 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19819 }
19820 arg1 = static_cast< wxEventType >(val1);
19821 }
19822 if (obj1) {
19823 ecode2 = SWIG_AsVal_int(obj1, &val2);
19824 if (!SWIG_IsOK(ecode2)) {
19825 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
19826 }
19827 arg2 = static_cast< int >(val2);
19828 }
19829 if (obj2) {
19830 ecode3 = SWIG_AsVal_int(obj2, &val3);
19831 if (!SWIG_IsOK(ecode3)) {
19832 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
19833 }
19834 arg3 = static_cast< int >(val3);
19835 }
19836 if (obj3) {
19837 ecode4 = SWIG_AsVal_int(obj3, &val4);
19838 if (!SWIG_IsOK(ecode4)) {
19839 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
19840 }
19841 arg4 = static_cast< int >(val4);
19842 }
19843 {
19844 PyThreadState* __tstate = wxPyBeginAllowThreads();
19845 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
19846 wxPyEndAllowThreads(__tstate);
19847 if (PyErr_Occurred()) SWIG_fail;
19848 }
19849 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
19850 return resultobj;
19851 fail:
19852 return NULL;
19853 }
19854
19855
19856 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19857 PyObject *resultobj = 0;
19858 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19859 int result;
19860 void *argp1 = 0 ;
19861 int res1 = 0 ;
19862 PyObject *swig_obj[1] ;
19863
19864 if (!args) SWIG_fail;
19865 swig_obj[0] = args;
19866 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19867 if (!SWIG_IsOK(res1)) {
19868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19869 }
19870 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19871 {
19872 PyThreadState* __tstate = wxPyBeginAllowThreads();
19873 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
19874 wxPyEndAllowThreads(__tstate);
19875 if (PyErr_Occurred()) SWIG_fail;
19876 }
19877 resultobj = SWIG_From_int(static_cast< int >(result));
19878 return resultobj;
19879 fail:
19880 return NULL;
19881 }
19882
19883
19884 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19885 PyObject *resultobj = 0;
19886 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19887 int result;
19888 void *argp1 = 0 ;
19889 int res1 = 0 ;
19890 PyObject *swig_obj[1] ;
19891
19892 if (!args) SWIG_fail;
19893 swig_obj[0] = args;
19894 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19895 if (!SWIG_IsOK(res1)) {
19896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19897 }
19898 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19899 {
19900 PyThreadState* __tstate = wxPyBeginAllowThreads();
19901 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
19902 wxPyEndAllowThreads(__tstate);
19903 if (PyErr_Occurred()) SWIG_fail;
19904 }
19905 resultobj = SWIG_From_int(static_cast< int >(result));
19906 return resultobj;
19907 fail:
19908 return NULL;
19909 }
19910
19911
19912 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19913 PyObject *resultobj = 0;
19914 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19915 int arg2 ;
19916 void *argp1 = 0 ;
19917 int res1 = 0 ;
19918 int val2 ;
19919 int ecode2 = 0 ;
19920 PyObject * obj0 = 0 ;
19921 PyObject * obj1 = 0 ;
19922 char * kwnames[] = {
19923 (char *) "self",(char *) "orient", NULL
19924 };
19925
19926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19928 if (!SWIG_IsOK(res1)) {
19929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19930 }
19931 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19932 ecode2 = SWIG_AsVal_int(obj1, &val2);
19933 if (!SWIG_IsOK(ecode2)) {
19934 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19935 }
19936 arg2 = static_cast< int >(val2);
19937 {
19938 PyThreadState* __tstate = wxPyBeginAllowThreads();
19939 (arg1)->SetOrientation(arg2);
19940 wxPyEndAllowThreads(__tstate);
19941 if (PyErr_Occurred()) SWIG_fail;
19942 }
19943 resultobj = SWIG_Py_Void();
19944 return resultobj;
19945 fail:
19946 return NULL;
19947 }
19948
19949
19950 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19951 PyObject *resultobj = 0;
19952 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19953 int arg2 ;
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 *) "pos", NULL
19962 };
19963
19964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19965 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19966 if (!SWIG_IsOK(res1)) {
19967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19968 }
19969 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19970 ecode2 = SWIG_AsVal_int(obj1, &val2);
19971 if (!SWIG_IsOK(ecode2)) {
19972 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19973 }
19974 arg2 = static_cast< int >(val2);
19975 {
19976 PyThreadState* __tstate = wxPyBeginAllowThreads();
19977 (arg1)->SetPosition(arg2);
19978 wxPyEndAllowThreads(__tstate);
19979 if (PyErr_Occurred()) SWIG_fail;
19980 }
19981 resultobj = SWIG_Py_Void();
19982 return resultobj;
19983 fail:
19984 return NULL;
19985 }
19986
19987
19988 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19989 PyObject *obj;
19990 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19991 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
19992 return SWIG_Py_Void();
19993 }
19994
19995 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19996 return SWIG_Python_InitShadowInstance(args);
19997 }
19998
19999 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20000 PyObject *resultobj = 0;
20001 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20002 int arg2 = (int) 0 ;
20003 int arg3 = (int) 0 ;
20004 wxScrollWinEvent *result = 0 ;
20005 int val1 ;
20006 int ecode1 = 0 ;
20007 int val2 ;
20008 int ecode2 = 0 ;
20009 int val3 ;
20010 int ecode3 = 0 ;
20011 PyObject * obj0 = 0 ;
20012 PyObject * obj1 = 0 ;
20013 PyObject * obj2 = 0 ;
20014 char * kwnames[] = {
20015 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
20016 };
20017
20018 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20019 if (obj0) {
20020 ecode1 = SWIG_AsVal_int(obj0, &val1);
20021 if (!SWIG_IsOK(ecode1)) {
20022 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
20023 }
20024 arg1 = static_cast< wxEventType >(val1);
20025 }
20026 if (obj1) {
20027 ecode2 = SWIG_AsVal_int(obj1, &val2);
20028 if (!SWIG_IsOK(ecode2)) {
20029 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
20030 }
20031 arg2 = static_cast< int >(val2);
20032 }
20033 if (obj2) {
20034 ecode3 = SWIG_AsVal_int(obj2, &val3);
20035 if (!SWIG_IsOK(ecode3)) {
20036 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
20037 }
20038 arg3 = static_cast< int >(val3);
20039 }
20040 {
20041 PyThreadState* __tstate = wxPyBeginAllowThreads();
20042 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
20043 wxPyEndAllowThreads(__tstate);
20044 if (PyErr_Occurred()) SWIG_fail;
20045 }
20046 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
20047 return resultobj;
20048 fail:
20049 return NULL;
20050 }
20051
20052
20053 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20054 PyObject *resultobj = 0;
20055 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
20056 int result;
20057 void *argp1 = 0 ;
20058 int res1 = 0 ;
20059 PyObject *swig_obj[1] ;
20060
20061 if (!args) SWIG_fail;
20062 swig_obj[0] = args;
20063 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
20064 if (!SWIG_IsOK(res1)) {
20065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
20066 }
20067 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
20068 {
20069 PyThreadState* __tstate = wxPyBeginAllowThreads();
20070 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
20071 wxPyEndAllowThreads(__tstate);
20072 if (PyErr_Occurred()) SWIG_fail;
20073 }
20074 resultobj = SWIG_From_int(static_cast< int >(result));
20075 return resultobj;
20076 fail:
20077 return NULL;
20078 }
20079
20080
20081 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20082 PyObject *resultobj = 0;
20083 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
20084 int result;
20085 void *argp1 = 0 ;
20086 int res1 = 0 ;
20087 PyObject *swig_obj[1] ;
20088
20089 if (!args) SWIG_fail;
20090 swig_obj[0] = args;
20091 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
20092 if (!SWIG_IsOK(res1)) {
20093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
20094 }
20095 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
20096 {
20097 PyThreadState* __tstate = wxPyBeginAllowThreads();
20098 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
20099 wxPyEndAllowThreads(__tstate);
20100 if (PyErr_Occurred()) SWIG_fail;
20101 }
20102 resultobj = SWIG_From_int(static_cast< int >(result));
20103 return resultobj;
20104 fail:
20105 return NULL;
20106 }
20107
20108
20109 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20110 PyObject *resultobj = 0;
20111 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
20112 int arg2 ;
20113 void *argp1 = 0 ;
20114 int res1 = 0 ;
20115 int val2 ;
20116 int ecode2 = 0 ;
20117 PyObject * obj0 = 0 ;
20118 PyObject * obj1 = 0 ;
20119 char * kwnames[] = {
20120 (char *) "self",(char *) "orient", NULL
20121 };
20122
20123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
20124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
20125 if (!SWIG_IsOK(res1)) {
20126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
20127 }
20128 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
20129 ecode2 = SWIG_AsVal_int(obj1, &val2);
20130 if (!SWIG_IsOK(ecode2)) {
20131 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
20132 }
20133 arg2 = static_cast< int >(val2);
20134 {
20135 PyThreadState* __tstate = wxPyBeginAllowThreads();
20136 (arg1)->SetOrientation(arg2);
20137 wxPyEndAllowThreads(__tstate);
20138 if (PyErr_Occurred()) SWIG_fail;
20139 }
20140 resultobj = SWIG_Py_Void();
20141 return resultobj;
20142 fail:
20143 return NULL;
20144 }
20145
20146
20147 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20148 PyObject *resultobj = 0;
20149 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
20150 int arg2 ;
20151 void *argp1 = 0 ;
20152 int res1 = 0 ;
20153 int val2 ;
20154 int ecode2 = 0 ;
20155 PyObject * obj0 = 0 ;
20156 PyObject * obj1 = 0 ;
20157 char * kwnames[] = {
20158 (char *) "self",(char *) "pos", NULL
20159 };
20160
20161 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
20162 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
20163 if (!SWIG_IsOK(res1)) {
20164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
20165 }
20166 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
20167 ecode2 = SWIG_AsVal_int(obj1, &val2);
20168 if (!SWIG_IsOK(ecode2)) {
20169 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
20170 }
20171 arg2 = static_cast< int >(val2);
20172 {
20173 PyThreadState* __tstate = wxPyBeginAllowThreads();
20174 (arg1)->SetPosition(arg2);
20175 wxPyEndAllowThreads(__tstate);
20176 if (PyErr_Occurred()) SWIG_fail;
20177 }
20178 resultobj = SWIG_Py_Void();
20179 return resultobj;
20180 fail:
20181 return NULL;
20182 }
20183
20184
20185 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20186 PyObject *obj;
20187 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20188 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
20189 return SWIG_Py_Void();
20190 }
20191
20192 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20193 return SWIG_Python_InitShadowInstance(args);
20194 }
20195
20196 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20197 PyObject *resultobj = 0;
20198 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20199 wxMouseEvent *result = 0 ;
20200 int val1 ;
20201 int ecode1 = 0 ;
20202 PyObject * obj0 = 0 ;
20203 char * kwnames[] = {
20204 (char *) "mouseType", NULL
20205 };
20206
20207 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
20208 if (obj0) {
20209 ecode1 = SWIG_AsVal_int(obj0, &val1);
20210 if (!SWIG_IsOK(ecode1)) {
20211 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
20212 }
20213 arg1 = static_cast< wxEventType >(val1);
20214 }
20215 {
20216 PyThreadState* __tstate = wxPyBeginAllowThreads();
20217 result = (wxMouseEvent *)new wxMouseEvent(arg1);
20218 wxPyEndAllowThreads(__tstate);
20219 if (PyErr_Occurred()) SWIG_fail;
20220 }
20221 {
20222 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
20223 }
20224 return resultobj;
20225 fail:
20226 return NULL;
20227 }
20228
20229
20230 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20231 PyObject *resultobj = 0;
20232 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20233 bool result;
20234 void *argp1 = 0 ;
20235 int res1 = 0 ;
20236 PyObject *swig_obj[1] ;
20237
20238 if (!args) SWIG_fail;
20239 swig_obj[0] = args;
20240 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20241 if (!SWIG_IsOK(res1)) {
20242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20243 }
20244 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20245 {
20246 PyThreadState* __tstate = wxPyBeginAllowThreads();
20247 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
20248 wxPyEndAllowThreads(__tstate);
20249 if (PyErr_Occurred()) SWIG_fail;
20250 }
20251 {
20252 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20253 }
20254 return resultobj;
20255 fail:
20256 return NULL;
20257 }
20258
20259
20260 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20261 PyObject *resultobj = 0;
20262 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20263 int arg2 = (int) wxMOUSE_BTN_ANY ;
20264 bool result;
20265 void *argp1 = 0 ;
20266 int res1 = 0 ;
20267 int val2 ;
20268 int ecode2 = 0 ;
20269 PyObject * obj0 = 0 ;
20270 PyObject * obj1 = 0 ;
20271 char * kwnames[] = {
20272 (char *) "self",(char *) "but", NULL
20273 };
20274
20275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
20276 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20277 if (!SWIG_IsOK(res1)) {
20278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20279 }
20280 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20281 if (obj1) {
20282 ecode2 = SWIG_AsVal_int(obj1, &val2);
20283 if (!SWIG_IsOK(ecode2)) {
20284 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
20285 }
20286 arg2 = static_cast< int >(val2);
20287 }
20288 {
20289 PyThreadState* __tstate = wxPyBeginAllowThreads();
20290 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
20291 wxPyEndAllowThreads(__tstate);
20292 if (PyErr_Occurred()) SWIG_fail;
20293 }
20294 {
20295 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20296 }
20297 return resultobj;
20298 fail:
20299 return NULL;
20300 }
20301
20302
20303 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20304 PyObject *resultobj = 0;
20305 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20306 int arg2 = (int) wxMOUSE_BTN_ANY ;
20307 bool result;
20308 void *argp1 = 0 ;
20309 int res1 = 0 ;
20310 int val2 ;
20311 int ecode2 = 0 ;
20312 PyObject * obj0 = 0 ;
20313 PyObject * obj1 = 0 ;
20314 char * kwnames[] = {
20315 (char *) "self",(char *) "but", NULL
20316 };
20317
20318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
20319 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20320 if (!SWIG_IsOK(res1)) {
20321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20322 }
20323 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20324 if (obj1) {
20325 ecode2 = SWIG_AsVal_int(obj1, &val2);
20326 if (!SWIG_IsOK(ecode2)) {
20327 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
20328 }
20329 arg2 = static_cast< int >(val2);
20330 }
20331 {
20332 PyThreadState* __tstate = wxPyBeginAllowThreads();
20333 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
20334 wxPyEndAllowThreads(__tstate);
20335 if (PyErr_Occurred()) SWIG_fail;
20336 }
20337 {
20338 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20339 }
20340 return resultobj;
20341 fail:
20342 return NULL;
20343 }
20344
20345
20346 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20347 PyObject *resultobj = 0;
20348 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20349 int arg2 = (int) wxMOUSE_BTN_ANY ;
20350 bool result;
20351 void *argp1 = 0 ;
20352 int res1 = 0 ;
20353 int val2 ;
20354 int ecode2 = 0 ;
20355 PyObject * obj0 = 0 ;
20356 PyObject * obj1 = 0 ;
20357 char * kwnames[] = {
20358 (char *) "self",(char *) "but", NULL
20359 };
20360
20361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
20362 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20363 if (!SWIG_IsOK(res1)) {
20364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20365 }
20366 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20367 if (obj1) {
20368 ecode2 = SWIG_AsVal_int(obj1, &val2);
20369 if (!SWIG_IsOK(ecode2)) {
20370 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
20371 }
20372 arg2 = static_cast< int >(val2);
20373 }
20374 {
20375 PyThreadState* __tstate = wxPyBeginAllowThreads();
20376 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
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_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20390 PyObject *resultobj = 0;
20391 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20392 int arg2 ;
20393 bool result;
20394 void *argp1 = 0 ;
20395 int res1 = 0 ;
20396 int val2 ;
20397 int ecode2 = 0 ;
20398 PyObject * obj0 = 0 ;
20399 PyObject * obj1 = 0 ;
20400 char * kwnames[] = {
20401 (char *) "self",(char *) "button", NULL
20402 };
20403
20404 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
20405 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20406 if (!SWIG_IsOK(res1)) {
20407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20408 }
20409 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20410 ecode2 = SWIG_AsVal_int(obj1, &val2);
20411 if (!SWIG_IsOK(ecode2)) {
20412 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
20413 }
20414 arg2 = static_cast< int >(val2);
20415 {
20416 PyThreadState* __tstate = wxPyBeginAllowThreads();
20417 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
20418 wxPyEndAllowThreads(__tstate);
20419 if (PyErr_Occurred()) SWIG_fail;
20420 }
20421 {
20422 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20423 }
20424 return resultobj;
20425 fail:
20426 return NULL;
20427 }
20428
20429
20430 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20431 PyObject *resultobj = 0;
20432 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20433 int arg2 ;
20434 bool result;
20435 void *argp1 = 0 ;
20436 int res1 = 0 ;
20437 int val2 ;
20438 int ecode2 = 0 ;
20439 PyObject * obj0 = 0 ;
20440 PyObject * obj1 = 0 ;
20441 char * kwnames[] = {
20442 (char *) "self",(char *) "but", NULL
20443 };
20444
20445 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
20446 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20447 if (!SWIG_IsOK(res1)) {
20448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20449 }
20450 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20451 ecode2 = SWIG_AsVal_int(obj1, &val2);
20452 if (!SWIG_IsOK(ecode2)) {
20453 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
20454 }
20455 arg2 = static_cast< int >(val2);
20456 {
20457 PyThreadState* __tstate = wxPyBeginAllowThreads();
20458 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
20459 wxPyEndAllowThreads(__tstate);
20460 if (PyErr_Occurred()) SWIG_fail;
20461 }
20462 {
20463 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20464 }
20465 return resultobj;
20466 fail:
20467 return NULL;
20468 }
20469
20470
20471 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20472 PyObject *resultobj = 0;
20473 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20474 int result;
20475 void *argp1 = 0 ;
20476 int res1 = 0 ;
20477 PyObject *swig_obj[1] ;
20478
20479 if (!args) SWIG_fail;
20480 swig_obj[0] = args;
20481 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20482 if (!SWIG_IsOK(res1)) {
20483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20484 }
20485 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20486 {
20487 PyThreadState* __tstate = wxPyBeginAllowThreads();
20488 result = (int)((wxMouseEvent const *)arg1)->GetButton();
20489 wxPyEndAllowThreads(__tstate);
20490 if (PyErr_Occurred()) SWIG_fail;
20491 }
20492 resultobj = SWIG_From_int(static_cast< int >(result));
20493 return resultobj;
20494 fail:
20495 return NULL;
20496 }
20497
20498
20499 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20500 PyObject *resultobj = 0;
20501 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20502 bool result;
20503 void *argp1 = 0 ;
20504 int res1 = 0 ;
20505 PyObject *swig_obj[1] ;
20506
20507 if (!args) SWIG_fail;
20508 swig_obj[0] = args;
20509 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20510 if (!SWIG_IsOK(res1)) {
20511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20512 }
20513 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20514 {
20515 PyThreadState* __tstate = wxPyBeginAllowThreads();
20516 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
20517 wxPyEndAllowThreads(__tstate);
20518 if (PyErr_Occurred()) SWIG_fail;
20519 }
20520 {
20521 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20522 }
20523 return resultobj;
20524 fail:
20525 return NULL;
20526 }
20527
20528
20529 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20530 PyObject *resultobj = 0;
20531 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20532 bool result;
20533 void *argp1 = 0 ;
20534 int res1 = 0 ;
20535 PyObject *swig_obj[1] ;
20536
20537 if (!args) SWIG_fail;
20538 swig_obj[0] = args;
20539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20540 if (!SWIG_IsOK(res1)) {
20541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20542 }
20543 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20544 {
20545 PyThreadState* __tstate = wxPyBeginAllowThreads();
20546 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
20547 wxPyEndAllowThreads(__tstate);
20548 if (PyErr_Occurred()) SWIG_fail;
20549 }
20550 {
20551 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20552 }
20553 return resultobj;
20554 fail:
20555 return NULL;
20556 }
20557
20558
20559 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20560 PyObject *resultobj = 0;
20561 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20562 bool result;
20563 void *argp1 = 0 ;
20564 int res1 = 0 ;
20565 PyObject *swig_obj[1] ;
20566
20567 if (!args) SWIG_fail;
20568 swig_obj[0] = args;
20569 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20570 if (!SWIG_IsOK(res1)) {
20571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20572 }
20573 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20574 {
20575 PyThreadState* __tstate = wxPyBeginAllowThreads();
20576 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
20577 wxPyEndAllowThreads(__tstate);
20578 if (PyErr_Occurred()) SWIG_fail;
20579 }
20580 {
20581 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20582 }
20583 return resultobj;
20584 fail:
20585 return NULL;
20586 }
20587
20588
20589 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20590 PyObject *resultobj = 0;
20591 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20592 bool result;
20593 void *argp1 = 0 ;
20594 int res1 = 0 ;
20595 PyObject *swig_obj[1] ;
20596
20597 if (!args) SWIG_fail;
20598 swig_obj[0] = args;
20599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20600 if (!SWIG_IsOK(res1)) {
20601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20602 }
20603 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20604 {
20605 PyThreadState* __tstate = wxPyBeginAllowThreads();
20606 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
20607 wxPyEndAllowThreads(__tstate);
20608 if (PyErr_Occurred()) SWIG_fail;
20609 }
20610 {
20611 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20612 }
20613 return resultobj;
20614 fail:
20615 return NULL;
20616 }
20617
20618
20619 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20620 PyObject *resultobj = 0;
20621 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20622 bool result;
20623 void *argp1 = 0 ;
20624 int res1 = 0 ;
20625 PyObject *swig_obj[1] ;
20626
20627 if (!args) SWIG_fail;
20628 swig_obj[0] = args;
20629 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20630 if (!SWIG_IsOK(res1)) {
20631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20632 }
20633 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20634 {
20635 PyThreadState* __tstate = wxPyBeginAllowThreads();
20636 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
20637 wxPyEndAllowThreads(__tstate);
20638 if (PyErr_Occurred()) SWIG_fail;
20639 }
20640 {
20641 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20642 }
20643 return resultobj;
20644 fail:
20645 return NULL;
20646 }
20647
20648
20649 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20650 PyObject *resultobj = 0;
20651 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20652 bool result;
20653 void *argp1 = 0 ;
20654 int res1 = 0 ;
20655 PyObject *swig_obj[1] ;
20656
20657 if (!args) SWIG_fail;
20658 swig_obj[0] = args;
20659 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20660 if (!SWIG_IsOK(res1)) {
20661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20662 }
20663 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20664 {
20665 PyThreadState* __tstate = wxPyBeginAllowThreads();
20666 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
20667 wxPyEndAllowThreads(__tstate);
20668 if (PyErr_Occurred()) SWIG_fail;
20669 }
20670 {
20671 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20672 }
20673 return resultobj;
20674 fail:
20675 return NULL;
20676 }
20677
20678
20679 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20680 PyObject *resultobj = 0;
20681 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20682 bool result;
20683 void *argp1 = 0 ;
20684 int res1 = 0 ;
20685 PyObject *swig_obj[1] ;
20686
20687 if (!args) SWIG_fail;
20688 swig_obj[0] = args;
20689 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20690 if (!SWIG_IsOK(res1)) {
20691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20692 }
20693 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20694 {
20695 PyThreadState* __tstate = wxPyBeginAllowThreads();
20696 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
20697 wxPyEndAllowThreads(__tstate);
20698 if (PyErr_Occurred()) SWIG_fail;
20699 }
20700 {
20701 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20702 }
20703 return resultobj;
20704 fail:
20705 return NULL;
20706 }
20707
20708
20709 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20710 PyObject *resultobj = 0;
20711 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20712 bool result;
20713 void *argp1 = 0 ;
20714 int res1 = 0 ;
20715 PyObject *swig_obj[1] ;
20716
20717 if (!args) SWIG_fail;
20718 swig_obj[0] = args;
20719 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20720 if (!SWIG_IsOK(res1)) {
20721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20722 }
20723 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20724 {
20725 PyThreadState* __tstate = wxPyBeginAllowThreads();
20726 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
20727 wxPyEndAllowThreads(__tstate);
20728 if (PyErr_Occurred()) SWIG_fail;
20729 }
20730 {
20731 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20732 }
20733 return resultobj;
20734 fail:
20735 return NULL;
20736 }
20737
20738
20739 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20740 PyObject *resultobj = 0;
20741 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20742 bool result;
20743 void *argp1 = 0 ;
20744 int res1 = 0 ;
20745 PyObject *swig_obj[1] ;
20746
20747 if (!args) SWIG_fail;
20748 swig_obj[0] = args;
20749 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20750 if (!SWIG_IsOK(res1)) {
20751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20752 }
20753 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20754 {
20755 PyThreadState* __tstate = wxPyBeginAllowThreads();
20756 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
20757 wxPyEndAllowThreads(__tstate);
20758 if (PyErr_Occurred()) SWIG_fail;
20759 }
20760 {
20761 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20762 }
20763 return resultobj;
20764 fail:
20765 return NULL;
20766 }
20767
20768
20769 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20770 PyObject *resultobj = 0;
20771 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20772 bool result;
20773 void *argp1 = 0 ;
20774 int res1 = 0 ;
20775 PyObject *swig_obj[1] ;
20776
20777 if (!args) SWIG_fail;
20778 swig_obj[0] = args;
20779 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20780 if (!SWIG_IsOK(res1)) {
20781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20782 }
20783 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20784 {
20785 PyThreadState* __tstate = wxPyBeginAllowThreads();
20786 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
20787 wxPyEndAllowThreads(__tstate);
20788 if (PyErr_Occurred()) SWIG_fail;
20789 }
20790 {
20791 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20792 }
20793 return resultobj;
20794 fail:
20795 return NULL;
20796 }
20797
20798
20799 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20800 PyObject *resultobj = 0;
20801 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20802 bool result;
20803 void *argp1 = 0 ;
20804 int res1 = 0 ;
20805 PyObject *swig_obj[1] ;
20806
20807 if (!args) SWIG_fail;
20808 swig_obj[0] = args;
20809 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20810 if (!SWIG_IsOK(res1)) {
20811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20812 }
20813 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20814 {
20815 PyThreadState* __tstate = wxPyBeginAllowThreads();
20816 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
20817 wxPyEndAllowThreads(__tstate);
20818 if (PyErr_Occurred()) SWIG_fail;
20819 }
20820 {
20821 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20822 }
20823 return resultobj;
20824 fail:
20825 return NULL;
20826 }
20827
20828
20829 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20830 PyObject *resultobj = 0;
20831 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20832 bool result;
20833 void *argp1 = 0 ;
20834 int res1 = 0 ;
20835 PyObject *swig_obj[1] ;
20836
20837 if (!args) SWIG_fail;
20838 swig_obj[0] = args;
20839 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20840 if (!SWIG_IsOK(res1)) {
20841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20842 }
20843 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20844 {
20845 PyThreadState* __tstate = wxPyBeginAllowThreads();
20846 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
20847 wxPyEndAllowThreads(__tstate);
20848 if (PyErr_Occurred()) SWIG_fail;
20849 }
20850 {
20851 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20852 }
20853 return resultobj;
20854 fail:
20855 return NULL;
20856 }
20857
20858
20859 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20860 PyObject *resultobj = 0;
20861 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20862 bool result;
20863 void *argp1 = 0 ;
20864 int res1 = 0 ;
20865 PyObject *swig_obj[1] ;
20866
20867 if (!args) SWIG_fail;
20868 swig_obj[0] = args;
20869 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20870 if (!SWIG_IsOK(res1)) {
20871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20872 }
20873 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20874 {
20875 PyThreadState* __tstate = wxPyBeginAllowThreads();
20876 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
20877 wxPyEndAllowThreads(__tstate);
20878 if (PyErr_Occurred()) SWIG_fail;
20879 }
20880 {
20881 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20882 }
20883 return resultobj;
20884 fail:
20885 return NULL;
20886 }
20887
20888
20889 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20890 PyObject *resultobj = 0;
20891 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20892 bool result;
20893 void *argp1 = 0 ;
20894 int res1 = 0 ;
20895 PyObject *swig_obj[1] ;
20896
20897 if (!args) SWIG_fail;
20898 swig_obj[0] = args;
20899 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20900 if (!SWIG_IsOK(res1)) {
20901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20902 }
20903 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20904 {
20905 PyThreadState* __tstate = wxPyBeginAllowThreads();
20906 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
20907 wxPyEndAllowThreads(__tstate);
20908 if (PyErr_Occurred()) SWIG_fail;
20909 }
20910 {
20911 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20912 }
20913 return resultobj;
20914 fail:
20915 return NULL;
20916 }
20917
20918
20919 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20920 PyObject *resultobj = 0;
20921 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20922 bool result;
20923 void *argp1 = 0 ;
20924 int res1 = 0 ;
20925 PyObject *swig_obj[1] ;
20926
20927 if (!args) SWIG_fail;
20928 swig_obj[0] = args;
20929 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20930 if (!SWIG_IsOK(res1)) {
20931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20932 }
20933 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20934 {
20935 PyThreadState* __tstate = wxPyBeginAllowThreads();
20936 result = (bool)(arg1)->LeftIsDown();
20937 wxPyEndAllowThreads(__tstate);
20938 if (PyErr_Occurred()) SWIG_fail;
20939 }
20940 {
20941 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20942 }
20943 return resultobj;
20944 fail:
20945 return NULL;
20946 }
20947
20948
20949 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20950 PyObject *resultobj = 0;
20951 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20952 bool result;
20953 void *argp1 = 0 ;
20954 int res1 = 0 ;
20955 PyObject *swig_obj[1] ;
20956
20957 if (!args) SWIG_fail;
20958 swig_obj[0] = args;
20959 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20960 if (!SWIG_IsOK(res1)) {
20961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20962 }
20963 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20964 {
20965 PyThreadState* __tstate = wxPyBeginAllowThreads();
20966 result = (bool)(arg1)->MiddleIsDown();
20967 wxPyEndAllowThreads(__tstate);
20968 if (PyErr_Occurred()) SWIG_fail;
20969 }
20970 {
20971 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20972 }
20973 return resultobj;
20974 fail:
20975 return NULL;
20976 }
20977
20978
20979 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20980 PyObject *resultobj = 0;
20981 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20982 bool result;
20983 void *argp1 = 0 ;
20984 int res1 = 0 ;
20985 PyObject *swig_obj[1] ;
20986
20987 if (!args) SWIG_fail;
20988 swig_obj[0] = args;
20989 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20990 if (!SWIG_IsOK(res1)) {
20991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20992 }
20993 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20994 {
20995 PyThreadState* __tstate = wxPyBeginAllowThreads();
20996 result = (bool)(arg1)->RightIsDown();
20997 wxPyEndAllowThreads(__tstate);
20998 if (PyErr_Occurred()) SWIG_fail;
20999 }
21000 {
21001 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21002 }
21003 return resultobj;
21004 fail:
21005 return NULL;
21006 }
21007
21008
21009 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21010 PyObject *resultobj = 0;
21011 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21012 bool result;
21013 void *argp1 = 0 ;
21014 int res1 = 0 ;
21015 PyObject *swig_obj[1] ;
21016
21017 if (!args) SWIG_fail;
21018 swig_obj[0] = args;
21019 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21020 if (!SWIG_IsOK(res1)) {
21021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21022 }
21023 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21024 {
21025 PyThreadState* __tstate = wxPyBeginAllowThreads();
21026 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
21027 wxPyEndAllowThreads(__tstate);
21028 if (PyErr_Occurred()) SWIG_fail;
21029 }
21030 {
21031 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21032 }
21033 return resultobj;
21034 fail:
21035 return NULL;
21036 }
21037
21038
21039 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21040 PyObject *resultobj = 0;
21041 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21042 bool result;
21043 void *argp1 = 0 ;
21044 int res1 = 0 ;
21045 PyObject *swig_obj[1] ;
21046
21047 if (!args) SWIG_fail;
21048 swig_obj[0] = args;
21049 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21050 if (!SWIG_IsOK(res1)) {
21051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21052 }
21053 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21054 {
21055 PyThreadState* __tstate = wxPyBeginAllowThreads();
21056 result = (bool)((wxMouseEvent const *)arg1)->Moving();
21057 wxPyEndAllowThreads(__tstate);
21058 if (PyErr_Occurred()) SWIG_fail;
21059 }
21060 {
21061 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21062 }
21063 return resultobj;
21064 fail:
21065 return NULL;
21066 }
21067
21068
21069 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21070 PyObject *resultobj = 0;
21071 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21072 bool result;
21073 void *argp1 = 0 ;
21074 int res1 = 0 ;
21075 PyObject *swig_obj[1] ;
21076
21077 if (!args) SWIG_fail;
21078 swig_obj[0] = args;
21079 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21080 if (!SWIG_IsOK(res1)) {
21081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21082 }
21083 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21084 {
21085 PyThreadState* __tstate = wxPyBeginAllowThreads();
21086 result = (bool)((wxMouseEvent const *)arg1)->Entering();
21087 wxPyEndAllowThreads(__tstate);
21088 if (PyErr_Occurred()) SWIG_fail;
21089 }
21090 {
21091 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21092 }
21093 return resultobj;
21094 fail:
21095 return NULL;
21096 }
21097
21098
21099 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21100 PyObject *resultobj = 0;
21101 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21102 bool result;
21103 void *argp1 = 0 ;
21104 int res1 = 0 ;
21105 PyObject *swig_obj[1] ;
21106
21107 if (!args) SWIG_fail;
21108 swig_obj[0] = args;
21109 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21110 if (!SWIG_IsOK(res1)) {
21111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21112 }
21113 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21114 {
21115 PyThreadState* __tstate = wxPyBeginAllowThreads();
21116 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
21117 wxPyEndAllowThreads(__tstate);
21118 if (PyErr_Occurred()) SWIG_fail;
21119 }
21120 {
21121 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21122 }
21123 return resultobj;
21124 fail:
21125 return NULL;
21126 }
21127
21128
21129 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21130 PyObject *resultobj = 0;
21131 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21132 wxPoint result;
21133 void *argp1 = 0 ;
21134 int res1 = 0 ;
21135 PyObject *swig_obj[1] ;
21136
21137 if (!args) SWIG_fail;
21138 swig_obj[0] = args;
21139 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21140 if (!SWIG_IsOK(res1)) {
21141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21142 }
21143 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21144 {
21145 PyThreadState* __tstate = wxPyBeginAllowThreads();
21146 result = (arg1)->GetPosition();
21147 wxPyEndAllowThreads(__tstate);
21148 if (PyErr_Occurred()) SWIG_fail;
21149 }
21150 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
21151 return resultobj;
21152 fail:
21153 return NULL;
21154 }
21155
21156
21157 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21158 PyObject *resultobj = 0;
21159 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21160 long *arg2 = (long *) 0 ;
21161 long *arg3 = (long *) 0 ;
21162 void *argp1 = 0 ;
21163 int res1 = 0 ;
21164 long temp2 ;
21165 int res2 = SWIG_TMPOBJ ;
21166 long temp3 ;
21167 int res3 = SWIG_TMPOBJ ;
21168 PyObject *swig_obj[1] ;
21169
21170 arg2 = &temp2;
21171 arg3 = &temp3;
21172 if (!args) SWIG_fail;
21173 swig_obj[0] = args;
21174 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21175 if (!SWIG_IsOK(res1)) {
21176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21177 }
21178 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21179 {
21180 PyThreadState* __tstate = wxPyBeginAllowThreads();
21181 (arg1)->GetPosition(arg2,arg3);
21182 wxPyEndAllowThreads(__tstate);
21183 if (PyErr_Occurred()) SWIG_fail;
21184 }
21185 resultobj = SWIG_Py_Void();
21186 if (SWIG_IsTmpObj(res2)) {
21187 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
21188 } else {
21189 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21190 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
21191 }
21192 if (SWIG_IsTmpObj(res3)) {
21193 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
21194 } else {
21195 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21196 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
21197 }
21198 return resultobj;
21199 fail:
21200 return NULL;
21201 }
21202
21203
21204 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21205 PyObject *resultobj = 0;
21206 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21207 wxDC *arg2 = 0 ;
21208 wxPoint result;
21209 void *argp1 = 0 ;
21210 int res1 = 0 ;
21211 void *argp2 = 0 ;
21212 int res2 = 0 ;
21213 PyObject * obj0 = 0 ;
21214 PyObject * obj1 = 0 ;
21215 char * kwnames[] = {
21216 (char *) "self",(char *) "dc", NULL
21217 };
21218
21219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
21220 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21221 if (!SWIG_IsOK(res1)) {
21222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21223 }
21224 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21225 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
21226 if (!SWIG_IsOK(res2)) {
21227 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
21228 }
21229 if (!argp2) {
21230 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
21231 }
21232 arg2 = reinterpret_cast< wxDC * >(argp2);
21233 {
21234 PyThreadState* __tstate = wxPyBeginAllowThreads();
21235 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
21236 wxPyEndAllowThreads(__tstate);
21237 if (PyErr_Occurred()) SWIG_fail;
21238 }
21239 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
21240 return resultobj;
21241 fail:
21242 return NULL;
21243 }
21244
21245
21246 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21247 PyObject *resultobj = 0;
21248 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21249 int result;
21250 void *argp1 = 0 ;
21251 int res1 = 0 ;
21252 PyObject *swig_obj[1] ;
21253
21254 if (!args) SWIG_fail;
21255 swig_obj[0] = args;
21256 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21257 if (!SWIG_IsOK(res1)) {
21258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21259 }
21260 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21261 {
21262 PyThreadState* __tstate = wxPyBeginAllowThreads();
21263 result = (int)((wxMouseEvent const *)arg1)->GetX();
21264 wxPyEndAllowThreads(__tstate);
21265 if (PyErr_Occurred()) SWIG_fail;
21266 }
21267 resultobj = SWIG_From_int(static_cast< int >(result));
21268 return resultobj;
21269 fail:
21270 return NULL;
21271 }
21272
21273
21274 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21275 PyObject *resultobj = 0;
21276 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21277 int result;
21278 void *argp1 = 0 ;
21279 int res1 = 0 ;
21280 PyObject *swig_obj[1] ;
21281
21282 if (!args) SWIG_fail;
21283 swig_obj[0] = args;
21284 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21285 if (!SWIG_IsOK(res1)) {
21286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21287 }
21288 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21289 {
21290 PyThreadState* __tstate = wxPyBeginAllowThreads();
21291 result = (int)((wxMouseEvent const *)arg1)->GetY();
21292 wxPyEndAllowThreads(__tstate);
21293 if (PyErr_Occurred()) SWIG_fail;
21294 }
21295 resultobj = SWIG_From_int(static_cast< int >(result));
21296 return resultobj;
21297 fail:
21298 return NULL;
21299 }
21300
21301
21302 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21303 PyObject *resultobj = 0;
21304 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21305 int result;
21306 void *argp1 = 0 ;
21307 int res1 = 0 ;
21308 PyObject *swig_obj[1] ;
21309
21310 if (!args) SWIG_fail;
21311 swig_obj[0] = args;
21312 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21313 if (!SWIG_IsOK(res1)) {
21314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21315 }
21316 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21317 {
21318 PyThreadState* __tstate = wxPyBeginAllowThreads();
21319 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
21320 wxPyEndAllowThreads(__tstate);
21321 if (PyErr_Occurred()) SWIG_fail;
21322 }
21323 resultobj = SWIG_From_int(static_cast< int >(result));
21324 return resultobj;
21325 fail:
21326 return NULL;
21327 }
21328
21329
21330 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21331 PyObject *resultobj = 0;
21332 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21333 int result;
21334 void *argp1 = 0 ;
21335 int res1 = 0 ;
21336 PyObject *swig_obj[1] ;
21337
21338 if (!args) SWIG_fail;
21339 swig_obj[0] = args;
21340 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21341 if (!SWIG_IsOK(res1)) {
21342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21343 }
21344 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21345 {
21346 PyThreadState* __tstate = wxPyBeginAllowThreads();
21347 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
21348 wxPyEndAllowThreads(__tstate);
21349 if (PyErr_Occurred()) SWIG_fail;
21350 }
21351 resultobj = SWIG_From_int(static_cast< int >(result));
21352 return resultobj;
21353 fail:
21354 return NULL;
21355 }
21356
21357
21358 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21359 PyObject *resultobj = 0;
21360 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21361 int result;
21362 void *argp1 = 0 ;
21363 int res1 = 0 ;
21364 PyObject *swig_obj[1] ;
21365
21366 if (!args) SWIG_fail;
21367 swig_obj[0] = args;
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_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21371 }
21372 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21373 {
21374 PyThreadState* __tstate = wxPyBeginAllowThreads();
21375 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
21376 wxPyEndAllowThreads(__tstate);
21377 if (PyErr_Occurred()) SWIG_fail;
21378 }
21379 resultobj = SWIG_From_int(static_cast< int >(result));
21380 return resultobj;
21381 fail:
21382 return NULL;
21383 }
21384
21385
21386 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21387 PyObject *resultobj = 0;
21388 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21389 bool result;
21390 void *argp1 = 0 ;
21391 int res1 = 0 ;
21392 PyObject *swig_obj[1] ;
21393
21394 if (!args) SWIG_fail;
21395 swig_obj[0] = args;
21396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21397 if (!SWIG_IsOK(res1)) {
21398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21399 }
21400 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21401 {
21402 PyThreadState* __tstate = wxPyBeginAllowThreads();
21403 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
21404 wxPyEndAllowThreads(__tstate);
21405 if (PyErr_Occurred()) SWIG_fail;
21406 }
21407 {
21408 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21409 }
21410 return resultobj;
21411 fail:
21412 return NULL;
21413 }
21414
21415
21416 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21417 PyObject *resultobj = 0;
21418 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21419 int arg2 ;
21420 void *argp1 = 0 ;
21421 int res1 = 0 ;
21422 int val2 ;
21423 int ecode2 = 0 ;
21424 PyObject *swig_obj[2] ;
21425
21426 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
21427 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21428 if (!SWIG_IsOK(res1)) {
21429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21430 }
21431 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21432 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21433 if (!SWIG_IsOK(ecode2)) {
21434 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
21435 }
21436 arg2 = static_cast< int >(val2);
21437 if (arg1) (arg1)->m_x = arg2;
21438
21439 resultobj = SWIG_Py_Void();
21440 return resultobj;
21441 fail:
21442 return NULL;
21443 }
21444
21445
21446 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21447 PyObject *resultobj = 0;
21448 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21449 int result;
21450 void *argp1 = 0 ;
21451 int res1 = 0 ;
21452 PyObject *swig_obj[1] ;
21453
21454 if (!args) SWIG_fail;
21455 swig_obj[0] = args;
21456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21457 if (!SWIG_IsOK(res1)) {
21458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21459 }
21460 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21461 result = (int) ((arg1)->m_x);
21462 resultobj = SWIG_From_int(static_cast< int >(result));
21463 return resultobj;
21464 fail:
21465 return NULL;
21466 }
21467
21468
21469 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21470 PyObject *resultobj = 0;
21471 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21472 int arg2 ;
21473 void *argp1 = 0 ;
21474 int res1 = 0 ;
21475 int val2 ;
21476 int ecode2 = 0 ;
21477 PyObject *swig_obj[2] ;
21478
21479 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
21480 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21481 if (!SWIG_IsOK(res1)) {
21482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21483 }
21484 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21485 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21486 if (!SWIG_IsOK(ecode2)) {
21487 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
21488 }
21489 arg2 = static_cast< int >(val2);
21490 if (arg1) (arg1)->m_y = arg2;
21491
21492 resultobj = SWIG_Py_Void();
21493 return resultobj;
21494 fail:
21495 return NULL;
21496 }
21497
21498
21499 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21500 PyObject *resultobj = 0;
21501 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21502 int result;
21503 void *argp1 = 0 ;
21504 int res1 = 0 ;
21505 PyObject *swig_obj[1] ;
21506
21507 if (!args) SWIG_fail;
21508 swig_obj[0] = args;
21509 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21510 if (!SWIG_IsOK(res1)) {
21511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21512 }
21513 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21514 result = (int) ((arg1)->m_y);
21515 resultobj = SWIG_From_int(static_cast< int >(result));
21516 return resultobj;
21517 fail:
21518 return NULL;
21519 }
21520
21521
21522 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21523 PyObject *resultobj = 0;
21524 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21525 bool arg2 ;
21526 void *argp1 = 0 ;
21527 int res1 = 0 ;
21528 bool val2 ;
21529 int ecode2 = 0 ;
21530 PyObject *swig_obj[2] ;
21531
21532 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
21533 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21534 if (!SWIG_IsOK(res1)) {
21535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21536 }
21537 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21538 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21539 if (!SWIG_IsOK(ecode2)) {
21540 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
21541 }
21542 arg2 = static_cast< bool >(val2);
21543 if (arg1) (arg1)->m_leftDown = arg2;
21544
21545 resultobj = SWIG_Py_Void();
21546 return resultobj;
21547 fail:
21548 return NULL;
21549 }
21550
21551
21552 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21553 PyObject *resultobj = 0;
21554 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21555 bool result;
21556 void *argp1 = 0 ;
21557 int res1 = 0 ;
21558 PyObject *swig_obj[1] ;
21559
21560 if (!args) SWIG_fail;
21561 swig_obj[0] = args;
21562 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21563 if (!SWIG_IsOK(res1)) {
21564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21565 }
21566 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21567 result = (bool) ((arg1)->m_leftDown);
21568 {
21569 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21570 }
21571 return resultobj;
21572 fail:
21573 return NULL;
21574 }
21575
21576
21577 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21578 PyObject *resultobj = 0;
21579 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21580 bool arg2 ;
21581 void *argp1 = 0 ;
21582 int res1 = 0 ;
21583 bool val2 ;
21584 int ecode2 = 0 ;
21585 PyObject *swig_obj[2] ;
21586
21587 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
21588 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21589 if (!SWIG_IsOK(res1)) {
21590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21591 }
21592 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21593 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21594 if (!SWIG_IsOK(ecode2)) {
21595 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
21596 }
21597 arg2 = static_cast< bool >(val2);
21598 if (arg1) (arg1)->m_middleDown = arg2;
21599
21600 resultobj = SWIG_Py_Void();
21601 return resultobj;
21602 fail:
21603 return NULL;
21604 }
21605
21606
21607 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21608 PyObject *resultobj = 0;
21609 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21610 bool result;
21611 void *argp1 = 0 ;
21612 int res1 = 0 ;
21613 PyObject *swig_obj[1] ;
21614
21615 if (!args) SWIG_fail;
21616 swig_obj[0] = args;
21617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21618 if (!SWIG_IsOK(res1)) {
21619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21620 }
21621 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21622 result = (bool) ((arg1)->m_middleDown);
21623 {
21624 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21625 }
21626 return resultobj;
21627 fail:
21628 return NULL;
21629 }
21630
21631
21632 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21633 PyObject *resultobj = 0;
21634 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21635 bool arg2 ;
21636 void *argp1 = 0 ;
21637 int res1 = 0 ;
21638 bool val2 ;
21639 int ecode2 = 0 ;
21640 PyObject *swig_obj[2] ;
21641
21642 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
21643 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21644 if (!SWIG_IsOK(res1)) {
21645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21646 }
21647 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21648 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21649 if (!SWIG_IsOK(ecode2)) {
21650 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
21651 }
21652 arg2 = static_cast< bool >(val2);
21653 if (arg1) (arg1)->m_rightDown = arg2;
21654
21655 resultobj = SWIG_Py_Void();
21656 return resultobj;
21657 fail:
21658 return NULL;
21659 }
21660
21661
21662 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21663 PyObject *resultobj = 0;
21664 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21665 bool result;
21666 void *argp1 = 0 ;
21667 int res1 = 0 ;
21668 PyObject *swig_obj[1] ;
21669
21670 if (!args) SWIG_fail;
21671 swig_obj[0] = args;
21672 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21673 if (!SWIG_IsOK(res1)) {
21674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21675 }
21676 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21677 result = (bool) ((arg1)->m_rightDown);
21678 {
21679 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21680 }
21681 return resultobj;
21682 fail:
21683 return NULL;
21684 }
21685
21686
21687 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21688 PyObject *resultobj = 0;
21689 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21690 bool arg2 ;
21691 void *argp1 = 0 ;
21692 int res1 = 0 ;
21693 bool val2 ;
21694 int ecode2 = 0 ;
21695 PyObject *swig_obj[2] ;
21696
21697 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
21698 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21699 if (!SWIG_IsOK(res1)) {
21700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21701 }
21702 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21703 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21704 if (!SWIG_IsOK(ecode2)) {
21705 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
21706 }
21707 arg2 = static_cast< bool >(val2);
21708 if (arg1) (arg1)->m_controlDown = arg2;
21709
21710 resultobj = SWIG_Py_Void();
21711 return resultobj;
21712 fail:
21713 return NULL;
21714 }
21715
21716
21717 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21718 PyObject *resultobj = 0;
21719 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21720 bool result;
21721 void *argp1 = 0 ;
21722 int res1 = 0 ;
21723 PyObject *swig_obj[1] ;
21724
21725 if (!args) SWIG_fail;
21726 swig_obj[0] = args;
21727 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21728 if (!SWIG_IsOK(res1)) {
21729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21730 }
21731 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21732 result = (bool) ((arg1)->m_controlDown);
21733 {
21734 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21735 }
21736 return resultobj;
21737 fail:
21738 return NULL;
21739 }
21740
21741
21742 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21743 PyObject *resultobj = 0;
21744 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21745 bool arg2 ;
21746 void *argp1 = 0 ;
21747 int res1 = 0 ;
21748 bool val2 ;
21749 int ecode2 = 0 ;
21750 PyObject *swig_obj[2] ;
21751
21752 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
21753 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21754 if (!SWIG_IsOK(res1)) {
21755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21756 }
21757 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21758 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21759 if (!SWIG_IsOK(ecode2)) {
21760 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
21761 }
21762 arg2 = static_cast< bool >(val2);
21763 if (arg1) (arg1)->m_shiftDown = arg2;
21764
21765 resultobj = SWIG_Py_Void();
21766 return resultobj;
21767 fail:
21768 return NULL;
21769 }
21770
21771
21772 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21773 PyObject *resultobj = 0;
21774 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21775 bool result;
21776 void *argp1 = 0 ;
21777 int res1 = 0 ;
21778 PyObject *swig_obj[1] ;
21779
21780 if (!args) SWIG_fail;
21781 swig_obj[0] = args;
21782 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21783 if (!SWIG_IsOK(res1)) {
21784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21785 }
21786 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21787 result = (bool) ((arg1)->m_shiftDown);
21788 {
21789 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21790 }
21791 return resultobj;
21792 fail:
21793 return NULL;
21794 }
21795
21796
21797 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21798 PyObject *resultobj = 0;
21799 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21800 bool arg2 ;
21801 void *argp1 = 0 ;
21802 int res1 = 0 ;
21803 bool val2 ;
21804 int ecode2 = 0 ;
21805 PyObject *swig_obj[2] ;
21806
21807 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
21808 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21809 if (!SWIG_IsOK(res1)) {
21810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21811 }
21812 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21813 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21814 if (!SWIG_IsOK(ecode2)) {
21815 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
21816 }
21817 arg2 = static_cast< bool >(val2);
21818 if (arg1) (arg1)->m_altDown = arg2;
21819
21820 resultobj = SWIG_Py_Void();
21821 return resultobj;
21822 fail:
21823 return NULL;
21824 }
21825
21826
21827 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21828 PyObject *resultobj = 0;
21829 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21830 bool result;
21831 void *argp1 = 0 ;
21832 int res1 = 0 ;
21833 PyObject *swig_obj[1] ;
21834
21835 if (!args) SWIG_fail;
21836 swig_obj[0] = args;
21837 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21838 if (!SWIG_IsOK(res1)) {
21839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21840 }
21841 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21842 result = (bool) ((arg1)->m_altDown);
21843 {
21844 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21845 }
21846 return resultobj;
21847 fail:
21848 return NULL;
21849 }
21850
21851
21852 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21853 PyObject *resultobj = 0;
21854 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21855 bool arg2 ;
21856 void *argp1 = 0 ;
21857 int res1 = 0 ;
21858 bool val2 ;
21859 int ecode2 = 0 ;
21860 PyObject *swig_obj[2] ;
21861
21862 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
21863 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21864 if (!SWIG_IsOK(res1)) {
21865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21866 }
21867 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21868 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21869 if (!SWIG_IsOK(ecode2)) {
21870 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
21871 }
21872 arg2 = static_cast< bool >(val2);
21873 if (arg1) (arg1)->m_metaDown = arg2;
21874
21875 resultobj = SWIG_Py_Void();
21876 return resultobj;
21877 fail:
21878 return NULL;
21879 }
21880
21881
21882 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21883 PyObject *resultobj = 0;
21884 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21885 bool result;
21886 void *argp1 = 0 ;
21887 int res1 = 0 ;
21888 PyObject *swig_obj[1] ;
21889
21890 if (!args) SWIG_fail;
21891 swig_obj[0] = args;
21892 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21893 if (!SWIG_IsOK(res1)) {
21894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21895 }
21896 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21897 result = (bool) ((arg1)->m_metaDown);
21898 {
21899 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21900 }
21901 return resultobj;
21902 fail:
21903 return NULL;
21904 }
21905
21906
21907 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21908 PyObject *resultobj = 0;
21909 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21910 int arg2 ;
21911 void *argp1 = 0 ;
21912 int res1 = 0 ;
21913 int val2 ;
21914 int ecode2 = 0 ;
21915 PyObject *swig_obj[2] ;
21916
21917 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
21918 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21919 if (!SWIG_IsOK(res1)) {
21920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21921 }
21922 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21923 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21924 if (!SWIG_IsOK(ecode2)) {
21925 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
21926 }
21927 arg2 = static_cast< int >(val2);
21928 if (arg1) (arg1)->m_wheelRotation = arg2;
21929
21930 resultobj = SWIG_Py_Void();
21931 return resultobj;
21932 fail:
21933 return NULL;
21934 }
21935
21936
21937 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21938 PyObject *resultobj = 0;
21939 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21940 int result;
21941 void *argp1 = 0 ;
21942 int res1 = 0 ;
21943 PyObject *swig_obj[1] ;
21944
21945 if (!args) SWIG_fail;
21946 swig_obj[0] = args;
21947 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21948 if (!SWIG_IsOK(res1)) {
21949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21950 }
21951 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21952 result = (int) ((arg1)->m_wheelRotation);
21953 resultobj = SWIG_From_int(static_cast< int >(result));
21954 return resultobj;
21955 fail:
21956 return NULL;
21957 }
21958
21959
21960 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21961 PyObject *resultobj = 0;
21962 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21963 int arg2 ;
21964 void *argp1 = 0 ;
21965 int res1 = 0 ;
21966 int val2 ;
21967 int ecode2 = 0 ;
21968 PyObject *swig_obj[2] ;
21969
21970 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
21971 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21972 if (!SWIG_IsOK(res1)) {
21973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21974 }
21975 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21976 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21977 if (!SWIG_IsOK(ecode2)) {
21978 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
21979 }
21980 arg2 = static_cast< int >(val2);
21981 if (arg1) (arg1)->m_wheelDelta = arg2;
21982
21983 resultobj = SWIG_Py_Void();
21984 return resultobj;
21985 fail:
21986 return NULL;
21987 }
21988
21989
21990 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21991 PyObject *resultobj = 0;
21992 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21993 int result;
21994 void *argp1 = 0 ;
21995 int res1 = 0 ;
21996 PyObject *swig_obj[1] ;
21997
21998 if (!args) SWIG_fail;
21999 swig_obj[0] = args;
22000 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22001 if (!SWIG_IsOK(res1)) {
22002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22003 }
22004 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22005 result = (int) ((arg1)->m_wheelDelta);
22006 resultobj = SWIG_From_int(static_cast< int >(result));
22007 return resultobj;
22008 fail:
22009 return NULL;
22010 }
22011
22012
22013 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22014 PyObject *resultobj = 0;
22015 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22016 int arg2 ;
22017 void *argp1 = 0 ;
22018 int res1 = 0 ;
22019 int val2 ;
22020 int ecode2 = 0 ;
22021 PyObject *swig_obj[2] ;
22022
22023 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
22024 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22025 if (!SWIG_IsOK(res1)) {
22026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22027 }
22028 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22029 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22030 if (!SWIG_IsOK(ecode2)) {
22031 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
22032 }
22033 arg2 = static_cast< int >(val2);
22034 if (arg1) (arg1)->m_linesPerAction = arg2;
22035
22036 resultobj = SWIG_Py_Void();
22037 return resultobj;
22038 fail:
22039 return NULL;
22040 }
22041
22042
22043 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22044 PyObject *resultobj = 0;
22045 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22046 int result;
22047 void *argp1 = 0 ;
22048 int res1 = 0 ;
22049 PyObject *swig_obj[1] ;
22050
22051 if (!args) SWIG_fail;
22052 swig_obj[0] = args;
22053 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22054 if (!SWIG_IsOK(res1)) {
22055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22056 }
22057 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22058 result = (int) ((arg1)->m_linesPerAction);
22059 resultobj = SWIG_From_int(static_cast< int >(result));
22060 return resultobj;
22061 fail:
22062 return NULL;
22063 }
22064
22065
22066 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22067 PyObject *obj;
22068 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22069 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
22070 return SWIG_Py_Void();
22071 }
22072
22073 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22074 return SWIG_Python_InitShadowInstance(args);
22075 }
22076
22077 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22078 PyObject *resultobj = 0;
22079 int arg1 = (int) 0 ;
22080 int arg2 = (int) 0 ;
22081 wxSetCursorEvent *result = 0 ;
22082 int val1 ;
22083 int ecode1 = 0 ;
22084 int val2 ;
22085 int ecode2 = 0 ;
22086 PyObject * obj0 = 0 ;
22087 PyObject * obj1 = 0 ;
22088 char * kwnames[] = {
22089 (char *) "x",(char *) "y", NULL
22090 };
22091
22092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
22093 if (obj0) {
22094 ecode1 = SWIG_AsVal_int(obj0, &val1);
22095 if (!SWIG_IsOK(ecode1)) {
22096 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
22097 }
22098 arg1 = static_cast< int >(val1);
22099 }
22100 if (obj1) {
22101 ecode2 = SWIG_AsVal_int(obj1, &val2);
22102 if (!SWIG_IsOK(ecode2)) {
22103 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
22104 }
22105 arg2 = static_cast< int >(val2);
22106 }
22107 {
22108 PyThreadState* __tstate = wxPyBeginAllowThreads();
22109 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
22110 wxPyEndAllowThreads(__tstate);
22111 if (PyErr_Occurred()) SWIG_fail;
22112 }
22113 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
22114 return resultobj;
22115 fail:
22116 return NULL;
22117 }
22118
22119
22120 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22121 PyObject *resultobj = 0;
22122 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 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_wxSetCursorEvent, 0 | 0 );
22131 if (!SWIG_IsOK(res1)) {
22132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22133 }
22134 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22135 {
22136 PyThreadState* __tstate = wxPyBeginAllowThreads();
22137 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
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_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22149 PyObject *resultobj = 0;
22150 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22151 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_wxSetCursorEvent, 0 | 0 );
22159 if (!SWIG_IsOK(res1)) {
22160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22161 }
22162 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22163 {
22164 PyThreadState* __tstate = wxPyBeginAllowThreads();
22165 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
22166 wxPyEndAllowThreads(__tstate);
22167 if (PyErr_Occurred()) SWIG_fail;
22168 }
22169 resultobj = SWIG_From_int(static_cast< int >(result));
22170 return resultobj;
22171 fail:
22172 return NULL;
22173 }
22174
22175
22176 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22177 PyObject *resultobj = 0;
22178 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22179 wxCursor *arg2 = 0 ;
22180 void *argp1 = 0 ;
22181 int res1 = 0 ;
22182 void *argp2 = 0 ;
22183 int res2 = 0 ;
22184 PyObject * obj0 = 0 ;
22185 PyObject * obj1 = 0 ;
22186 char * kwnames[] = {
22187 (char *) "self",(char *) "cursor", NULL
22188 };
22189
22190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
22191 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22192 if (!SWIG_IsOK(res1)) {
22193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
22194 }
22195 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22196 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
22197 if (!SWIG_IsOK(res2)) {
22198 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
22199 }
22200 if (!argp2) {
22201 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
22202 }
22203 arg2 = reinterpret_cast< wxCursor * >(argp2);
22204 {
22205 PyThreadState* __tstate = wxPyBeginAllowThreads();
22206 (arg1)->SetCursor((wxCursor const &)*arg2);
22207 wxPyEndAllowThreads(__tstate);
22208 if (PyErr_Occurred()) SWIG_fail;
22209 }
22210 resultobj = SWIG_Py_Void();
22211 return resultobj;
22212 fail:
22213 return NULL;
22214 }
22215
22216
22217 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22218 PyObject *resultobj = 0;
22219 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22220 wxCursor *result = 0 ;
22221 void *argp1 = 0 ;
22222 int res1 = 0 ;
22223 PyObject *swig_obj[1] ;
22224
22225 if (!args) SWIG_fail;
22226 swig_obj[0] = args;
22227 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22228 if (!SWIG_IsOK(res1)) {
22229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22230 }
22231 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22232 {
22233 PyThreadState* __tstate = wxPyBeginAllowThreads();
22234 {
22235 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
22236 result = (wxCursor *) &_result_ref;
22237 }
22238 wxPyEndAllowThreads(__tstate);
22239 if (PyErr_Occurred()) SWIG_fail;
22240 }
22241 {
22242 wxCursor* resultptr = new wxCursor(*result);
22243 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
22244 }
22245 return resultobj;
22246 fail:
22247 return NULL;
22248 }
22249
22250
22251 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22252 PyObject *resultobj = 0;
22253 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22254 bool result;
22255 void *argp1 = 0 ;
22256 int res1 = 0 ;
22257 PyObject *swig_obj[1] ;
22258
22259 if (!args) SWIG_fail;
22260 swig_obj[0] = args;
22261 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22262 if (!SWIG_IsOK(res1)) {
22263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22264 }
22265 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22266 {
22267 PyThreadState* __tstate = wxPyBeginAllowThreads();
22268 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
22269 wxPyEndAllowThreads(__tstate);
22270 if (PyErr_Occurred()) SWIG_fail;
22271 }
22272 {
22273 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22274 }
22275 return resultobj;
22276 fail:
22277 return NULL;
22278 }
22279
22280
22281 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22282 PyObject *obj;
22283 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22284 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
22285 return SWIG_Py_Void();
22286 }
22287
22288 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22289 return SWIG_Python_InitShadowInstance(args);
22290 }
22291
22292 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22293 PyObject *resultobj = 0;
22294 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22295 wxKeyEvent *result = 0 ;
22296 int val1 ;
22297 int ecode1 = 0 ;
22298 PyObject * obj0 = 0 ;
22299 char * kwnames[] = {
22300 (char *) "eventType", NULL
22301 };
22302
22303 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
22304 if (obj0) {
22305 ecode1 = SWIG_AsVal_int(obj0, &val1);
22306 if (!SWIG_IsOK(ecode1)) {
22307 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22308 }
22309 arg1 = static_cast< wxEventType >(val1);
22310 }
22311 {
22312 PyThreadState* __tstate = wxPyBeginAllowThreads();
22313 result = (wxKeyEvent *)new wxKeyEvent(arg1);
22314 wxPyEndAllowThreads(__tstate);
22315 if (PyErr_Occurred()) SWIG_fail;
22316 }
22317 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
22318 return resultobj;
22319 fail:
22320 return NULL;
22321 }
22322
22323
22324 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22325 PyObject *resultobj = 0;
22326 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22327 int result;
22328 void *argp1 = 0 ;
22329 int res1 = 0 ;
22330 PyObject *swig_obj[1] ;
22331
22332 if (!args) SWIG_fail;
22333 swig_obj[0] = args;
22334 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22335 if (!SWIG_IsOK(res1)) {
22336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22337 }
22338 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22339 {
22340 PyThreadState* __tstate = wxPyBeginAllowThreads();
22341 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
22342 wxPyEndAllowThreads(__tstate);
22343 if (PyErr_Occurred()) SWIG_fail;
22344 }
22345 resultobj = SWIG_From_int(static_cast< int >(result));
22346 return resultobj;
22347 fail:
22348 return NULL;
22349 }
22350
22351
22352 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22353 PyObject *resultobj = 0;
22354 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22355 bool result;
22356 void *argp1 = 0 ;
22357 int res1 = 0 ;
22358 PyObject *swig_obj[1] ;
22359
22360 if (!args) SWIG_fail;
22361 swig_obj[0] = args;
22362 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22363 if (!SWIG_IsOK(res1)) {
22364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22365 }
22366 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22367 {
22368 PyThreadState* __tstate = wxPyBeginAllowThreads();
22369 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
22370 wxPyEndAllowThreads(__tstate);
22371 if (PyErr_Occurred()) SWIG_fail;
22372 }
22373 {
22374 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22375 }
22376 return resultobj;
22377 fail:
22378 return NULL;
22379 }
22380
22381
22382 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22383 PyObject *resultobj = 0;
22384 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22385 bool result;
22386 void *argp1 = 0 ;
22387 int res1 = 0 ;
22388 PyObject *swig_obj[1] ;
22389
22390 if (!args) SWIG_fail;
22391 swig_obj[0] = args;
22392 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22393 if (!SWIG_IsOK(res1)) {
22394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22395 }
22396 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22397 {
22398 PyThreadState* __tstate = wxPyBeginAllowThreads();
22399 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
22400 wxPyEndAllowThreads(__tstate);
22401 if (PyErr_Occurred()) SWIG_fail;
22402 }
22403 {
22404 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22405 }
22406 return resultobj;
22407 fail:
22408 return NULL;
22409 }
22410
22411
22412 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22413 PyObject *resultobj = 0;
22414 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22415 bool result;
22416 void *argp1 = 0 ;
22417 int res1 = 0 ;
22418 PyObject *swig_obj[1] ;
22419
22420 if (!args) SWIG_fail;
22421 swig_obj[0] = args;
22422 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22423 if (!SWIG_IsOK(res1)) {
22424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22425 }
22426 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22427 {
22428 PyThreadState* __tstate = wxPyBeginAllowThreads();
22429 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
22430 wxPyEndAllowThreads(__tstate);
22431 if (PyErr_Occurred()) SWIG_fail;
22432 }
22433 {
22434 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22435 }
22436 return resultobj;
22437 fail:
22438 return NULL;
22439 }
22440
22441
22442 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22443 PyObject *resultobj = 0;
22444 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22445 bool result;
22446 void *argp1 = 0 ;
22447 int res1 = 0 ;
22448 PyObject *swig_obj[1] ;
22449
22450 if (!args) SWIG_fail;
22451 swig_obj[0] = args;
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_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22455 }
22456 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22457 {
22458 PyThreadState* __tstate = wxPyBeginAllowThreads();
22459 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
22460 wxPyEndAllowThreads(__tstate);
22461 if (PyErr_Occurred()) SWIG_fail;
22462 }
22463 {
22464 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22465 }
22466 return resultobj;
22467 fail:
22468 return NULL;
22469 }
22470
22471
22472 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22473 PyObject *resultobj = 0;
22474 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22475 bool result;
22476 void *argp1 = 0 ;
22477 int res1 = 0 ;
22478 PyObject *swig_obj[1] ;
22479
22480 if (!args) SWIG_fail;
22481 swig_obj[0] = args;
22482 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22483 if (!SWIG_IsOK(res1)) {
22484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22485 }
22486 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22487 {
22488 PyThreadState* __tstate = wxPyBeginAllowThreads();
22489 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
22490 wxPyEndAllowThreads(__tstate);
22491 if (PyErr_Occurred()) SWIG_fail;
22492 }
22493 {
22494 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22495 }
22496 return resultobj;
22497 fail:
22498 return NULL;
22499 }
22500
22501
22502 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22503 PyObject *resultobj = 0;
22504 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22505 bool result;
22506 void *argp1 = 0 ;
22507 int res1 = 0 ;
22508 PyObject *swig_obj[1] ;
22509
22510 if (!args) SWIG_fail;
22511 swig_obj[0] = args;
22512 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22513 if (!SWIG_IsOK(res1)) {
22514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22515 }
22516 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22517 {
22518 PyThreadState* __tstate = wxPyBeginAllowThreads();
22519 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
22520 wxPyEndAllowThreads(__tstate);
22521 if (PyErr_Occurred()) SWIG_fail;
22522 }
22523 {
22524 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22525 }
22526 return resultobj;
22527 fail:
22528 return NULL;
22529 }
22530
22531
22532 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22533 PyObject *resultobj = 0;
22534 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22535 int result;
22536 void *argp1 = 0 ;
22537 int res1 = 0 ;
22538 PyObject *swig_obj[1] ;
22539
22540 if (!args) SWIG_fail;
22541 swig_obj[0] = args;
22542 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22543 if (!SWIG_IsOK(res1)) {
22544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22545 }
22546 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22547 {
22548 PyThreadState* __tstate = wxPyBeginAllowThreads();
22549 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
22550 wxPyEndAllowThreads(__tstate);
22551 if (PyErr_Occurred()) SWIG_fail;
22552 }
22553 resultobj = SWIG_From_int(static_cast< int >(result));
22554 return resultobj;
22555 fail:
22556 return NULL;
22557 }
22558
22559
22560 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22561 PyObject *resultobj = 0;
22562 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22563 int result;
22564 void *argp1 = 0 ;
22565 int res1 = 0 ;
22566 PyObject *swig_obj[1] ;
22567
22568 if (!args) SWIG_fail;
22569 swig_obj[0] = args;
22570 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22571 if (!SWIG_IsOK(res1)) {
22572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22573 }
22574 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22575 {
22576 PyThreadState* __tstate = wxPyBeginAllowThreads();
22577 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
22578 wxPyEndAllowThreads(__tstate);
22579 if (PyErr_Occurred()) SWIG_fail;
22580 }
22581 resultobj = SWIG_From_int(static_cast< int >(result));
22582 return resultobj;
22583 fail:
22584 return NULL;
22585 }
22586
22587
22588 SWIGINTERN PyObject *_wrap_KeyEvent_SetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22589 PyObject *resultobj = 0;
22590 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22591 int arg2 ;
22592 void *argp1 = 0 ;
22593 int res1 = 0 ;
22594 int val2 ;
22595 int ecode2 = 0 ;
22596 PyObject * obj0 = 0 ;
22597 PyObject * obj1 = 0 ;
22598 char * kwnames[] = {
22599 (char *) "self",(char *) "uniChar", NULL
22600 };
22601
22602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_SetUnicodeKey",kwnames,&obj0,&obj1)) SWIG_fail;
22603 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22604 if (!SWIG_IsOK(res1)) {
22605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22606 }
22607 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22608 ecode2 = SWIG_AsVal_int(obj1, &val2);
22609 if (!SWIG_IsOK(ecode2)) {
22610 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "2"" of type '" "int""'");
22611 }
22612 arg2 = static_cast< int >(val2);
22613 {
22614 PyThreadState* __tstate = wxPyBeginAllowThreads();
22615 wxKeyEvent_SetUnicodeKey(arg1,arg2);
22616 wxPyEndAllowThreads(__tstate);
22617 if (PyErr_Occurred()) SWIG_fail;
22618 }
22619 resultobj = SWIG_Py_Void();
22620 return resultobj;
22621 fail:
22622 return NULL;
22623 }
22624
22625
22626 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22627 PyObject *resultobj = 0;
22628 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22629 unsigned int result;
22630 void *argp1 = 0 ;
22631 int res1 = 0 ;
22632 PyObject *swig_obj[1] ;
22633
22634 if (!args) SWIG_fail;
22635 swig_obj[0] = args;
22636 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22637 if (!SWIG_IsOK(res1)) {
22638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22639 }
22640 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22641 {
22642 PyThreadState* __tstate = wxPyBeginAllowThreads();
22643 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
22644 wxPyEndAllowThreads(__tstate);
22645 if (PyErr_Occurred()) SWIG_fail;
22646 }
22647 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22648 return resultobj;
22649 fail:
22650 return NULL;
22651 }
22652
22653
22654 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22655 PyObject *resultobj = 0;
22656 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22657 unsigned int result;
22658 void *argp1 = 0 ;
22659 int res1 = 0 ;
22660 PyObject *swig_obj[1] ;
22661
22662 if (!args) SWIG_fail;
22663 swig_obj[0] = args;
22664 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22665 if (!SWIG_IsOK(res1)) {
22666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22667 }
22668 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22669 {
22670 PyThreadState* __tstate = wxPyBeginAllowThreads();
22671 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
22672 wxPyEndAllowThreads(__tstate);
22673 if (PyErr_Occurred()) SWIG_fail;
22674 }
22675 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22676 return resultobj;
22677 fail:
22678 return NULL;
22679 }
22680
22681
22682 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22683 PyObject *resultobj = 0;
22684 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22685 wxPoint result;
22686 void *argp1 = 0 ;
22687 int res1 = 0 ;
22688 PyObject *swig_obj[1] ;
22689
22690 if (!args) SWIG_fail;
22691 swig_obj[0] = args;
22692 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22693 if (!SWIG_IsOK(res1)) {
22694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22695 }
22696 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22697 {
22698 PyThreadState* __tstate = wxPyBeginAllowThreads();
22699 result = (arg1)->GetPosition();
22700 wxPyEndAllowThreads(__tstate);
22701 if (PyErr_Occurred()) SWIG_fail;
22702 }
22703 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
22704 return resultobj;
22705 fail:
22706 return NULL;
22707 }
22708
22709
22710 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22711 PyObject *resultobj = 0;
22712 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22713 long *arg2 = (long *) 0 ;
22714 long *arg3 = (long *) 0 ;
22715 void *argp1 = 0 ;
22716 int res1 = 0 ;
22717 long temp2 ;
22718 int res2 = SWIG_TMPOBJ ;
22719 long temp3 ;
22720 int res3 = SWIG_TMPOBJ ;
22721 PyObject *swig_obj[1] ;
22722
22723 arg2 = &temp2;
22724 arg3 = &temp3;
22725 if (!args) SWIG_fail;
22726 swig_obj[0] = args;
22727 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22728 if (!SWIG_IsOK(res1)) {
22729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22730 }
22731 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22732 {
22733 PyThreadState* __tstate = wxPyBeginAllowThreads();
22734 (arg1)->GetPosition(arg2,arg3);
22735 wxPyEndAllowThreads(__tstate);
22736 if (PyErr_Occurred()) SWIG_fail;
22737 }
22738 resultobj = SWIG_Py_Void();
22739 if (SWIG_IsTmpObj(res2)) {
22740 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
22741 } else {
22742 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22743 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
22744 }
22745 if (SWIG_IsTmpObj(res3)) {
22746 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
22747 } else {
22748 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22749 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
22750 }
22751 return resultobj;
22752 fail:
22753 return NULL;
22754 }
22755
22756
22757 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22758 PyObject *resultobj = 0;
22759 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22760 int result;
22761 void *argp1 = 0 ;
22762 int res1 = 0 ;
22763 PyObject *swig_obj[1] ;
22764
22765 if (!args) SWIG_fail;
22766 swig_obj[0] = args;
22767 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22768 if (!SWIG_IsOK(res1)) {
22769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22770 }
22771 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22772 {
22773 PyThreadState* __tstate = wxPyBeginAllowThreads();
22774 result = (int)((wxKeyEvent const *)arg1)->GetX();
22775 wxPyEndAllowThreads(__tstate);
22776 if (PyErr_Occurred()) SWIG_fail;
22777 }
22778 resultobj = SWIG_From_int(static_cast< int >(result));
22779 return resultobj;
22780 fail:
22781 return NULL;
22782 }
22783
22784
22785 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22786 PyObject *resultobj = 0;
22787 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22788 int result;
22789 void *argp1 = 0 ;
22790 int res1 = 0 ;
22791 PyObject *swig_obj[1] ;
22792
22793 if (!args) SWIG_fail;
22794 swig_obj[0] = args;
22795 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22796 if (!SWIG_IsOK(res1)) {
22797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22798 }
22799 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22800 {
22801 PyThreadState* __tstate = wxPyBeginAllowThreads();
22802 result = (int)((wxKeyEvent const *)arg1)->GetY();
22803 wxPyEndAllowThreads(__tstate);
22804 if (PyErr_Occurred()) SWIG_fail;
22805 }
22806 resultobj = SWIG_From_int(static_cast< int >(result));
22807 return resultobj;
22808 fail:
22809 return NULL;
22810 }
22811
22812
22813 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22814 PyObject *resultobj = 0;
22815 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22816 int arg2 ;
22817 void *argp1 = 0 ;
22818 int res1 = 0 ;
22819 int val2 ;
22820 int ecode2 = 0 ;
22821 PyObject *swig_obj[2] ;
22822
22823 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
22824 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22825 if (!SWIG_IsOK(res1)) {
22826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22827 }
22828 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22829 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22830 if (!SWIG_IsOK(ecode2)) {
22831 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
22832 }
22833 arg2 = static_cast< int >(val2);
22834 if (arg1) (arg1)->m_x = arg2;
22835
22836 resultobj = SWIG_Py_Void();
22837 return resultobj;
22838 fail:
22839 return NULL;
22840 }
22841
22842
22843 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22844 PyObject *resultobj = 0;
22845 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22846 int result;
22847 void *argp1 = 0 ;
22848 int res1 = 0 ;
22849 PyObject *swig_obj[1] ;
22850
22851 if (!args) SWIG_fail;
22852 swig_obj[0] = args;
22853 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22854 if (!SWIG_IsOK(res1)) {
22855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22856 }
22857 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22858 result = (int) ((arg1)->m_x);
22859 resultobj = SWIG_From_int(static_cast< int >(result));
22860 return resultobj;
22861 fail:
22862 return NULL;
22863 }
22864
22865
22866 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22867 PyObject *resultobj = 0;
22868 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22869 int arg2 ;
22870 void *argp1 = 0 ;
22871 int res1 = 0 ;
22872 int val2 ;
22873 int ecode2 = 0 ;
22874 PyObject *swig_obj[2] ;
22875
22876 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
22877 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22878 if (!SWIG_IsOK(res1)) {
22879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22880 }
22881 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22882 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22883 if (!SWIG_IsOK(ecode2)) {
22884 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
22885 }
22886 arg2 = static_cast< int >(val2);
22887 if (arg1) (arg1)->m_y = arg2;
22888
22889 resultobj = SWIG_Py_Void();
22890 return resultobj;
22891 fail:
22892 return NULL;
22893 }
22894
22895
22896 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22897 PyObject *resultobj = 0;
22898 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22899 int result;
22900 void *argp1 = 0 ;
22901 int res1 = 0 ;
22902 PyObject *swig_obj[1] ;
22903
22904 if (!args) SWIG_fail;
22905 swig_obj[0] = args;
22906 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22907 if (!SWIG_IsOK(res1)) {
22908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22909 }
22910 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22911 result = (int) ((arg1)->m_y);
22912 resultobj = SWIG_From_int(static_cast< int >(result));
22913 return resultobj;
22914 fail:
22915 return NULL;
22916 }
22917
22918
22919 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22920 PyObject *resultobj = 0;
22921 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22922 long arg2 ;
22923 void *argp1 = 0 ;
22924 int res1 = 0 ;
22925 long val2 ;
22926 int ecode2 = 0 ;
22927 PyObject *swig_obj[2] ;
22928
22929 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
22930 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22931 if (!SWIG_IsOK(res1)) {
22932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22933 }
22934 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22935 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
22936 if (!SWIG_IsOK(ecode2)) {
22937 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
22938 }
22939 arg2 = static_cast< long >(val2);
22940 if (arg1) (arg1)->m_keyCode = arg2;
22941
22942 resultobj = SWIG_Py_Void();
22943 return resultobj;
22944 fail:
22945 return NULL;
22946 }
22947
22948
22949 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22950 PyObject *resultobj = 0;
22951 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22952 long result;
22953 void *argp1 = 0 ;
22954 int res1 = 0 ;
22955 PyObject *swig_obj[1] ;
22956
22957 if (!args) SWIG_fail;
22958 swig_obj[0] = args;
22959 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22960 if (!SWIG_IsOK(res1)) {
22961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22962 }
22963 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22964 result = (long) ((arg1)->m_keyCode);
22965 resultobj = SWIG_From_long(static_cast< long >(result));
22966 return resultobj;
22967 fail:
22968 return NULL;
22969 }
22970
22971
22972 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22973 PyObject *resultobj = 0;
22974 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22975 bool arg2 ;
22976 void *argp1 = 0 ;
22977 int res1 = 0 ;
22978 bool val2 ;
22979 int ecode2 = 0 ;
22980 PyObject *swig_obj[2] ;
22981
22982 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
22983 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22984 if (!SWIG_IsOK(res1)) {
22985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22986 }
22987 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22988 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22989 if (!SWIG_IsOK(ecode2)) {
22990 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
22991 }
22992 arg2 = static_cast< bool >(val2);
22993 if (arg1) (arg1)->m_controlDown = arg2;
22994
22995 resultobj = SWIG_Py_Void();
22996 return resultobj;
22997 fail:
22998 return NULL;
22999 }
23000
23001
23002 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23003 PyObject *resultobj = 0;
23004 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23005 bool result;
23006 void *argp1 = 0 ;
23007 int res1 = 0 ;
23008 PyObject *swig_obj[1] ;
23009
23010 if (!args) SWIG_fail;
23011 swig_obj[0] = args;
23012 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23013 if (!SWIG_IsOK(res1)) {
23014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23015 }
23016 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23017 result = (bool) ((arg1)->m_controlDown);
23018 {
23019 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23020 }
23021 return resultobj;
23022 fail:
23023 return NULL;
23024 }
23025
23026
23027 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23028 PyObject *resultobj = 0;
23029 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23030 bool arg2 ;
23031 void *argp1 = 0 ;
23032 int res1 = 0 ;
23033 bool val2 ;
23034 int ecode2 = 0 ;
23035 PyObject *swig_obj[2] ;
23036
23037 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
23038 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23039 if (!SWIG_IsOK(res1)) {
23040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23041 }
23042 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23043 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
23044 if (!SWIG_IsOK(ecode2)) {
23045 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
23046 }
23047 arg2 = static_cast< bool >(val2);
23048 if (arg1) (arg1)->m_shiftDown = arg2;
23049
23050 resultobj = SWIG_Py_Void();
23051 return resultobj;
23052 fail:
23053 return NULL;
23054 }
23055
23056
23057 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23058 PyObject *resultobj = 0;
23059 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23060 bool result;
23061 void *argp1 = 0 ;
23062 int res1 = 0 ;
23063 PyObject *swig_obj[1] ;
23064
23065 if (!args) SWIG_fail;
23066 swig_obj[0] = args;
23067 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23068 if (!SWIG_IsOK(res1)) {
23069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23070 }
23071 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23072 result = (bool) ((arg1)->m_shiftDown);
23073 {
23074 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23075 }
23076 return resultobj;
23077 fail:
23078 return NULL;
23079 }
23080
23081
23082 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23083 PyObject *resultobj = 0;
23084 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23085 bool arg2 ;
23086 void *argp1 = 0 ;
23087 int res1 = 0 ;
23088 bool val2 ;
23089 int ecode2 = 0 ;
23090 PyObject *swig_obj[2] ;
23091
23092 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
23093 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23094 if (!SWIG_IsOK(res1)) {
23095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23096 }
23097 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23098 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
23099 if (!SWIG_IsOK(ecode2)) {
23100 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
23101 }
23102 arg2 = static_cast< bool >(val2);
23103 if (arg1) (arg1)->m_altDown = arg2;
23104
23105 resultobj = SWIG_Py_Void();
23106 return resultobj;
23107 fail:
23108 return NULL;
23109 }
23110
23111
23112 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23113 PyObject *resultobj = 0;
23114 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23115 bool result;
23116 void *argp1 = 0 ;
23117 int res1 = 0 ;
23118 PyObject *swig_obj[1] ;
23119
23120 if (!args) SWIG_fail;
23121 swig_obj[0] = args;
23122 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23123 if (!SWIG_IsOK(res1)) {
23124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23125 }
23126 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23127 result = (bool) ((arg1)->m_altDown);
23128 {
23129 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23130 }
23131 return resultobj;
23132 fail:
23133 return NULL;
23134 }
23135
23136
23137 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23138 PyObject *resultobj = 0;
23139 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23140 bool arg2 ;
23141 void *argp1 = 0 ;
23142 int res1 = 0 ;
23143 bool val2 ;
23144 int ecode2 = 0 ;
23145 PyObject *swig_obj[2] ;
23146
23147 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
23148 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23149 if (!SWIG_IsOK(res1)) {
23150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23151 }
23152 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23153 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
23154 if (!SWIG_IsOK(ecode2)) {
23155 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
23156 }
23157 arg2 = static_cast< bool >(val2);
23158 if (arg1) (arg1)->m_metaDown = arg2;
23159
23160 resultobj = SWIG_Py_Void();
23161 return resultobj;
23162 fail:
23163 return NULL;
23164 }
23165
23166
23167 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23168 PyObject *resultobj = 0;
23169 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23170 bool result;
23171 void *argp1 = 0 ;
23172 int res1 = 0 ;
23173 PyObject *swig_obj[1] ;
23174
23175 if (!args) SWIG_fail;
23176 swig_obj[0] = args;
23177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23178 if (!SWIG_IsOK(res1)) {
23179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23180 }
23181 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23182 result = (bool) ((arg1)->m_metaDown);
23183 {
23184 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23185 }
23186 return resultobj;
23187 fail:
23188 return NULL;
23189 }
23190
23191
23192 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23193 PyObject *resultobj = 0;
23194 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23195 bool arg2 ;
23196 void *argp1 = 0 ;
23197 int res1 = 0 ;
23198 bool val2 ;
23199 int ecode2 = 0 ;
23200 PyObject *swig_obj[2] ;
23201
23202 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
23203 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23204 if (!SWIG_IsOK(res1)) {
23205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23206 }
23207 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23208 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
23209 if (!SWIG_IsOK(ecode2)) {
23210 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
23211 }
23212 arg2 = static_cast< bool >(val2);
23213 if (arg1) (arg1)->m_scanCode = arg2;
23214
23215 resultobj = SWIG_Py_Void();
23216 return resultobj;
23217 fail:
23218 return NULL;
23219 }
23220
23221
23222 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23223 PyObject *resultobj = 0;
23224 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23225 bool result;
23226 void *argp1 = 0 ;
23227 int res1 = 0 ;
23228 PyObject *swig_obj[1] ;
23229
23230 if (!args) SWIG_fail;
23231 swig_obj[0] = args;
23232 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23233 if (!SWIG_IsOK(res1)) {
23234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23235 }
23236 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23237 result = (bool) ((arg1)->m_scanCode);
23238 {
23239 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23240 }
23241 return resultobj;
23242 fail:
23243 return NULL;
23244 }
23245
23246
23247 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23248 PyObject *resultobj = 0;
23249 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23250 unsigned int arg2 ;
23251 void *argp1 = 0 ;
23252 int res1 = 0 ;
23253 unsigned int val2 ;
23254 int ecode2 = 0 ;
23255 PyObject *swig_obj[2] ;
23256
23257 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
23258 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23259 if (!SWIG_IsOK(res1)) {
23260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23261 }
23262 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23263 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
23264 if (!SWIG_IsOK(ecode2)) {
23265 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
23266 }
23267 arg2 = static_cast< unsigned int >(val2);
23268 if (arg1) (arg1)->m_rawCode = arg2;
23269
23270 resultobj = SWIG_Py_Void();
23271 return resultobj;
23272 fail:
23273 return NULL;
23274 }
23275
23276
23277 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23278 PyObject *resultobj = 0;
23279 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23280 unsigned int result;
23281 void *argp1 = 0 ;
23282 int res1 = 0 ;
23283 PyObject *swig_obj[1] ;
23284
23285 if (!args) SWIG_fail;
23286 swig_obj[0] = args;
23287 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23288 if (!SWIG_IsOK(res1)) {
23289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23290 }
23291 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23292 result = (unsigned int) ((arg1)->m_rawCode);
23293 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
23294 return resultobj;
23295 fail:
23296 return NULL;
23297 }
23298
23299
23300 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23301 PyObject *resultobj = 0;
23302 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23303 unsigned int arg2 ;
23304 void *argp1 = 0 ;
23305 int res1 = 0 ;
23306 unsigned int val2 ;
23307 int ecode2 = 0 ;
23308 PyObject *swig_obj[2] ;
23309
23310 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
23311 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23312 if (!SWIG_IsOK(res1)) {
23313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23314 }
23315 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23316 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
23317 if (!SWIG_IsOK(ecode2)) {
23318 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
23319 }
23320 arg2 = static_cast< unsigned int >(val2);
23321 if (arg1) (arg1)->m_rawFlags = arg2;
23322
23323 resultobj = SWIG_Py_Void();
23324 return resultobj;
23325 fail:
23326 return NULL;
23327 }
23328
23329
23330 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23331 PyObject *resultobj = 0;
23332 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23333 unsigned int result;
23334 void *argp1 = 0 ;
23335 int res1 = 0 ;
23336 PyObject *swig_obj[1] ;
23337
23338 if (!args) SWIG_fail;
23339 swig_obj[0] = args;
23340 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23341 if (!SWIG_IsOK(res1)) {
23342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23343 }
23344 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23345 result = (unsigned int) ((arg1)->m_rawFlags);
23346 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
23347 return resultobj;
23348 fail:
23349 return NULL;
23350 }
23351
23352
23353 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23354 PyObject *obj;
23355 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23356 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
23357 return SWIG_Py_Void();
23358 }
23359
23360 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23361 return SWIG_Python_InitShadowInstance(args);
23362 }
23363
23364 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23365 PyObject *resultobj = 0;
23366 wxSize const &arg1_defvalue = wxDefaultSize ;
23367 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
23368 int arg2 = (int) 0 ;
23369 wxSizeEvent *result = 0 ;
23370 wxSize temp1 ;
23371 int val2 ;
23372 int ecode2 = 0 ;
23373 PyObject * obj0 = 0 ;
23374 PyObject * obj1 = 0 ;
23375 char * kwnames[] = {
23376 (char *) "sz",(char *) "winid", NULL
23377 };
23378
23379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23380 if (obj0) {
23381 {
23382 arg1 = &temp1;
23383 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
23384 }
23385 }
23386 if (obj1) {
23387 ecode2 = SWIG_AsVal_int(obj1, &val2);
23388 if (!SWIG_IsOK(ecode2)) {
23389 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
23390 }
23391 arg2 = static_cast< int >(val2);
23392 }
23393 {
23394 PyThreadState* __tstate = wxPyBeginAllowThreads();
23395 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
23396 wxPyEndAllowThreads(__tstate);
23397 if (PyErr_Occurred()) SWIG_fail;
23398 }
23399 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
23400 return resultobj;
23401 fail:
23402 return NULL;
23403 }
23404
23405
23406 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23407 PyObject *resultobj = 0;
23408 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23409 wxSize result;
23410 void *argp1 = 0 ;
23411 int res1 = 0 ;
23412 PyObject *swig_obj[1] ;
23413
23414 if (!args) SWIG_fail;
23415 swig_obj[0] = args;
23416 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23417 if (!SWIG_IsOK(res1)) {
23418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23419 }
23420 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23421 {
23422 PyThreadState* __tstate = wxPyBeginAllowThreads();
23423 result = ((wxSizeEvent const *)arg1)->GetSize();
23424 wxPyEndAllowThreads(__tstate);
23425 if (PyErr_Occurred()) SWIG_fail;
23426 }
23427 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
23428 return resultobj;
23429 fail:
23430 return NULL;
23431 }
23432
23433
23434 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23435 PyObject *resultobj = 0;
23436 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23437 wxRect result;
23438 void *argp1 = 0 ;
23439 int res1 = 0 ;
23440 PyObject *swig_obj[1] ;
23441
23442 if (!args) SWIG_fail;
23443 swig_obj[0] = args;
23444 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23445 if (!SWIG_IsOK(res1)) {
23446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23447 }
23448 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23449 {
23450 PyThreadState* __tstate = wxPyBeginAllowThreads();
23451 result = ((wxSizeEvent const *)arg1)->GetRect();
23452 wxPyEndAllowThreads(__tstate);
23453 if (PyErr_Occurred()) SWIG_fail;
23454 }
23455 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23456 return resultobj;
23457 fail:
23458 return NULL;
23459 }
23460
23461
23462 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23463 PyObject *resultobj = 0;
23464 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23465 wxRect arg2 ;
23466 void *argp1 = 0 ;
23467 int res1 = 0 ;
23468 void *argp2 ;
23469 int res2 = 0 ;
23470 PyObject * obj0 = 0 ;
23471 PyObject * obj1 = 0 ;
23472 char * kwnames[] = {
23473 (char *) "self",(char *) "rect", NULL
23474 };
23475
23476 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23477 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23478 if (!SWIG_IsOK(res1)) {
23479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23480 }
23481 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23482 {
23483 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
23484 if (!SWIG_IsOK(res2)) {
23485 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23486 }
23487 if (!argp2) {
23488 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23489 } else {
23490 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
23491 arg2 = *temp;
23492 if (SWIG_IsNewObj(res2)) delete temp;
23493 }
23494 }
23495 {
23496 PyThreadState* __tstate = wxPyBeginAllowThreads();
23497 (arg1)->SetRect(arg2);
23498 wxPyEndAllowThreads(__tstate);
23499 if (PyErr_Occurred()) SWIG_fail;
23500 }
23501 resultobj = SWIG_Py_Void();
23502 return resultobj;
23503 fail:
23504 return NULL;
23505 }
23506
23507
23508 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23509 PyObject *resultobj = 0;
23510 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23511 wxSize arg2 ;
23512 void *argp1 = 0 ;
23513 int res1 = 0 ;
23514 void *argp2 ;
23515 int res2 = 0 ;
23516 PyObject * obj0 = 0 ;
23517 PyObject * obj1 = 0 ;
23518 char * kwnames[] = {
23519 (char *) "self",(char *) "size", NULL
23520 };
23521
23522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
23523 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23524 if (!SWIG_IsOK(res1)) {
23525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23526 }
23527 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23528 {
23529 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
23530 if (!SWIG_IsOK(res2)) {
23531 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23532 }
23533 if (!argp2) {
23534 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23535 } else {
23536 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
23537 arg2 = *temp;
23538 if (SWIG_IsNewObj(res2)) delete temp;
23539 }
23540 }
23541 {
23542 PyThreadState* __tstate = wxPyBeginAllowThreads();
23543 wxSizeEvent_SetSize(arg1,arg2);
23544 wxPyEndAllowThreads(__tstate);
23545 if (PyErr_Occurred()) SWIG_fail;
23546 }
23547 resultobj = SWIG_Py_Void();
23548 return resultobj;
23549 fail:
23550 return NULL;
23551 }
23552
23553
23554 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23555 PyObject *resultobj = 0;
23556 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23557 wxSize *arg2 = (wxSize *) 0 ;
23558 void *argp1 = 0 ;
23559 int res1 = 0 ;
23560 void *argp2 = 0 ;
23561 int res2 = 0 ;
23562 PyObject *swig_obj[2] ;
23563
23564 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
23565 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23566 if (!SWIG_IsOK(res1)) {
23567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23568 }
23569 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23570 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
23571 if (!SWIG_IsOK(res2)) {
23572 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
23573 }
23574 arg2 = reinterpret_cast< wxSize * >(argp2);
23575 if (arg1) (arg1)->m_size = *arg2;
23576
23577 resultobj = SWIG_Py_Void();
23578 return resultobj;
23579 fail:
23580 return NULL;
23581 }
23582
23583
23584 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23585 PyObject *resultobj = 0;
23586 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23587 wxSize *result = 0 ;
23588 void *argp1 = 0 ;
23589 int res1 = 0 ;
23590 PyObject *swig_obj[1] ;
23591
23592 if (!args) SWIG_fail;
23593 swig_obj[0] = args;
23594 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23595 if (!SWIG_IsOK(res1)) {
23596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23597 }
23598 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23599 result = (wxSize *)& ((arg1)->m_size);
23600 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
23601 return resultobj;
23602 fail:
23603 return NULL;
23604 }
23605
23606
23607 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23608 PyObject *resultobj = 0;
23609 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23610 wxRect *arg2 = (wxRect *) 0 ;
23611 void *argp1 = 0 ;
23612 int res1 = 0 ;
23613 void *argp2 = 0 ;
23614 int res2 = 0 ;
23615 PyObject *swig_obj[2] ;
23616
23617 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
23618 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23619 if (!SWIG_IsOK(res1)) {
23620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23621 }
23622 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23623 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
23624 if (!SWIG_IsOK(res2)) {
23625 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
23626 }
23627 arg2 = reinterpret_cast< wxRect * >(argp2);
23628 if (arg1) (arg1)->m_rect = *arg2;
23629
23630 resultobj = SWIG_Py_Void();
23631 return resultobj;
23632 fail:
23633 return NULL;
23634 }
23635
23636
23637 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23638 PyObject *resultobj = 0;
23639 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23640 wxRect *result = 0 ;
23641 void *argp1 = 0 ;
23642 int res1 = 0 ;
23643 PyObject *swig_obj[1] ;
23644
23645 if (!args) SWIG_fail;
23646 swig_obj[0] = args;
23647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23648 if (!SWIG_IsOK(res1)) {
23649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23650 }
23651 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23652 result = (wxRect *)& ((arg1)->m_rect);
23653 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
23654 return resultobj;
23655 fail:
23656 return NULL;
23657 }
23658
23659
23660 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23661 PyObject *obj;
23662 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23663 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
23664 return SWIG_Py_Void();
23665 }
23666
23667 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23668 return SWIG_Python_InitShadowInstance(args);
23669 }
23670
23671 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23672 PyObject *resultobj = 0;
23673 wxPoint const &arg1_defvalue = wxDefaultPosition ;
23674 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
23675 int arg2 = (int) 0 ;
23676 wxMoveEvent *result = 0 ;
23677 wxPoint temp1 ;
23678 int val2 ;
23679 int ecode2 = 0 ;
23680 PyObject * obj0 = 0 ;
23681 PyObject * obj1 = 0 ;
23682 char * kwnames[] = {
23683 (char *) "pos",(char *) "winid", NULL
23684 };
23685
23686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23687 if (obj0) {
23688 {
23689 arg1 = &temp1;
23690 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
23691 }
23692 }
23693 if (obj1) {
23694 ecode2 = SWIG_AsVal_int(obj1, &val2);
23695 if (!SWIG_IsOK(ecode2)) {
23696 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
23697 }
23698 arg2 = static_cast< int >(val2);
23699 }
23700 {
23701 PyThreadState* __tstate = wxPyBeginAllowThreads();
23702 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
23703 wxPyEndAllowThreads(__tstate);
23704 if (PyErr_Occurred()) SWIG_fail;
23705 }
23706 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
23707 return resultobj;
23708 fail:
23709 return NULL;
23710 }
23711
23712
23713 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23714 PyObject *resultobj = 0;
23715 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23716 wxPoint result;
23717 void *argp1 = 0 ;
23718 int res1 = 0 ;
23719 PyObject *swig_obj[1] ;
23720
23721 if (!args) SWIG_fail;
23722 swig_obj[0] = args;
23723 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23724 if (!SWIG_IsOK(res1)) {
23725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23726 }
23727 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23728 {
23729 PyThreadState* __tstate = wxPyBeginAllowThreads();
23730 result = ((wxMoveEvent const *)arg1)->GetPosition();
23731 wxPyEndAllowThreads(__tstate);
23732 if (PyErr_Occurred()) SWIG_fail;
23733 }
23734 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23735 return resultobj;
23736 fail:
23737 return NULL;
23738 }
23739
23740
23741 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23742 PyObject *resultobj = 0;
23743 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23744 wxRect result;
23745 void *argp1 = 0 ;
23746 int res1 = 0 ;
23747 PyObject *swig_obj[1] ;
23748
23749 if (!args) SWIG_fail;
23750 swig_obj[0] = args;
23751 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23752 if (!SWIG_IsOK(res1)) {
23753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23754 }
23755 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23756 {
23757 PyThreadState* __tstate = wxPyBeginAllowThreads();
23758 result = ((wxMoveEvent const *)arg1)->GetRect();
23759 wxPyEndAllowThreads(__tstate);
23760 if (PyErr_Occurred()) SWIG_fail;
23761 }
23762 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23763 return resultobj;
23764 fail:
23765 return NULL;
23766 }
23767
23768
23769 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23770 PyObject *resultobj = 0;
23771 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23772 wxRect *arg2 = 0 ;
23773 void *argp1 = 0 ;
23774 int res1 = 0 ;
23775 wxRect temp2 ;
23776 PyObject * obj0 = 0 ;
23777 PyObject * obj1 = 0 ;
23778 char * kwnames[] = {
23779 (char *) "self",(char *) "rect", NULL
23780 };
23781
23782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23783 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23784 if (!SWIG_IsOK(res1)) {
23785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23786 }
23787 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23788 {
23789 arg2 = &temp2;
23790 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
23791 }
23792 {
23793 PyThreadState* __tstate = wxPyBeginAllowThreads();
23794 (arg1)->SetRect((wxRect const &)*arg2);
23795 wxPyEndAllowThreads(__tstate);
23796 if (PyErr_Occurred()) SWIG_fail;
23797 }
23798 resultobj = SWIG_Py_Void();
23799 return resultobj;
23800 fail:
23801 return NULL;
23802 }
23803
23804
23805 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23806 PyObject *resultobj = 0;
23807 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23808 wxPoint *arg2 = 0 ;
23809 void *argp1 = 0 ;
23810 int res1 = 0 ;
23811 wxPoint temp2 ;
23812 PyObject * obj0 = 0 ;
23813 PyObject * obj1 = 0 ;
23814 char * kwnames[] = {
23815 (char *) "self",(char *) "pos", NULL
23816 };
23817
23818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23819 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23820 if (!SWIG_IsOK(res1)) {
23821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23822 }
23823 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23824 {
23825 arg2 = &temp2;
23826 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
23827 }
23828 {
23829 PyThreadState* __tstate = wxPyBeginAllowThreads();
23830 (arg1)->SetPosition((wxPoint const &)*arg2);
23831 wxPyEndAllowThreads(__tstate);
23832 if (PyErr_Occurred()) SWIG_fail;
23833 }
23834 resultobj = SWIG_Py_Void();
23835 return resultobj;
23836 fail:
23837 return NULL;
23838 }
23839
23840
23841 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23842 PyObject *obj;
23843 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23844 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
23845 return SWIG_Py_Void();
23846 }
23847
23848 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23849 return SWIG_Python_InitShadowInstance(args);
23850 }
23851
23852 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23853 PyObject *resultobj = 0;
23854 int arg1 = (int) 0 ;
23855 wxPaintEvent *result = 0 ;
23856 int val1 ;
23857 int ecode1 = 0 ;
23858 PyObject * obj0 = 0 ;
23859 char * kwnames[] = {
23860 (char *) "Id", NULL
23861 };
23862
23863 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
23864 if (obj0) {
23865 ecode1 = SWIG_AsVal_int(obj0, &val1);
23866 if (!SWIG_IsOK(ecode1)) {
23867 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
23868 }
23869 arg1 = static_cast< int >(val1);
23870 }
23871 {
23872 PyThreadState* __tstate = wxPyBeginAllowThreads();
23873 result = (wxPaintEvent *)new wxPaintEvent(arg1);
23874 wxPyEndAllowThreads(__tstate);
23875 if (PyErr_Occurred()) SWIG_fail;
23876 }
23877 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
23878 return resultobj;
23879 fail:
23880 return NULL;
23881 }
23882
23883
23884 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23885 PyObject *obj;
23886 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23887 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
23888 return SWIG_Py_Void();
23889 }
23890
23891 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23892 return SWIG_Python_InitShadowInstance(args);
23893 }
23894
23895 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23896 PyObject *resultobj = 0;
23897 int arg1 = (int) 0 ;
23898 wxNcPaintEvent *result = 0 ;
23899 int val1 ;
23900 int ecode1 = 0 ;
23901 PyObject * obj0 = 0 ;
23902 char * kwnames[] = {
23903 (char *) "winid", NULL
23904 };
23905
23906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
23907 if (obj0) {
23908 ecode1 = SWIG_AsVal_int(obj0, &val1);
23909 if (!SWIG_IsOK(ecode1)) {
23910 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
23911 }
23912 arg1 = static_cast< int >(val1);
23913 }
23914 {
23915 PyThreadState* __tstate = wxPyBeginAllowThreads();
23916 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
23917 wxPyEndAllowThreads(__tstate);
23918 if (PyErr_Occurred()) SWIG_fail;
23919 }
23920 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
23921 return resultobj;
23922 fail:
23923 return NULL;
23924 }
23925
23926
23927 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23928 PyObject *obj;
23929 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23930 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
23931 return SWIG_Py_Void();
23932 }
23933
23934 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23935 return SWIG_Python_InitShadowInstance(args);
23936 }
23937
23938 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23939 PyObject *resultobj = 0;
23940 int arg1 = (int) 0 ;
23941 wxDC *arg2 = (wxDC *) NULL ;
23942 wxEraseEvent *result = 0 ;
23943 int val1 ;
23944 int ecode1 = 0 ;
23945 void *argp2 = 0 ;
23946 int res2 = 0 ;
23947 PyObject * obj0 = 0 ;
23948 PyObject * obj1 = 0 ;
23949 char * kwnames[] = {
23950 (char *) "Id",(char *) "dc", NULL
23951 };
23952
23953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23954 if (obj0) {
23955 ecode1 = SWIG_AsVal_int(obj0, &val1);
23956 if (!SWIG_IsOK(ecode1)) {
23957 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
23958 }
23959 arg1 = static_cast< int >(val1);
23960 }
23961 if (obj1) {
23962 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
23963 if (!SWIG_IsOK(res2)) {
23964 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
23965 }
23966 arg2 = reinterpret_cast< wxDC * >(argp2);
23967 }
23968 {
23969 PyThreadState* __tstate = wxPyBeginAllowThreads();
23970 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
23971 wxPyEndAllowThreads(__tstate);
23972 if (PyErr_Occurred()) SWIG_fail;
23973 }
23974 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
23975 return resultobj;
23976 fail:
23977 return NULL;
23978 }
23979
23980
23981 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23982 PyObject *resultobj = 0;
23983 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
23984 wxDC *result = 0 ;
23985 void *argp1 = 0 ;
23986 int res1 = 0 ;
23987 PyObject *swig_obj[1] ;
23988
23989 if (!args) SWIG_fail;
23990 swig_obj[0] = args;
23991 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
23992 if (!SWIG_IsOK(res1)) {
23993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
23994 }
23995 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
23996 {
23997 PyThreadState* __tstate = wxPyBeginAllowThreads();
23998 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
23999 wxPyEndAllowThreads(__tstate);
24000 if (PyErr_Occurred()) SWIG_fail;
24001 }
24002 {
24003 resultobj = wxPyMake_wxObject(result, (bool)0);
24004 }
24005 return resultobj;
24006 fail:
24007 return NULL;
24008 }
24009
24010
24011 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24012 PyObject *obj;
24013 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24014 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
24015 return SWIG_Py_Void();
24016 }
24017
24018 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24019 return SWIG_Python_InitShadowInstance(args);
24020 }
24021
24022 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24023 PyObject *resultobj = 0;
24024 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24025 int arg2 = (int) 0 ;
24026 wxFocusEvent *result = 0 ;
24027 int val1 ;
24028 int ecode1 = 0 ;
24029 int val2 ;
24030 int ecode2 = 0 ;
24031 PyObject * obj0 = 0 ;
24032 PyObject * obj1 = 0 ;
24033 char * kwnames[] = {
24034 (char *) "type",(char *) "winid", NULL
24035 };
24036
24037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24038 if (obj0) {
24039 ecode1 = SWIG_AsVal_int(obj0, &val1);
24040 if (!SWIG_IsOK(ecode1)) {
24041 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24042 }
24043 arg1 = static_cast< wxEventType >(val1);
24044 }
24045 if (obj1) {
24046 ecode2 = SWIG_AsVal_int(obj1, &val2);
24047 if (!SWIG_IsOK(ecode2)) {
24048 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
24049 }
24050 arg2 = static_cast< int >(val2);
24051 }
24052 {
24053 PyThreadState* __tstate = wxPyBeginAllowThreads();
24054 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
24055 wxPyEndAllowThreads(__tstate);
24056 if (PyErr_Occurred()) SWIG_fail;
24057 }
24058 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
24059 return resultobj;
24060 fail:
24061 return NULL;
24062 }
24063
24064
24065 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24066 PyObject *resultobj = 0;
24067 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
24068 wxWindow *result = 0 ;
24069 void *argp1 = 0 ;
24070 int res1 = 0 ;
24071 PyObject *swig_obj[1] ;
24072
24073 if (!args) SWIG_fail;
24074 swig_obj[0] = args;
24075 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
24076 if (!SWIG_IsOK(res1)) {
24077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
24078 }
24079 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
24080 {
24081 PyThreadState* __tstate = wxPyBeginAllowThreads();
24082 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
24083 wxPyEndAllowThreads(__tstate);
24084 if (PyErr_Occurred()) SWIG_fail;
24085 }
24086 {
24087 resultobj = wxPyMake_wxObject(result, (bool)0);
24088 }
24089 return resultobj;
24090 fail:
24091 return NULL;
24092 }
24093
24094
24095 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24096 PyObject *resultobj = 0;
24097 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
24098 wxWindow *arg2 = (wxWindow *) 0 ;
24099 void *argp1 = 0 ;
24100 int res1 = 0 ;
24101 void *argp2 = 0 ;
24102 int res2 = 0 ;
24103 PyObject * obj0 = 0 ;
24104 PyObject * obj1 = 0 ;
24105 char * kwnames[] = {
24106 (char *) "self",(char *) "win", NULL
24107 };
24108
24109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
24110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
24111 if (!SWIG_IsOK(res1)) {
24112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
24113 }
24114 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
24115 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
24116 if (!SWIG_IsOK(res2)) {
24117 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
24118 }
24119 arg2 = reinterpret_cast< wxWindow * >(argp2);
24120 {
24121 PyThreadState* __tstate = wxPyBeginAllowThreads();
24122 (arg1)->SetWindow(arg2);
24123 wxPyEndAllowThreads(__tstate);
24124 if (PyErr_Occurred()) SWIG_fail;
24125 }
24126 resultobj = SWIG_Py_Void();
24127 return resultobj;
24128 fail:
24129 return NULL;
24130 }
24131
24132
24133 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24134 PyObject *obj;
24135 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24136 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
24137 return SWIG_Py_Void();
24138 }
24139
24140 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24141 return SWIG_Python_InitShadowInstance(args);
24142 }
24143
24144 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24145 PyObject *resultobj = 0;
24146 wxWindow *arg1 = (wxWindow *) NULL ;
24147 wxChildFocusEvent *result = 0 ;
24148 void *argp1 = 0 ;
24149 int res1 = 0 ;
24150 PyObject * obj0 = 0 ;
24151 char * kwnames[] = {
24152 (char *) "win", NULL
24153 };
24154
24155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
24156 if (obj0) {
24157 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
24158 if (!SWIG_IsOK(res1)) {
24159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
24160 }
24161 arg1 = reinterpret_cast< wxWindow * >(argp1);
24162 }
24163 {
24164 PyThreadState* __tstate = wxPyBeginAllowThreads();
24165 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
24166 wxPyEndAllowThreads(__tstate);
24167 if (PyErr_Occurred()) SWIG_fail;
24168 }
24169 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
24170 return resultobj;
24171 fail:
24172 return NULL;
24173 }
24174
24175
24176 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24177 PyObject *resultobj = 0;
24178 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
24179 wxWindow *result = 0 ;
24180 void *argp1 = 0 ;
24181 int res1 = 0 ;
24182 PyObject *swig_obj[1] ;
24183
24184 if (!args) SWIG_fail;
24185 swig_obj[0] = args;
24186 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
24187 if (!SWIG_IsOK(res1)) {
24188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
24189 }
24190 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
24191 {
24192 PyThreadState* __tstate = wxPyBeginAllowThreads();
24193 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
24194 wxPyEndAllowThreads(__tstate);
24195 if (PyErr_Occurred()) SWIG_fail;
24196 }
24197 {
24198 resultobj = wxPyMake_wxObject(result, (bool)0);
24199 }
24200 return resultobj;
24201 fail:
24202 return NULL;
24203 }
24204
24205
24206 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24207 PyObject *obj;
24208 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24209 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
24210 return SWIG_Py_Void();
24211 }
24212
24213 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24214 return SWIG_Python_InitShadowInstance(args);
24215 }
24216
24217 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24218 PyObject *resultobj = 0;
24219 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24220 bool arg2 = (bool) true ;
24221 int arg3 = (int) 0 ;
24222 wxActivateEvent *result = 0 ;
24223 int val1 ;
24224 int ecode1 = 0 ;
24225 bool val2 ;
24226 int ecode2 = 0 ;
24227 int val3 ;
24228 int ecode3 = 0 ;
24229 PyObject * obj0 = 0 ;
24230 PyObject * obj1 = 0 ;
24231 PyObject * obj2 = 0 ;
24232 char * kwnames[] = {
24233 (char *) "type",(char *) "active",(char *) "Id", NULL
24234 };
24235
24236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24237 if (obj0) {
24238 ecode1 = SWIG_AsVal_int(obj0, &val1);
24239 if (!SWIG_IsOK(ecode1)) {
24240 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24241 }
24242 arg1 = static_cast< wxEventType >(val1);
24243 }
24244 if (obj1) {
24245 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24246 if (!SWIG_IsOK(ecode2)) {
24247 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
24248 }
24249 arg2 = static_cast< bool >(val2);
24250 }
24251 if (obj2) {
24252 ecode3 = SWIG_AsVal_int(obj2, &val3);
24253 if (!SWIG_IsOK(ecode3)) {
24254 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
24255 }
24256 arg3 = static_cast< int >(val3);
24257 }
24258 {
24259 PyThreadState* __tstate = wxPyBeginAllowThreads();
24260 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
24261 wxPyEndAllowThreads(__tstate);
24262 if (PyErr_Occurred()) SWIG_fail;
24263 }
24264 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
24265 return resultobj;
24266 fail:
24267 return NULL;
24268 }
24269
24270
24271 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24272 PyObject *resultobj = 0;
24273 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
24274 bool result;
24275 void *argp1 = 0 ;
24276 int res1 = 0 ;
24277 PyObject *swig_obj[1] ;
24278
24279 if (!args) SWIG_fail;
24280 swig_obj[0] = args;
24281 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
24282 if (!SWIG_IsOK(res1)) {
24283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
24284 }
24285 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
24286 {
24287 PyThreadState* __tstate = wxPyBeginAllowThreads();
24288 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
24289 wxPyEndAllowThreads(__tstate);
24290 if (PyErr_Occurred()) SWIG_fail;
24291 }
24292 {
24293 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24294 }
24295 return resultobj;
24296 fail:
24297 return NULL;
24298 }
24299
24300
24301 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24302 PyObject *obj;
24303 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24304 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
24305 return SWIG_Py_Void();
24306 }
24307
24308 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24309 return SWIG_Python_InitShadowInstance(args);
24310 }
24311
24312 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24313 PyObject *resultobj = 0;
24314 int arg1 = (int) 0 ;
24315 wxInitDialogEvent *result = 0 ;
24316 int val1 ;
24317 int ecode1 = 0 ;
24318 PyObject * obj0 = 0 ;
24319 char * kwnames[] = {
24320 (char *) "Id", NULL
24321 };
24322
24323 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
24324 if (obj0) {
24325 ecode1 = SWIG_AsVal_int(obj0, &val1);
24326 if (!SWIG_IsOK(ecode1)) {
24327 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
24328 }
24329 arg1 = static_cast< int >(val1);
24330 }
24331 {
24332 PyThreadState* __tstate = wxPyBeginAllowThreads();
24333 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
24334 wxPyEndAllowThreads(__tstate);
24335 if (PyErr_Occurred()) SWIG_fail;
24336 }
24337 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
24338 return resultobj;
24339 fail:
24340 return NULL;
24341 }
24342
24343
24344 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24345 PyObject *obj;
24346 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24347 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
24348 return SWIG_Py_Void();
24349 }
24350
24351 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24352 return SWIG_Python_InitShadowInstance(args);
24353 }
24354
24355 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24356 PyObject *resultobj = 0;
24357 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24358 int arg2 = (int) 0 ;
24359 wxMenu *arg3 = (wxMenu *) NULL ;
24360 wxMenuEvent *result = 0 ;
24361 int val1 ;
24362 int ecode1 = 0 ;
24363 int val2 ;
24364 int ecode2 = 0 ;
24365 void *argp3 = 0 ;
24366 int res3 = 0 ;
24367 PyObject * obj0 = 0 ;
24368 PyObject * obj1 = 0 ;
24369 PyObject * obj2 = 0 ;
24370 char * kwnames[] = {
24371 (char *) "type",(char *) "winid",(char *) "menu", NULL
24372 };
24373
24374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24375 if (obj0) {
24376 ecode1 = SWIG_AsVal_int(obj0, &val1);
24377 if (!SWIG_IsOK(ecode1)) {
24378 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24379 }
24380 arg1 = static_cast< wxEventType >(val1);
24381 }
24382 if (obj1) {
24383 ecode2 = SWIG_AsVal_int(obj1, &val2);
24384 if (!SWIG_IsOK(ecode2)) {
24385 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
24386 }
24387 arg2 = static_cast< int >(val2);
24388 }
24389 if (obj2) {
24390 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
24391 if (!SWIG_IsOK(res3)) {
24392 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
24393 }
24394 arg3 = reinterpret_cast< wxMenu * >(argp3);
24395 }
24396 {
24397 PyThreadState* __tstate = wxPyBeginAllowThreads();
24398 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
24399 wxPyEndAllowThreads(__tstate);
24400 if (PyErr_Occurred()) SWIG_fail;
24401 }
24402 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
24403 return resultobj;
24404 fail:
24405 return NULL;
24406 }
24407
24408
24409 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24410 PyObject *resultobj = 0;
24411 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24412 int result;
24413 void *argp1 = 0 ;
24414 int res1 = 0 ;
24415 PyObject *swig_obj[1] ;
24416
24417 if (!args) SWIG_fail;
24418 swig_obj[0] = args;
24419 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24420 if (!SWIG_IsOK(res1)) {
24421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24422 }
24423 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24424 {
24425 PyThreadState* __tstate = wxPyBeginAllowThreads();
24426 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
24427 wxPyEndAllowThreads(__tstate);
24428 if (PyErr_Occurred()) SWIG_fail;
24429 }
24430 resultobj = SWIG_From_int(static_cast< int >(result));
24431 return resultobj;
24432 fail:
24433 return NULL;
24434 }
24435
24436
24437 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24438 PyObject *resultobj = 0;
24439 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24440 bool result;
24441 void *argp1 = 0 ;
24442 int res1 = 0 ;
24443 PyObject *swig_obj[1] ;
24444
24445 if (!args) SWIG_fail;
24446 swig_obj[0] = args;
24447 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24448 if (!SWIG_IsOK(res1)) {
24449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24450 }
24451 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24452 {
24453 PyThreadState* __tstate = wxPyBeginAllowThreads();
24454 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
24455 wxPyEndAllowThreads(__tstate);
24456 if (PyErr_Occurred()) SWIG_fail;
24457 }
24458 {
24459 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24460 }
24461 return resultobj;
24462 fail:
24463 return NULL;
24464 }
24465
24466
24467 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24468 PyObject *resultobj = 0;
24469 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24470 wxMenu *result = 0 ;
24471 void *argp1 = 0 ;
24472 int res1 = 0 ;
24473 PyObject *swig_obj[1] ;
24474
24475 if (!args) SWIG_fail;
24476 swig_obj[0] = args;
24477 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24478 if (!SWIG_IsOK(res1)) {
24479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24480 }
24481 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24482 {
24483 PyThreadState* __tstate = wxPyBeginAllowThreads();
24484 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
24485 wxPyEndAllowThreads(__tstate);
24486 if (PyErr_Occurred()) SWIG_fail;
24487 }
24488 {
24489 resultobj = wxPyMake_wxObject(result, (bool)0);
24490 }
24491 return resultobj;
24492 fail:
24493 return NULL;
24494 }
24495
24496
24497 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24498 PyObject *obj;
24499 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24500 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
24501 return SWIG_Py_Void();
24502 }
24503
24504 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24505 return SWIG_Python_InitShadowInstance(args);
24506 }
24507
24508 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24509 PyObject *resultobj = 0;
24510 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24511 int arg2 = (int) 0 ;
24512 wxCloseEvent *result = 0 ;
24513 int val1 ;
24514 int ecode1 = 0 ;
24515 int val2 ;
24516 int ecode2 = 0 ;
24517 PyObject * obj0 = 0 ;
24518 PyObject * obj1 = 0 ;
24519 char * kwnames[] = {
24520 (char *) "type",(char *) "winid", NULL
24521 };
24522
24523 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24524 if (obj0) {
24525 ecode1 = SWIG_AsVal_int(obj0, &val1);
24526 if (!SWIG_IsOK(ecode1)) {
24527 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24528 }
24529 arg1 = static_cast< wxEventType >(val1);
24530 }
24531 if (obj1) {
24532 ecode2 = SWIG_AsVal_int(obj1, &val2);
24533 if (!SWIG_IsOK(ecode2)) {
24534 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
24535 }
24536 arg2 = static_cast< int >(val2);
24537 }
24538 {
24539 PyThreadState* __tstate = wxPyBeginAllowThreads();
24540 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
24541 wxPyEndAllowThreads(__tstate);
24542 if (PyErr_Occurred()) SWIG_fail;
24543 }
24544 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
24545 return resultobj;
24546 fail:
24547 return NULL;
24548 }
24549
24550
24551 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24552 PyObject *resultobj = 0;
24553 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24554 bool arg2 ;
24555 void *argp1 = 0 ;
24556 int res1 = 0 ;
24557 bool val2 ;
24558 int ecode2 = 0 ;
24559 PyObject * obj0 = 0 ;
24560 PyObject * obj1 = 0 ;
24561 char * kwnames[] = {
24562 (char *) "self",(char *) "logOff", NULL
24563 };
24564
24565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
24566 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24567 if (!SWIG_IsOK(res1)) {
24568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24569 }
24570 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24571 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24572 if (!SWIG_IsOK(ecode2)) {
24573 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
24574 }
24575 arg2 = static_cast< bool >(val2);
24576 {
24577 PyThreadState* __tstate = wxPyBeginAllowThreads();
24578 (arg1)->SetLoggingOff(arg2);
24579 wxPyEndAllowThreads(__tstate);
24580 if (PyErr_Occurred()) SWIG_fail;
24581 }
24582 resultobj = SWIG_Py_Void();
24583 return resultobj;
24584 fail:
24585 return NULL;
24586 }
24587
24588
24589 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24590 PyObject *resultobj = 0;
24591 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24592 bool result;
24593 void *argp1 = 0 ;
24594 int res1 = 0 ;
24595 PyObject *swig_obj[1] ;
24596
24597 if (!args) SWIG_fail;
24598 swig_obj[0] = args;
24599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24600 if (!SWIG_IsOK(res1)) {
24601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24602 }
24603 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24604 {
24605 PyThreadState* __tstate = wxPyBeginAllowThreads();
24606 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
24607 wxPyEndAllowThreads(__tstate);
24608 if (PyErr_Occurred()) SWIG_fail;
24609 }
24610 {
24611 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24612 }
24613 return resultobj;
24614 fail:
24615 return NULL;
24616 }
24617
24618
24619 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24620 PyObject *resultobj = 0;
24621 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24622 bool arg2 = (bool) true ;
24623 void *argp1 = 0 ;
24624 int res1 = 0 ;
24625 bool val2 ;
24626 int ecode2 = 0 ;
24627 PyObject * obj0 = 0 ;
24628 PyObject * obj1 = 0 ;
24629 char * kwnames[] = {
24630 (char *) "self",(char *) "veto", NULL
24631 };
24632
24633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
24634 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24635 if (!SWIG_IsOK(res1)) {
24636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24637 }
24638 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24639 if (obj1) {
24640 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24641 if (!SWIG_IsOK(ecode2)) {
24642 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
24643 }
24644 arg2 = static_cast< bool >(val2);
24645 }
24646 {
24647 PyThreadState* __tstate = wxPyBeginAllowThreads();
24648 (arg1)->Veto(arg2);
24649 wxPyEndAllowThreads(__tstate);
24650 if (PyErr_Occurred()) SWIG_fail;
24651 }
24652 resultobj = SWIG_Py_Void();
24653 return resultobj;
24654 fail:
24655 return NULL;
24656 }
24657
24658
24659 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24660 PyObject *resultobj = 0;
24661 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24662 bool result;
24663 void *argp1 = 0 ;
24664 int res1 = 0 ;
24665 PyObject *swig_obj[1] ;
24666
24667 if (!args) SWIG_fail;
24668 swig_obj[0] = args;
24669 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24670 if (!SWIG_IsOK(res1)) {
24671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24672 }
24673 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24674 {
24675 PyThreadState* __tstate = wxPyBeginAllowThreads();
24676 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
24677 wxPyEndAllowThreads(__tstate);
24678 if (PyErr_Occurred()) SWIG_fail;
24679 }
24680 {
24681 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24682 }
24683 return resultobj;
24684 fail:
24685 return NULL;
24686 }
24687
24688
24689 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24690 PyObject *resultobj = 0;
24691 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24692 bool arg2 ;
24693 void *argp1 = 0 ;
24694 int res1 = 0 ;
24695 bool val2 ;
24696 int ecode2 = 0 ;
24697 PyObject * obj0 = 0 ;
24698 PyObject * obj1 = 0 ;
24699 char * kwnames[] = {
24700 (char *) "self",(char *) "canVeto", NULL
24701 };
24702
24703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
24704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24705 if (!SWIG_IsOK(res1)) {
24706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24707 }
24708 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24709 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24710 if (!SWIG_IsOK(ecode2)) {
24711 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
24712 }
24713 arg2 = static_cast< bool >(val2);
24714 {
24715 PyThreadState* __tstate = wxPyBeginAllowThreads();
24716 (arg1)->SetCanVeto(arg2);
24717 wxPyEndAllowThreads(__tstate);
24718 if (PyErr_Occurred()) SWIG_fail;
24719 }
24720 resultobj = SWIG_Py_Void();
24721 return resultobj;
24722 fail:
24723 return NULL;
24724 }
24725
24726
24727 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24728 PyObject *resultobj = 0;
24729 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24730 bool result;
24731 void *argp1 = 0 ;
24732 int res1 = 0 ;
24733 PyObject *swig_obj[1] ;
24734
24735 if (!args) SWIG_fail;
24736 swig_obj[0] = args;
24737 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24738 if (!SWIG_IsOK(res1)) {
24739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24740 }
24741 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24742 {
24743 PyThreadState* __tstate = wxPyBeginAllowThreads();
24744 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
24745 wxPyEndAllowThreads(__tstate);
24746 if (PyErr_Occurred()) SWIG_fail;
24747 }
24748 {
24749 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24750 }
24751 return resultobj;
24752 fail:
24753 return NULL;
24754 }
24755
24756
24757 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24758 PyObject *obj;
24759 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24760 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
24761 return SWIG_Py_Void();
24762 }
24763
24764 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24765 return SWIG_Python_InitShadowInstance(args);
24766 }
24767
24768 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24769 PyObject *resultobj = 0;
24770 int arg1 = (int) 0 ;
24771 bool arg2 = (bool) false ;
24772 wxShowEvent *result = 0 ;
24773 int val1 ;
24774 int ecode1 = 0 ;
24775 bool val2 ;
24776 int ecode2 = 0 ;
24777 PyObject * obj0 = 0 ;
24778 PyObject * obj1 = 0 ;
24779 char * kwnames[] = {
24780 (char *) "winid",(char *) "show", NULL
24781 };
24782
24783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24784 if (obj0) {
24785 ecode1 = SWIG_AsVal_int(obj0, &val1);
24786 if (!SWIG_IsOK(ecode1)) {
24787 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
24788 }
24789 arg1 = static_cast< int >(val1);
24790 }
24791 if (obj1) {
24792 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24793 if (!SWIG_IsOK(ecode2)) {
24794 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
24795 }
24796 arg2 = static_cast< bool >(val2);
24797 }
24798 {
24799 PyThreadState* __tstate = wxPyBeginAllowThreads();
24800 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
24801 wxPyEndAllowThreads(__tstate);
24802 if (PyErr_Occurred()) SWIG_fail;
24803 }
24804 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
24805 return resultobj;
24806 fail:
24807 return NULL;
24808 }
24809
24810
24811 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24812 PyObject *resultobj = 0;
24813 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24814 bool arg2 ;
24815 void *argp1 = 0 ;
24816 int res1 = 0 ;
24817 bool val2 ;
24818 int ecode2 = 0 ;
24819 PyObject * obj0 = 0 ;
24820 PyObject * obj1 = 0 ;
24821 char * kwnames[] = {
24822 (char *) "self",(char *) "show", NULL
24823 };
24824
24825 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
24826 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24827 if (!SWIG_IsOK(res1)) {
24828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
24829 }
24830 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24831 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24832 if (!SWIG_IsOK(ecode2)) {
24833 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
24834 }
24835 arg2 = static_cast< bool >(val2);
24836 {
24837 PyThreadState* __tstate = wxPyBeginAllowThreads();
24838 (arg1)->SetShow(arg2);
24839 wxPyEndAllowThreads(__tstate);
24840 if (PyErr_Occurred()) SWIG_fail;
24841 }
24842 resultobj = SWIG_Py_Void();
24843 return resultobj;
24844 fail:
24845 return NULL;
24846 }
24847
24848
24849 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24850 PyObject *resultobj = 0;
24851 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24852 bool result;
24853 void *argp1 = 0 ;
24854 int res1 = 0 ;
24855 PyObject *swig_obj[1] ;
24856
24857 if (!args) SWIG_fail;
24858 swig_obj[0] = args;
24859 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24860 if (!SWIG_IsOK(res1)) {
24861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
24862 }
24863 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24864 {
24865 PyThreadState* __tstate = wxPyBeginAllowThreads();
24866 result = (bool)((wxShowEvent const *)arg1)->GetShow();
24867 wxPyEndAllowThreads(__tstate);
24868 if (PyErr_Occurred()) SWIG_fail;
24869 }
24870 {
24871 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24872 }
24873 return resultobj;
24874 fail:
24875 return NULL;
24876 }
24877
24878
24879 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24880 PyObject *obj;
24881 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24882 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
24883 return SWIG_Py_Void();
24884 }
24885
24886 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24887 return SWIG_Python_InitShadowInstance(args);
24888 }
24889
24890 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24891 PyObject *resultobj = 0;
24892 int arg1 = (int) 0 ;
24893 bool arg2 = (bool) true ;
24894 wxIconizeEvent *result = 0 ;
24895 int val1 ;
24896 int ecode1 = 0 ;
24897 bool val2 ;
24898 int ecode2 = 0 ;
24899 PyObject * obj0 = 0 ;
24900 PyObject * obj1 = 0 ;
24901 char * kwnames[] = {
24902 (char *) "id",(char *) "iconized", NULL
24903 };
24904
24905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24906 if (obj0) {
24907 ecode1 = SWIG_AsVal_int(obj0, &val1);
24908 if (!SWIG_IsOK(ecode1)) {
24909 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
24910 }
24911 arg1 = static_cast< int >(val1);
24912 }
24913 if (obj1) {
24914 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24915 if (!SWIG_IsOK(ecode2)) {
24916 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
24917 }
24918 arg2 = static_cast< bool >(val2);
24919 }
24920 {
24921 PyThreadState* __tstate = wxPyBeginAllowThreads();
24922 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
24923 wxPyEndAllowThreads(__tstate);
24924 if (PyErr_Occurred()) SWIG_fail;
24925 }
24926 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
24927 return resultobj;
24928 fail:
24929 return NULL;
24930 }
24931
24932
24933 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24934 PyObject *resultobj = 0;
24935 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
24936 bool result;
24937 void *argp1 = 0 ;
24938 int res1 = 0 ;
24939 PyObject *swig_obj[1] ;
24940
24941 if (!args) SWIG_fail;
24942 swig_obj[0] = args;
24943 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
24944 if (!SWIG_IsOK(res1)) {
24945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
24946 }
24947 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
24948 {
24949 PyThreadState* __tstate = wxPyBeginAllowThreads();
24950 result = (bool)(arg1)->Iconized();
24951 wxPyEndAllowThreads(__tstate);
24952 if (PyErr_Occurred()) SWIG_fail;
24953 }
24954 {
24955 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24956 }
24957 return resultobj;
24958 fail:
24959 return NULL;
24960 }
24961
24962
24963 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24964 PyObject *obj;
24965 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24966 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
24967 return SWIG_Py_Void();
24968 }
24969
24970 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24971 return SWIG_Python_InitShadowInstance(args);
24972 }
24973
24974 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24975 PyObject *resultobj = 0;
24976 int arg1 = (int) 0 ;
24977 wxMaximizeEvent *result = 0 ;
24978 int val1 ;
24979 int ecode1 = 0 ;
24980 PyObject * obj0 = 0 ;
24981 char * kwnames[] = {
24982 (char *) "id", NULL
24983 };
24984
24985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
24986 if (obj0) {
24987 ecode1 = SWIG_AsVal_int(obj0, &val1);
24988 if (!SWIG_IsOK(ecode1)) {
24989 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
24990 }
24991 arg1 = static_cast< int >(val1);
24992 }
24993 {
24994 PyThreadState* __tstate = wxPyBeginAllowThreads();
24995 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
24996 wxPyEndAllowThreads(__tstate);
24997 if (PyErr_Occurred()) SWIG_fail;
24998 }
24999 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
25000 return resultobj;
25001 fail:
25002 return NULL;
25003 }
25004
25005
25006 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25007 PyObject *obj;
25008 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25009 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
25010 return SWIG_Py_Void();
25011 }
25012
25013 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25014 return SWIG_Python_InitShadowInstance(args);
25015 }
25016
25017 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25018 PyObject *resultobj = 0;
25019 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
25020 wxPoint result;
25021 void *argp1 = 0 ;
25022 int res1 = 0 ;
25023 PyObject *swig_obj[1] ;
25024
25025 if (!args) SWIG_fail;
25026 swig_obj[0] = args;
25027 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
25028 if (!SWIG_IsOK(res1)) {
25029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
25030 }
25031 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
25032 {
25033 PyThreadState* __tstate = wxPyBeginAllowThreads();
25034 result = (arg1)->GetPosition();
25035 wxPyEndAllowThreads(__tstate);
25036 if (PyErr_Occurred()) SWIG_fail;
25037 }
25038 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
25039 return resultobj;
25040 fail:
25041 return NULL;
25042 }
25043
25044
25045 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25046 PyObject *resultobj = 0;
25047 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
25048 int result;
25049 void *argp1 = 0 ;
25050 int res1 = 0 ;
25051 PyObject *swig_obj[1] ;
25052
25053 if (!args) SWIG_fail;
25054 swig_obj[0] = args;
25055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
25056 if (!SWIG_IsOK(res1)) {
25057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
25058 }
25059 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
25060 {
25061 PyThreadState* __tstate = wxPyBeginAllowThreads();
25062 result = (int)(arg1)->GetNumberOfFiles();
25063 wxPyEndAllowThreads(__tstate);
25064 if (PyErr_Occurred()) SWIG_fail;
25065 }
25066 resultobj = SWIG_From_int(static_cast< int >(result));
25067 return resultobj;
25068 fail:
25069 return NULL;
25070 }
25071
25072
25073 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25074 PyObject *resultobj = 0;
25075 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
25076 PyObject *result = 0 ;
25077 void *argp1 = 0 ;
25078 int res1 = 0 ;
25079 PyObject *swig_obj[1] ;
25080
25081 if (!args) SWIG_fail;
25082 swig_obj[0] = args;
25083 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
25084 if (!SWIG_IsOK(res1)) {
25085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
25086 }
25087 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
25088 {
25089 PyThreadState* __tstate = wxPyBeginAllowThreads();
25090 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
25091 wxPyEndAllowThreads(__tstate);
25092 if (PyErr_Occurred()) SWIG_fail;
25093 }
25094 resultobj = result;
25095 return resultobj;
25096 fail:
25097 return NULL;
25098 }
25099
25100
25101 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25102 PyObject *obj;
25103 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25104 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
25105 return SWIG_Py_Void();
25106 }
25107
25108 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25109 PyObject *resultobj = 0;
25110 int arg1 = (int) 0 ;
25111 wxUpdateUIEvent *result = 0 ;
25112 int val1 ;
25113 int ecode1 = 0 ;
25114 PyObject * obj0 = 0 ;
25115 char * kwnames[] = {
25116 (char *) "commandId", NULL
25117 };
25118
25119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
25120 if (obj0) {
25121 ecode1 = SWIG_AsVal_int(obj0, &val1);
25122 if (!SWIG_IsOK(ecode1)) {
25123 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
25124 }
25125 arg1 = static_cast< int >(val1);
25126 }
25127 {
25128 PyThreadState* __tstate = wxPyBeginAllowThreads();
25129 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
25130 wxPyEndAllowThreads(__tstate);
25131 if (PyErr_Occurred()) SWIG_fail;
25132 }
25133 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
25134 return resultobj;
25135 fail:
25136 return NULL;
25137 }
25138
25139
25140 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25141 PyObject *resultobj = 0;
25142 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25143 bool result;
25144 void *argp1 = 0 ;
25145 int res1 = 0 ;
25146 PyObject *swig_obj[1] ;
25147
25148 if (!args) SWIG_fail;
25149 swig_obj[0] = args;
25150 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25151 if (!SWIG_IsOK(res1)) {
25152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25153 }
25154 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25155 {
25156 PyThreadState* __tstate = wxPyBeginAllowThreads();
25157 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
25158 wxPyEndAllowThreads(__tstate);
25159 if (PyErr_Occurred()) SWIG_fail;
25160 }
25161 {
25162 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25163 }
25164 return resultobj;
25165 fail:
25166 return NULL;
25167 }
25168
25169
25170 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25171 PyObject *resultobj = 0;
25172 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25173 bool result;
25174 void *argp1 = 0 ;
25175 int res1 = 0 ;
25176 PyObject *swig_obj[1] ;
25177
25178 if (!args) SWIG_fail;
25179 swig_obj[0] = args;
25180 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25181 if (!SWIG_IsOK(res1)) {
25182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25183 }
25184 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25185 {
25186 PyThreadState* __tstate = wxPyBeginAllowThreads();
25187 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
25188 wxPyEndAllowThreads(__tstate);
25189 if (PyErr_Occurred()) SWIG_fail;
25190 }
25191 {
25192 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25193 }
25194 return resultobj;
25195 fail:
25196 return NULL;
25197 }
25198
25199
25200 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25201 PyObject *resultobj = 0;
25202 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25203 bool result;
25204 void *argp1 = 0 ;
25205 int res1 = 0 ;
25206 PyObject *swig_obj[1] ;
25207
25208 if (!args) SWIG_fail;
25209 swig_obj[0] = args;
25210 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25211 if (!SWIG_IsOK(res1)) {
25212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25213 }
25214 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25215 {
25216 PyThreadState* __tstate = wxPyBeginAllowThreads();
25217 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
25218 wxPyEndAllowThreads(__tstate);
25219 if (PyErr_Occurred()) SWIG_fail;
25220 }
25221 {
25222 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25223 }
25224 return resultobj;
25225 fail:
25226 return NULL;
25227 }
25228
25229
25230 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25231 PyObject *resultobj = 0;
25232 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25233 wxString result;
25234 void *argp1 = 0 ;
25235 int res1 = 0 ;
25236 PyObject *swig_obj[1] ;
25237
25238 if (!args) SWIG_fail;
25239 swig_obj[0] = args;
25240 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25241 if (!SWIG_IsOK(res1)) {
25242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25243 }
25244 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25245 {
25246 PyThreadState* __tstate = wxPyBeginAllowThreads();
25247 result = ((wxUpdateUIEvent const *)arg1)->GetText();
25248 wxPyEndAllowThreads(__tstate);
25249 if (PyErr_Occurred()) SWIG_fail;
25250 }
25251 {
25252 #if wxUSE_UNICODE
25253 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25254 #else
25255 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25256 #endif
25257 }
25258 return resultobj;
25259 fail:
25260 return NULL;
25261 }
25262
25263
25264 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25265 PyObject *resultobj = 0;
25266 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25267 bool result;
25268 void *argp1 = 0 ;
25269 int res1 = 0 ;
25270 PyObject *swig_obj[1] ;
25271
25272 if (!args) SWIG_fail;
25273 swig_obj[0] = args;
25274 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25275 if (!SWIG_IsOK(res1)) {
25276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25277 }
25278 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25279 {
25280 PyThreadState* __tstate = wxPyBeginAllowThreads();
25281 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
25282 wxPyEndAllowThreads(__tstate);
25283 if (PyErr_Occurred()) SWIG_fail;
25284 }
25285 {
25286 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25287 }
25288 return resultobj;
25289 fail:
25290 return NULL;
25291 }
25292
25293
25294 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25295 PyObject *resultobj = 0;
25296 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25297 bool result;
25298 void *argp1 = 0 ;
25299 int res1 = 0 ;
25300 PyObject *swig_obj[1] ;
25301
25302 if (!args) SWIG_fail;
25303 swig_obj[0] = args;
25304 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25305 if (!SWIG_IsOK(res1)) {
25306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25307 }
25308 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25309 {
25310 PyThreadState* __tstate = wxPyBeginAllowThreads();
25311 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
25312 wxPyEndAllowThreads(__tstate);
25313 if (PyErr_Occurred()) SWIG_fail;
25314 }
25315 {
25316 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25317 }
25318 return resultobj;
25319 fail:
25320 return NULL;
25321 }
25322
25323
25324 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25325 PyObject *resultobj = 0;
25326 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25327 bool result;
25328 void *argp1 = 0 ;
25329 int res1 = 0 ;
25330 PyObject *swig_obj[1] ;
25331
25332 if (!args) SWIG_fail;
25333 swig_obj[0] = args;
25334 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25335 if (!SWIG_IsOK(res1)) {
25336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25337 }
25338 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25339 {
25340 PyThreadState* __tstate = wxPyBeginAllowThreads();
25341 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
25342 wxPyEndAllowThreads(__tstate);
25343 if (PyErr_Occurred()) SWIG_fail;
25344 }
25345 {
25346 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25347 }
25348 return resultobj;
25349 fail:
25350 return NULL;
25351 }
25352
25353
25354 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25355 PyObject *resultobj = 0;
25356 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25357 bool result;
25358 void *argp1 = 0 ;
25359 int res1 = 0 ;
25360 PyObject *swig_obj[1] ;
25361
25362 if (!args) SWIG_fail;
25363 swig_obj[0] = args;
25364 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25365 if (!SWIG_IsOK(res1)) {
25366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25367 }
25368 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25369 {
25370 PyThreadState* __tstate = wxPyBeginAllowThreads();
25371 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
25372 wxPyEndAllowThreads(__tstate);
25373 if (PyErr_Occurred()) SWIG_fail;
25374 }
25375 {
25376 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25377 }
25378 return resultobj;
25379 fail:
25380 return NULL;
25381 }
25382
25383
25384 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25385 PyObject *resultobj = 0;
25386 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25387 bool arg2 ;
25388 void *argp1 = 0 ;
25389 int res1 = 0 ;
25390 bool val2 ;
25391 int ecode2 = 0 ;
25392 PyObject * obj0 = 0 ;
25393 PyObject * obj1 = 0 ;
25394 char * kwnames[] = {
25395 (char *) "self",(char *) "check", NULL
25396 };
25397
25398 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
25399 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25400 if (!SWIG_IsOK(res1)) {
25401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25402 }
25403 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25404 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25405 if (!SWIG_IsOK(ecode2)) {
25406 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
25407 }
25408 arg2 = static_cast< bool >(val2);
25409 {
25410 PyThreadState* __tstate = wxPyBeginAllowThreads();
25411 (arg1)->Check(arg2);
25412 wxPyEndAllowThreads(__tstate);
25413 if (PyErr_Occurred()) SWIG_fail;
25414 }
25415 resultobj = SWIG_Py_Void();
25416 return resultobj;
25417 fail:
25418 return NULL;
25419 }
25420
25421
25422 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25423 PyObject *resultobj = 0;
25424 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25425 bool arg2 ;
25426 void *argp1 = 0 ;
25427 int res1 = 0 ;
25428 bool val2 ;
25429 int ecode2 = 0 ;
25430 PyObject * obj0 = 0 ;
25431 PyObject * obj1 = 0 ;
25432 char * kwnames[] = {
25433 (char *) "self",(char *) "enable", NULL
25434 };
25435
25436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
25437 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25438 if (!SWIG_IsOK(res1)) {
25439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25440 }
25441 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25442 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25443 if (!SWIG_IsOK(ecode2)) {
25444 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
25445 }
25446 arg2 = static_cast< bool >(val2);
25447 {
25448 PyThreadState* __tstate = wxPyBeginAllowThreads();
25449 (arg1)->Enable(arg2);
25450 wxPyEndAllowThreads(__tstate);
25451 if (PyErr_Occurred()) SWIG_fail;
25452 }
25453 resultobj = SWIG_Py_Void();
25454 return resultobj;
25455 fail:
25456 return NULL;
25457 }
25458
25459
25460 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25461 PyObject *resultobj = 0;
25462 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25463 bool arg2 ;
25464 void *argp1 = 0 ;
25465 int res1 = 0 ;
25466 bool val2 ;
25467 int ecode2 = 0 ;
25468 PyObject * obj0 = 0 ;
25469 PyObject * obj1 = 0 ;
25470 char * kwnames[] = {
25471 (char *) "self",(char *) "show", NULL
25472 };
25473
25474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
25475 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25476 if (!SWIG_IsOK(res1)) {
25477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25478 }
25479 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25480 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25481 if (!SWIG_IsOK(ecode2)) {
25482 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
25483 }
25484 arg2 = static_cast< bool >(val2);
25485 {
25486 PyThreadState* __tstate = wxPyBeginAllowThreads();
25487 (arg1)->Show(arg2);
25488 wxPyEndAllowThreads(__tstate);
25489 if (PyErr_Occurred()) SWIG_fail;
25490 }
25491 resultobj = SWIG_Py_Void();
25492 return resultobj;
25493 fail:
25494 return NULL;
25495 }
25496
25497
25498 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25499 PyObject *resultobj = 0;
25500 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25501 wxString *arg2 = 0 ;
25502 void *argp1 = 0 ;
25503 int res1 = 0 ;
25504 bool temp2 = false ;
25505 PyObject * obj0 = 0 ;
25506 PyObject * obj1 = 0 ;
25507 char * kwnames[] = {
25508 (char *) "self",(char *) "text", NULL
25509 };
25510
25511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
25512 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25513 if (!SWIG_IsOK(res1)) {
25514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25515 }
25516 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25517 {
25518 arg2 = wxString_in_helper(obj1);
25519 if (arg2 == NULL) SWIG_fail;
25520 temp2 = true;
25521 }
25522 {
25523 PyThreadState* __tstate = wxPyBeginAllowThreads();
25524 (arg1)->SetText((wxString const &)*arg2);
25525 wxPyEndAllowThreads(__tstate);
25526 if (PyErr_Occurred()) SWIG_fail;
25527 }
25528 resultobj = SWIG_Py_Void();
25529 {
25530 if (temp2)
25531 delete arg2;
25532 }
25533 return resultobj;
25534 fail:
25535 {
25536 if (temp2)
25537 delete arg2;
25538 }
25539 return NULL;
25540 }
25541
25542
25543 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25544 PyObject *resultobj = 0;
25545 long arg1 ;
25546 long val1 ;
25547 int ecode1 = 0 ;
25548 PyObject * obj0 = 0 ;
25549 char * kwnames[] = {
25550 (char *) "updateInterval", NULL
25551 };
25552
25553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
25554 ecode1 = SWIG_AsVal_long(obj0, &val1);
25555 if (!SWIG_IsOK(ecode1)) {
25556 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
25557 }
25558 arg1 = static_cast< long >(val1);
25559 {
25560 PyThreadState* __tstate = wxPyBeginAllowThreads();
25561 wxUpdateUIEvent::SetUpdateInterval(arg1);
25562 wxPyEndAllowThreads(__tstate);
25563 if (PyErr_Occurred()) SWIG_fail;
25564 }
25565 resultobj = SWIG_Py_Void();
25566 return resultobj;
25567 fail:
25568 return NULL;
25569 }
25570
25571
25572 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25573 PyObject *resultobj = 0;
25574 long result;
25575
25576 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
25577 {
25578 PyThreadState* __tstate = wxPyBeginAllowThreads();
25579 result = (long)wxUpdateUIEvent::GetUpdateInterval();
25580 wxPyEndAllowThreads(__tstate);
25581 if (PyErr_Occurred()) SWIG_fail;
25582 }
25583 resultobj = SWIG_From_long(static_cast< long >(result));
25584 return resultobj;
25585 fail:
25586 return NULL;
25587 }
25588
25589
25590 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25591 PyObject *resultobj = 0;
25592 wxWindow *arg1 = (wxWindow *) 0 ;
25593 bool result;
25594 void *argp1 = 0 ;
25595 int res1 = 0 ;
25596 PyObject * obj0 = 0 ;
25597 char * kwnames[] = {
25598 (char *) "win", NULL
25599 };
25600
25601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
25602 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25603 if (!SWIG_IsOK(res1)) {
25604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
25605 }
25606 arg1 = reinterpret_cast< wxWindow * >(argp1);
25607 {
25608 PyThreadState* __tstate = wxPyBeginAllowThreads();
25609 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
25610 wxPyEndAllowThreads(__tstate);
25611 if (PyErr_Occurred()) SWIG_fail;
25612 }
25613 {
25614 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25615 }
25616 return resultobj;
25617 fail:
25618 return NULL;
25619 }
25620
25621
25622 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25623 PyObject *resultobj = 0;
25624
25625 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
25626 {
25627 PyThreadState* __tstate = wxPyBeginAllowThreads();
25628 wxUpdateUIEvent::ResetUpdateTime();
25629 wxPyEndAllowThreads(__tstate);
25630 if (PyErr_Occurred()) SWIG_fail;
25631 }
25632 resultobj = SWIG_Py_Void();
25633 return resultobj;
25634 fail:
25635 return NULL;
25636 }
25637
25638
25639 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25640 PyObject *resultobj = 0;
25641 wxUpdateUIMode arg1 ;
25642 int val1 ;
25643 int ecode1 = 0 ;
25644 PyObject * obj0 = 0 ;
25645 char * kwnames[] = {
25646 (char *) "mode", NULL
25647 };
25648
25649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
25650 ecode1 = SWIG_AsVal_int(obj0, &val1);
25651 if (!SWIG_IsOK(ecode1)) {
25652 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
25653 }
25654 arg1 = static_cast< wxUpdateUIMode >(val1);
25655 {
25656 PyThreadState* __tstate = wxPyBeginAllowThreads();
25657 wxUpdateUIEvent::SetMode(arg1);
25658 wxPyEndAllowThreads(__tstate);
25659 if (PyErr_Occurred()) SWIG_fail;
25660 }
25661 resultobj = SWIG_Py_Void();
25662 return resultobj;
25663 fail:
25664 return NULL;
25665 }
25666
25667
25668 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25669 PyObject *resultobj = 0;
25670 wxUpdateUIMode result;
25671
25672 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
25673 {
25674 PyThreadState* __tstate = wxPyBeginAllowThreads();
25675 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
25676 wxPyEndAllowThreads(__tstate);
25677 if (PyErr_Occurred()) SWIG_fail;
25678 }
25679 resultobj = SWIG_From_int(static_cast< int >(result));
25680 return resultobj;
25681 fail:
25682 return NULL;
25683 }
25684
25685
25686 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25687 PyObject *obj;
25688 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25689 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
25690 return SWIG_Py_Void();
25691 }
25692
25693 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25694 return SWIG_Python_InitShadowInstance(args);
25695 }
25696
25697 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25698 PyObject *resultobj = 0;
25699 wxSysColourChangedEvent *result = 0 ;
25700
25701 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
25702 {
25703 PyThreadState* __tstate = wxPyBeginAllowThreads();
25704 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
25705 wxPyEndAllowThreads(__tstate);
25706 if (PyErr_Occurred()) SWIG_fail;
25707 }
25708 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
25709 return resultobj;
25710 fail:
25711 return NULL;
25712 }
25713
25714
25715 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25716 PyObject *obj;
25717 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25718 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
25719 return SWIG_Py_Void();
25720 }
25721
25722 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25723 return SWIG_Python_InitShadowInstance(args);
25724 }
25725
25726 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25727 PyObject *resultobj = 0;
25728 int arg1 = (int) 0 ;
25729 wxWindow *arg2 = (wxWindow *) NULL ;
25730 wxMouseCaptureChangedEvent *result = 0 ;
25731 int val1 ;
25732 int ecode1 = 0 ;
25733 void *argp2 = 0 ;
25734 int res2 = 0 ;
25735 PyObject * obj0 = 0 ;
25736 PyObject * obj1 = 0 ;
25737 char * kwnames[] = {
25738 (char *) "winid",(char *) "gainedCapture", NULL
25739 };
25740
25741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25742 if (obj0) {
25743 ecode1 = SWIG_AsVal_int(obj0, &val1);
25744 if (!SWIG_IsOK(ecode1)) {
25745 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
25746 }
25747 arg1 = static_cast< int >(val1);
25748 }
25749 if (obj1) {
25750 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25751 if (!SWIG_IsOK(res2)) {
25752 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
25753 }
25754 arg2 = reinterpret_cast< wxWindow * >(argp2);
25755 }
25756 {
25757 PyThreadState* __tstate = wxPyBeginAllowThreads();
25758 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
25759 wxPyEndAllowThreads(__tstate);
25760 if (PyErr_Occurred()) SWIG_fail;
25761 }
25762 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
25763 return resultobj;
25764 fail:
25765 return NULL;
25766 }
25767
25768
25769 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25770 PyObject *resultobj = 0;
25771 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
25772 wxWindow *result = 0 ;
25773 void *argp1 = 0 ;
25774 int res1 = 0 ;
25775 PyObject *swig_obj[1] ;
25776
25777 if (!args) SWIG_fail;
25778 swig_obj[0] = args;
25779 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
25780 if (!SWIG_IsOK(res1)) {
25781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
25782 }
25783 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
25784 {
25785 PyThreadState* __tstate = wxPyBeginAllowThreads();
25786 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
25787 wxPyEndAllowThreads(__tstate);
25788 if (PyErr_Occurred()) SWIG_fail;
25789 }
25790 {
25791 resultobj = wxPyMake_wxObject(result, (bool)0);
25792 }
25793 return resultobj;
25794 fail:
25795 return NULL;
25796 }
25797
25798
25799 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25800 PyObject *obj;
25801 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25802 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
25803 return SWIG_Py_Void();
25804 }
25805
25806 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25807 return SWIG_Python_InitShadowInstance(args);
25808 }
25809
25810 SWIGINTERN PyObject *_wrap_new_MouseCaptureLostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25811 PyObject *resultobj = 0;
25812 int arg1 = (int) 0 ;
25813 wxMouseCaptureLostEvent *result = 0 ;
25814 int val1 ;
25815 int ecode1 = 0 ;
25816 PyObject * obj0 = 0 ;
25817 char * kwnames[] = {
25818 (char *) "winid", NULL
25819 };
25820
25821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseCaptureLostEvent",kwnames,&obj0)) SWIG_fail;
25822 if (obj0) {
25823 ecode1 = SWIG_AsVal_int(obj0, &val1);
25824 if (!SWIG_IsOK(ecode1)) {
25825 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureLostEvent" "', expected argument " "1"" of type '" "int""'");
25826 }
25827 arg1 = static_cast< int >(val1);
25828 }
25829 {
25830 PyThreadState* __tstate = wxPyBeginAllowThreads();
25831 result = (wxMouseCaptureLostEvent *)new wxMouseCaptureLostEvent(arg1);
25832 wxPyEndAllowThreads(__tstate);
25833 if (PyErr_Occurred()) SWIG_fail;
25834 }
25835 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_POINTER_NEW | 0 );
25836 return resultobj;
25837 fail:
25838 return NULL;
25839 }
25840
25841
25842 SWIGINTERN PyObject *MouseCaptureLostEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25843 PyObject *obj;
25844 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25845 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_NewClientData(obj));
25846 return SWIG_Py_Void();
25847 }
25848
25849 SWIGINTERN PyObject *MouseCaptureLostEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25850 return SWIG_Python_InitShadowInstance(args);
25851 }
25852
25853 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25854 PyObject *resultobj = 0;
25855 wxDisplayChangedEvent *result = 0 ;
25856
25857 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
25858 {
25859 PyThreadState* __tstate = wxPyBeginAllowThreads();
25860 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
25861 wxPyEndAllowThreads(__tstate);
25862 if (PyErr_Occurred()) SWIG_fail;
25863 }
25864 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
25865 return resultobj;
25866 fail:
25867 return NULL;
25868 }
25869
25870
25871 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25872 PyObject *obj;
25873 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25874 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
25875 return SWIG_Py_Void();
25876 }
25877
25878 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25879 return SWIG_Python_InitShadowInstance(args);
25880 }
25881
25882 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25883 PyObject *resultobj = 0;
25884 int arg1 = (int) 0 ;
25885 wxPaletteChangedEvent *result = 0 ;
25886 int val1 ;
25887 int ecode1 = 0 ;
25888 PyObject * obj0 = 0 ;
25889 char * kwnames[] = {
25890 (char *) "id", NULL
25891 };
25892
25893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
25894 if (obj0) {
25895 ecode1 = SWIG_AsVal_int(obj0, &val1);
25896 if (!SWIG_IsOK(ecode1)) {
25897 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
25898 }
25899 arg1 = static_cast< int >(val1);
25900 }
25901 {
25902 PyThreadState* __tstate = wxPyBeginAllowThreads();
25903 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
25904 wxPyEndAllowThreads(__tstate);
25905 if (PyErr_Occurred()) SWIG_fail;
25906 }
25907 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
25908 return resultobj;
25909 fail:
25910 return NULL;
25911 }
25912
25913
25914 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25915 PyObject *resultobj = 0;
25916 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25917 wxWindow *arg2 = (wxWindow *) 0 ;
25918 void *argp1 = 0 ;
25919 int res1 = 0 ;
25920 void *argp2 = 0 ;
25921 int res2 = 0 ;
25922 PyObject * obj0 = 0 ;
25923 PyObject * obj1 = 0 ;
25924 char * kwnames[] = {
25925 (char *) "self",(char *) "win", NULL
25926 };
25927
25928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
25929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25930 if (!SWIG_IsOK(res1)) {
25931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25932 }
25933 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25934 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25935 if (!SWIG_IsOK(res2)) {
25936 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
25937 }
25938 arg2 = reinterpret_cast< wxWindow * >(argp2);
25939 {
25940 PyThreadState* __tstate = wxPyBeginAllowThreads();
25941 (arg1)->SetChangedWindow(arg2);
25942 wxPyEndAllowThreads(__tstate);
25943 if (PyErr_Occurred()) SWIG_fail;
25944 }
25945 resultobj = SWIG_Py_Void();
25946 return resultobj;
25947 fail:
25948 return NULL;
25949 }
25950
25951
25952 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25953 PyObject *resultobj = 0;
25954 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25955 wxWindow *result = 0 ;
25956 void *argp1 = 0 ;
25957 int res1 = 0 ;
25958 PyObject *swig_obj[1] ;
25959
25960 if (!args) SWIG_fail;
25961 swig_obj[0] = args;
25962 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25963 if (!SWIG_IsOK(res1)) {
25964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25965 }
25966 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25967 {
25968 PyThreadState* __tstate = wxPyBeginAllowThreads();
25969 result = (wxWindow *)(arg1)->GetChangedWindow();
25970 wxPyEndAllowThreads(__tstate);
25971 if (PyErr_Occurred()) SWIG_fail;
25972 }
25973 {
25974 resultobj = wxPyMake_wxObject(result, (bool)0);
25975 }
25976 return resultobj;
25977 fail:
25978 return NULL;
25979 }
25980
25981
25982 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25983 PyObject *obj;
25984 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25985 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
25986 return SWIG_Py_Void();
25987 }
25988
25989 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25990 return SWIG_Python_InitShadowInstance(args);
25991 }
25992
25993 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25994 PyObject *resultobj = 0;
25995 int arg1 = (int) 0 ;
25996 wxQueryNewPaletteEvent *result = 0 ;
25997 int val1 ;
25998 int ecode1 = 0 ;
25999 PyObject * obj0 = 0 ;
26000 char * kwnames[] = {
26001 (char *) "winid", NULL
26002 };
26003
26004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
26005 if (obj0) {
26006 ecode1 = SWIG_AsVal_int(obj0, &val1);
26007 if (!SWIG_IsOK(ecode1)) {
26008 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
26009 }
26010 arg1 = static_cast< int >(val1);
26011 }
26012 {
26013 PyThreadState* __tstate = wxPyBeginAllowThreads();
26014 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
26015 wxPyEndAllowThreads(__tstate);
26016 if (PyErr_Occurred()) SWIG_fail;
26017 }
26018 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
26019 return resultobj;
26020 fail:
26021 return NULL;
26022 }
26023
26024
26025 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26026 PyObject *resultobj = 0;
26027 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
26028 bool arg2 ;
26029 void *argp1 = 0 ;
26030 int res1 = 0 ;
26031 bool val2 ;
26032 int ecode2 = 0 ;
26033 PyObject * obj0 = 0 ;
26034 PyObject * obj1 = 0 ;
26035 char * kwnames[] = {
26036 (char *) "self",(char *) "realized", NULL
26037 };
26038
26039 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
26040 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
26041 if (!SWIG_IsOK(res1)) {
26042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
26043 }
26044 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
26045 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26046 if (!SWIG_IsOK(ecode2)) {
26047 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
26048 }
26049 arg2 = static_cast< bool >(val2);
26050 {
26051 PyThreadState* __tstate = wxPyBeginAllowThreads();
26052 (arg1)->SetPaletteRealized(arg2);
26053 wxPyEndAllowThreads(__tstate);
26054 if (PyErr_Occurred()) SWIG_fail;
26055 }
26056 resultobj = SWIG_Py_Void();
26057 return resultobj;
26058 fail:
26059 return NULL;
26060 }
26061
26062
26063 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26064 PyObject *resultobj = 0;
26065 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
26066 bool result;
26067 void *argp1 = 0 ;
26068 int res1 = 0 ;
26069 PyObject *swig_obj[1] ;
26070
26071 if (!args) SWIG_fail;
26072 swig_obj[0] = args;
26073 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
26074 if (!SWIG_IsOK(res1)) {
26075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
26076 }
26077 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
26078 {
26079 PyThreadState* __tstate = wxPyBeginAllowThreads();
26080 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
26081 wxPyEndAllowThreads(__tstate);
26082 if (PyErr_Occurred()) SWIG_fail;
26083 }
26084 {
26085 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26086 }
26087 return resultobj;
26088 fail:
26089 return NULL;
26090 }
26091
26092
26093 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26094 PyObject *obj;
26095 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26096 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
26097 return SWIG_Py_Void();
26098 }
26099
26100 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26101 return SWIG_Python_InitShadowInstance(args);
26102 }
26103
26104 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26105 PyObject *resultobj = 0;
26106 wxNavigationKeyEvent *result = 0 ;
26107
26108 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
26109 {
26110 PyThreadState* __tstate = wxPyBeginAllowThreads();
26111 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
26112 wxPyEndAllowThreads(__tstate);
26113 if (PyErr_Occurred()) SWIG_fail;
26114 }
26115 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
26116 return resultobj;
26117 fail:
26118 return NULL;
26119 }
26120
26121
26122 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26123 PyObject *resultobj = 0;
26124 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26125 bool result;
26126 void *argp1 = 0 ;
26127 int res1 = 0 ;
26128 PyObject *swig_obj[1] ;
26129
26130 if (!args) SWIG_fail;
26131 swig_obj[0] = args;
26132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26133 if (!SWIG_IsOK(res1)) {
26134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26135 }
26136 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26137 {
26138 PyThreadState* __tstate = wxPyBeginAllowThreads();
26139 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
26140 wxPyEndAllowThreads(__tstate);
26141 if (PyErr_Occurred()) SWIG_fail;
26142 }
26143 {
26144 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26145 }
26146 return resultobj;
26147 fail:
26148 return NULL;
26149 }
26150
26151
26152 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26153 PyObject *resultobj = 0;
26154 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26155 bool arg2 ;
26156 void *argp1 = 0 ;
26157 int res1 = 0 ;
26158 bool val2 ;
26159 int ecode2 = 0 ;
26160 PyObject * obj0 = 0 ;
26161 PyObject * obj1 = 0 ;
26162 char * kwnames[] = {
26163 (char *) "self",(char *) "forward", NULL
26164 };
26165
26166 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
26167 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26168 if (!SWIG_IsOK(res1)) {
26169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26170 }
26171 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26172 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26173 if (!SWIG_IsOK(ecode2)) {
26174 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
26175 }
26176 arg2 = static_cast< bool >(val2);
26177 {
26178 PyThreadState* __tstate = wxPyBeginAllowThreads();
26179 (arg1)->SetDirection(arg2);
26180 wxPyEndAllowThreads(__tstate);
26181 if (PyErr_Occurred()) SWIG_fail;
26182 }
26183 resultobj = SWIG_Py_Void();
26184 return resultobj;
26185 fail:
26186 return NULL;
26187 }
26188
26189
26190 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26191 PyObject *resultobj = 0;
26192 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26193 bool result;
26194 void *argp1 = 0 ;
26195 int res1 = 0 ;
26196 PyObject *swig_obj[1] ;
26197
26198 if (!args) SWIG_fail;
26199 swig_obj[0] = args;
26200 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26201 if (!SWIG_IsOK(res1)) {
26202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26203 }
26204 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26205 {
26206 PyThreadState* __tstate = wxPyBeginAllowThreads();
26207 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
26208 wxPyEndAllowThreads(__tstate);
26209 if (PyErr_Occurred()) SWIG_fail;
26210 }
26211 {
26212 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26213 }
26214 return resultobj;
26215 fail:
26216 return NULL;
26217 }
26218
26219
26220 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26221 PyObject *resultobj = 0;
26222 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26223 bool arg2 ;
26224 void *argp1 = 0 ;
26225 int res1 = 0 ;
26226 bool val2 ;
26227 int ecode2 = 0 ;
26228 PyObject * obj0 = 0 ;
26229 PyObject * obj1 = 0 ;
26230 char * kwnames[] = {
26231 (char *) "self",(char *) "ischange", NULL
26232 };
26233
26234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
26235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26236 if (!SWIG_IsOK(res1)) {
26237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26238 }
26239 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26240 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26241 if (!SWIG_IsOK(ecode2)) {
26242 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
26243 }
26244 arg2 = static_cast< bool >(val2);
26245 {
26246 PyThreadState* __tstate = wxPyBeginAllowThreads();
26247 (arg1)->SetWindowChange(arg2);
26248 wxPyEndAllowThreads(__tstate);
26249 if (PyErr_Occurred()) SWIG_fail;
26250 }
26251 resultobj = SWIG_Py_Void();
26252 return resultobj;
26253 fail:
26254 return NULL;
26255 }
26256
26257
26258 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26259 PyObject *resultobj = 0;
26260 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26261 bool result;
26262 void *argp1 = 0 ;
26263 int res1 = 0 ;
26264 PyObject *swig_obj[1] ;
26265
26266 if (!args) SWIG_fail;
26267 swig_obj[0] = args;
26268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26269 if (!SWIG_IsOK(res1)) {
26270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26271 }
26272 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26273 {
26274 PyThreadState* __tstate = wxPyBeginAllowThreads();
26275 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
26276 wxPyEndAllowThreads(__tstate);
26277 if (PyErr_Occurred()) SWIG_fail;
26278 }
26279 {
26280 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26281 }
26282 return resultobj;
26283 fail:
26284 return NULL;
26285 }
26286
26287
26288 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26289 PyObject *resultobj = 0;
26290 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26291 bool arg2 ;
26292 void *argp1 = 0 ;
26293 int res1 = 0 ;
26294 bool val2 ;
26295 int ecode2 = 0 ;
26296 PyObject * obj0 = 0 ;
26297 PyObject * obj1 = 0 ;
26298 char * kwnames[] = {
26299 (char *) "self",(char *) "bIs", NULL
26300 };
26301
26302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
26303 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26304 if (!SWIG_IsOK(res1)) {
26305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26306 }
26307 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26308 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26309 if (!SWIG_IsOK(ecode2)) {
26310 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
26311 }
26312 arg2 = static_cast< bool >(val2);
26313 {
26314 PyThreadState* __tstate = wxPyBeginAllowThreads();
26315 (arg1)->SetFromTab(arg2);
26316 wxPyEndAllowThreads(__tstate);
26317 if (PyErr_Occurred()) SWIG_fail;
26318 }
26319 resultobj = SWIG_Py_Void();
26320 return resultobj;
26321 fail:
26322 return NULL;
26323 }
26324
26325
26326 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26327 PyObject *resultobj = 0;
26328 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26329 long arg2 ;
26330 void *argp1 = 0 ;
26331 int res1 = 0 ;
26332 long val2 ;
26333 int ecode2 = 0 ;
26334 PyObject * obj0 = 0 ;
26335 PyObject * obj1 = 0 ;
26336 char * kwnames[] = {
26337 (char *) "self",(char *) "flags", NULL
26338 };
26339
26340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
26341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26342 if (!SWIG_IsOK(res1)) {
26343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26344 }
26345 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26346 ecode2 = SWIG_AsVal_long(obj1, &val2);
26347 if (!SWIG_IsOK(ecode2)) {
26348 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
26349 }
26350 arg2 = static_cast< long >(val2);
26351 {
26352 PyThreadState* __tstate = wxPyBeginAllowThreads();
26353 (arg1)->SetFlags(arg2);
26354 wxPyEndAllowThreads(__tstate);
26355 if (PyErr_Occurred()) SWIG_fail;
26356 }
26357 resultobj = SWIG_Py_Void();
26358 return resultobj;
26359 fail:
26360 return NULL;
26361 }
26362
26363
26364 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26365 PyObject *resultobj = 0;
26366 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26367 wxWindow *result = 0 ;
26368 void *argp1 = 0 ;
26369 int res1 = 0 ;
26370 PyObject *swig_obj[1] ;
26371
26372 if (!args) SWIG_fail;
26373 swig_obj[0] = args;
26374 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26375 if (!SWIG_IsOK(res1)) {
26376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26377 }
26378 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26379 {
26380 PyThreadState* __tstate = wxPyBeginAllowThreads();
26381 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
26382 wxPyEndAllowThreads(__tstate);
26383 if (PyErr_Occurred()) SWIG_fail;
26384 }
26385 {
26386 resultobj = wxPyMake_wxObject(result, (bool)0);
26387 }
26388 return resultobj;
26389 fail:
26390 return NULL;
26391 }
26392
26393
26394 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26395 PyObject *resultobj = 0;
26396 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26397 wxWindow *arg2 = (wxWindow *) 0 ;
26398 void *argp1 = 0 ;
26399 int res1 = 0 ;
26400 void *argp2 = 0 ;
26401 int res2 = 0 ;
26402 PyObject * obj0 = 0 ;
26403 PyObject * obj1 = 0 ;
26404 char * kwnames[] = {
26405 (char *) "self",(char *) "win", NULL
26406 };
26407
26408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
26409 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26410 if (!SWIG_IsOK(res1)) {
26411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26412 }
26413 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26414 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26415 if (!SWIG_IsOK(res2)) {
26416 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
26417 }
26418 arg2 = reinterpret_cast< wxWindow * >(argp2);
26419 {
26420 PyThreadState* __tstate = wxPyBeginAllowThreads();
26421 (arg1)->SetCurrentFocus(arg2);
26422 wxPyEndAllowThreads(__tstate);
26423 if (PyErr_Occurred()) SWIG_fail;
26424 }
26425 resultobj = SWIG_Py_Void();
26426 return resultobj;
26427 fail:
26428 return NULL;
26429 }
26430
26431
26432 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26433 PyObject *obj;
26434 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26435 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
26436 return SWIG_Py_Void();
26437 }
26438
26439 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26440 return SWIG_Python_InitShadowInstance(args);
26441 }
26442
26443 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26444 PyObject *resultobj = 0;
26445 wxWindow *arg1 = (wxWindow *) NULL ;
26446 wxWindowCreateEvent *result = 0 ;
26447 void *argp1 = 0 ;
26448 int res1 = 0 ;
26449 PyObject * obj0 = 0 ;
26450 char * kwnames[] = {
26451 (char *) "win", NULL
26452 };
26453
26454 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
26455 if (obj0) {
26456 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26457 if (!SWIG_IsOK(res1)) {
26458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26459 }
26460 arg1 = reinterpret_cast< wxWindow * >(argp1);
26461 }
26462 {
26463 PyThreadState* __tstate = wxPyBeginAllowThreads();
26464 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
26465 wxPyEndAllowThreads(__tstate);
26466 if (PyErr_Occurred()) SWIG_fail;
26467 }
26468 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
26469 return resultobj;
26470 fail:
26471 return NULL;
26472 }
26473
26474
26475 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26476 PyObject *resultobj = 0;
26477 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
26478 wxWindow *result = 0 ;
26479 void *argp1 = 0 ;
26480 int res1 = 0 ;
26481 PyObject *swig_obj[1] ;
26482
26483 if (!args) SWIG_fail;
26484 swig_obj[0] = args;
26485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
26486 if (!SWIG_IsOK(res1)) {
26487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
26488 }
26489 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
26490 {
26491 PyThreadState* __tstate = wxPyBeginAllowThreads();
26492 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
26493 wxPyEndAllowThreads(__tstate);
26494 if (PyErr_Occurred()) SWIG_fail;
26495 }
26496 {
26497 resultobj = wxPyMake_wxObject(result, (bool)0);
26498 }
26499 return resultobj;
26500 fail:
26501 return NULL;
26502 }
26503
26504
26505 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26506 PyObject *obj;
26507 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26508 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
26509 return SWIG_Py_Void();
26510 }
26511
26512 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26513 return SWIG_Python_InitShadowInstance(args);
26514 }
26515
26516 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26517 PyObject *resultobj = 0;
26518 wxWindow *arg1 = (wxWindow *) NULL ;
26519 wxWindowDestroyEvent *result = 0 ;
26520 void *argp1 = 0 ;
26521 int res1 = 0 ;
26522 PyObject * obj0 = 0 ;
26523 char * kwnames[] = {
26524 (char *) "win", NULL
26525 };
26526
26527 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
26528 if (obj0) {
26529 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26530 if (!SWIG_IsOK(res1)) {
26531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26532 }
26533 arg1 = reinterpret_cast< wxWindow * >(argp1);
26534 }
26535 {
26536 PyThreadState* __tstate = wxPyBeginAllowThreads();
26537 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
26538 wxPyEndAllowThreads(__tstate);
26539 if (PyErr_Occurred()) SWIG_fail;
26540 }
26541 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
26542 return resultobj;
26543 fail:
26544 return NULL;
26545 }
26546
26547
26548 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26549 PyObject *resultobj = 0;
26550 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
26551 wxWindow *result = 0 ;
26552 void *argp1 = 0 ;
26553 int res1 = 0 ;
26554 PyObject *swig_obj[1] ;
26555
26556 if (!args) SWIG_fail;
26557 swig_obj[0] = args;
26558 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
26559 if (!SWIG_IsOK(res1)) {
26560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
26561 }
26562 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
26563 {
26564 PyThreadState* __tstate = wxPyBeginAllowThreads();
26565 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
26566 wxPyEndAllowThreads(__tstate);
26567 if (PyErr_Occurred()) SWIG_fail;
26568 }
26569 {
26570 resultobj = wxPyMake_wxObject(result, (bool)0);
26571 }
26572 return resultobj;
26573 fail:
26574 return NULL;
26575 }
26576
26577
26578 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26579 PyObject *obj;
26580 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26581 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
26582 return SWIG_Py_Void();
26583 }
26584
26585 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26586 return SWIG_Python_InitShadowInstance(args);
26587 }
26588
26589 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26590 PyObject *resultobj = 0;
26591 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26592 int arg2 = (int) 0 ;
26593 wxPoint const &arg3_defvalue = wxDefaultPosition ;
26594 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
26595 wxContextMenuEvent *result = 0 ;
26596 int val1 ;
26597 int ecode1 = 0 ;
26598 int val2 ;
26599 int ecode2 = 0 ;
26600 wxPoint temp3 ;
26601 PyObject * obj0 = 0 ;
26602 PyObject * obj1 = 0 ;
26603 PyObject * obj2 = 0 ;
26604 char * kwnames[] = {
26605 (char *) "type",(char *) "winid",(char *) "pt", NULL
26606 };
26607
26608 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26609 if (obj0) {
26610 ecode1 = SWIG_AsVal_int(obj0, &val1);
26611 if (!SWIG_IsOK(ecode1)) {
26612 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26613 }
26614 arg1 = static_cast< wxEventType >(val1);
26615 }
26616 if (obj1) {
26617 ecode2 = SWIG_AsVal_int(obj1, &val2);
26618 if (!SWIG_IsOK(ecode2)) {
26619 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
26620 }
26621 arg2 = static_cast< int >(val2);
26622 }
26623 if (obj2) {
26624 {
26625 arg3 = &temp3;
26626 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
26627 }
26628 }
26629 {
26630 PyThreadState* __tstate = wxPyBeginAllowThreads();
26631 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
26632 wxPyEndAllowThreads(__tstate);
26633 if (PyErr_Occurred()) SWIG_fail;
26634 }
26635 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
26636 return resultobj;
26637 fail:
26638 return NULL;
26639 }
26640
26641
26642 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26643 PyObject *resultobj = 0;
26644 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26645 wxPoint *result = 0 ;
26646 void *argp1 = 0 ;
26647 int res1 = 0 ;
26648 PyObject *swig_obj[1] ;
26649
26650 if (!args) SWIG_fail;
26651 swig_obj[0] = args;
26652 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26653 if (!SWIG_IsOK(res1)) {
26654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
26655 }
26656 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26657 {
26658 PyThreadState* __tstate = wxPyBeginAllowThreads();
26659 {
26660 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
26661 result = (wxPoint *) &_result_ref;
26662 }
26663 wxPyEndAllowThreads(__tstate);
26664 if (PyErr_Occurred()) SWIG_fail;
26665 }
26666 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
26667 return resultobj;
26668 fail:
26669 return NULL;
26670 }
26671
26672
26673 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26674 PyObject *resultobj = 0;
26675 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26676 wxPoint *arg2 = 0 ;
26677 void *argp1 = 0 ;
26678 int res1 = 0 ;
26679 wxPoint temp2 ;
26680 PyObject * obj0 = 0 ;
26681 PyObject * obj1 = 0 ;
26682 char * kwnames[] = {
26683 (char *) "self",(char *) "pos", NULL
26684 };
26685
26686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26687 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26688 if (!SWIG_IsOK(res1)) {
26689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
26690 }
26691 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26692 {
26693 arg2 = &temp2;
26694 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26695 }
26696 {
26697 PyThreadState* __tstate = wxPyBeginAllowThreads();
26698 (arg1)->SetPosition((wxPoint const &)*arg2);
26699 wxPyEndAllowThreads(__tstate);
26700 if (PyErr_Occurred()) SWIG_fail;
26701 }
26702 resultobj = SWIG_Py_Void();
26703 return resultobj;
26704 fail:
26705 return NULL;
26706 }
26707
26708
26709 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26710 PyObject *obj;
26711 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26712 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
26713 return SWIG_Py_Void();
26714 }
26715
26716 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26717 return SWIG_Python_InitShadowInstance(args);
26718 }
26719
26720 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26721 PyObject *resultobj = 0;
26722 wxIdleEvent *result = 0 ;
26723
26724 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
26725 {
26726 PyThreadState* __tstate = wxPyBeginAllowThreads();
26727 result = (wxIdleEvent *)new wxIdleEvent();
26728 wxPyEndAllowThreads(__tstate);
26729 if (PyErr_Occurred()) SWIG_fail;
26730 }
26731 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
26732 return resultobj;
26733 fail:
26734 return NULL;
26735 }
26736
26737
26738 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26739 PyObject *resultobj = 0;
26740 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26741 bool arg2 = (bool) true ;
26742 void *argp1 = 0 ;
26743 int res1 = 0 ;
26744 bool val2 ;
26745 int ecode2 = 0 ;
26746 PyObject * obj0 = 0 ;
26747 PyObject * obj1 = 0 ;
26748 char * kwnames[] = {
26749 (char *) "self",(char *) "needMore", NULL
26750 };
26751
26752 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
26753 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26754 if (!SWIG_IsOK(res1)) {
26755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
26756 }
26757 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26758 if (obj1) {
26759 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26760 if (!SWIG_IsOK(ecode2)) {
26761 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
26762 }
26763 arg2 = static_cast< bool >(val2);
26764 }
26765 {
26766 PyThreadState* __tstate = wxPyBeginAllowThreads();
26767 (arg1)->RequestMore(arg2);
26768 wxPyEndAllowThreads(__tstate);
26769 if (PyErr_Occurred()) SWIG_fail;
26770 }
26771 resultobj = SWIG_Py_Void();
26772 return resultobj;
26773 fail:
26774 return NULL;
26775 }
26776
26777
26778 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26779 PyObject *resultobj = 0;
26780 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26781 bool result;
26782 void *argp1 = 0 ;
26783 int res1 = 0 ;
26784 PyObject *swig_obj[1] ;
26785
26786 if (!args) SWIG_fail;
26787 swig_obj[0] = args;
26788 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26789 if (!SWIG_IsOK(res1)) {
26790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
26791 }
26792 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26793 {
26794 PyThreadState* __tstate = wxPyBeginAllowThreads();
26795 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
26796 wxPyEndAllowThreads(__tstate);
26797 if (PyErr_Occurred()) SWIG_fail;
26798 }
26799 {
26800 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26801 }
26802 return resultobj;
26803 fail:
26804 return NULL;
26805 }
26806
26807
26808 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26809 PyObject *resultobj = 0;
26810 wxIdleMode arg1 ;
26811 int val1 ;
26812 int ecode1 = 0 ;
26813 PyObject * obj0 = 0 ;
26814 char * kwnames[] = {
26815 (char *) "mode", NULL
26816 };
26817
26818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
26819 ecode1 = SWIG_AsVal_int(obj0, &val1);
26820 if (!SWIG_IsOK(ecode1)) {
26821 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
26822 }
26823 arg1 = static_cast< wxIdleMode >(val1);
26824 {
26825 PyThreadState* __tstate = wxPyBeginAllowThreads();
26826 wxIdleEvent::SetMode(arg1);
26827 wxPyEndAllowThreads(__tstate);
26828 if (PyErr_Occurred()) SWIG_fail;
26829 }
26830 resultobj = SWIG_Py_Void();
26831 return resultobj;
26832 fail:
26833 return NULL;
26834 }
26835
26836
26837 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26838 PyObject *resultobj = 0;
26839 wxIdleMode result;
26840
26841 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
26842 {
26843 PyThreadState* __tstate = wxPyBeginAllowThreads();
26844 result = (wxIdleMode)wxIdleEvent::GetMode();
26845 wxPyEndAllowThreads(__tstate);
26846 if (PyErr_Occurred()) SWIG_fail;
26847 }
26848 resultobj = SWIG_From_int(static_cast< int >(result));
26849 return resultobj;
26850 fail:
26851 return NULL;
26852 }
26853
26854
26855 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26856 PyObject *resultobj = 0;
26857 wxWindow *arg1 = (wxWindow *) 0 ;
26858 bool result;
26859 void *argp1 = 0 ;
26860 int res1 = 0 ;
26861 PyObject * obj0 = 0 ;
26862 char * kwnames[] = {
26863 (char *) "win", NULL
26864 };
26865
26866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
26867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26868 if (!SWIG_IsOK(res1)) {
26869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
26870 }
26871 arg1 = reinterpret_cast< wxWindow * >(argp1);
26872 {
26873 PyThreadState* __tstate = wxPyBeginAllowThreads();
26874 result = (bool)wxIdleEvent::CanSend(arg1);
26875 wxPyEndAllowThreads(__tstate);
26876 if (PyErr_Occurred()) SWIG_fail;
26877 }
26878 {
26879 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26880 }
26881 return resultobj;
26882 fail:
26883 return NULL;
26884 }
26885
26886
26887 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26888 PyObject *obj;
26889 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26890 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
26891 return SWIG_Py_Void();
26892 }
26893
26894 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26895 return SWIG_Python_InitShadowInstance(args);
26896 }
26897
26898 SWIGINTERN PyObject *_wrap_new_ClipboardTextEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26899 PyObject *resultobj = 0;
26900 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26901 int arg2 = (int) 0 ;
26902 wxClipboardTextEvent *result = 0 ;
26903 int val1 ;
26904 int ecode1 = 0 ;
26905 int val2 ;
26906 int ecode2 = 0 ;
26907 PyObject * obj0 = 0 ;
26908 PyObject * obj1 = 0 ;
26909 char * kwnames[] = {
26910 (char *) "type",(char *) "winid", NULL
26911 };
26912
26913 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ClipboardTextEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26914 if (obj0) {
26915 ecode1 = SWIG_AsVal_int(obj0, &val1);
26916 if (!SWIG_IsOK(ecode1)) {
26917 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ClipboardTextEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26918 }
26919 arg1 = static_cast< wxEventType >(val1);
26920 }
26921 if (obj1) {
26922 ecode2 = SWIG_AsVal_int(obj1, &val2);
26923 if (!SWIG_IsOK(ecode2)) {
26924 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ClipboardTextEvent" "', expected argument " "2"" of type '" "int""'");
26925 }
26926 arg2 = static_cast< int >(val2);
26927 }
26928 {
26929 PyThreadState* __tstate = wxPyBeginAllowThreads();
26930 result = (wxClipboardTextEvent *)new wxClipboardTextEvent(arg1,arg2);
26931 wxPyEndAllowThreads(__tstate);
26932 if (PyErr_Occurred()) SWIG_fail;
26933 }
26934 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardTextEvent, SWIG_POINTER_NEW | 0 );
26935 return resultobj;
26936 fail:
26937 return NULL;
26938 }
26939
26940
26941 SWIGINTERN PyObject *ClipboardTextEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26942 PyObject *obj;
26943 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26944 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardTextEvent, SWIG_NewClientData(obj));
26945 return SWIG_Py_Void();
26946 }
26947
26948 SWIGINTERN PyObject *ClipboardTextEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26949 return SWIG_Python_InitShadowInstance(args);
26950 }
26951
26952 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26953 PyObject *resultobj = 0;
26954 int arg1 = (int) 0 ;
26955 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
26956 wxPyEvent *result = 0 ;
26957 int val1 ;
26958 int ecode1 = 0 ;
26959 int val2 ;
26960 int ecode2 = 0 ;
26961 PyObject * obj0 = 0 ;
26962 PyObject * obj1 = 0 ;
26963 char * kwnames[] = {
26964 (char *) "winid",(char *) "eventType", NULL
26965 };
26966
26967 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26968 if (obj0) {
26969 ecode1 = SWIG_AsVal_int(obj0, &val1);
26970 if (!SWIG_IsOK(ecode1)) {
26971 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
26972 }
26973 arg1 = static_cast< int >(val1);
26974 }
26975 if (obj1) {
26976 ecode2 = SWIG_AsVal_int(obj1, &val2);
26977 if (!SWIG_IsOK(ecode2)) {
26978 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
26979 }
26980 arg2 = static_cast< wxEventType >(val2);
26981 }
26982 {
26983 PyThreadState* __tstate = wxPyBeginAllowThreads();
26984 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
26985 wxPyEndAllowThreads(__tstate);
26986 if (PyErr_Occurred()) SWIG_fail;
26987 }
26988 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
26989 return resultobj;
26990 fail:
26991 return NULL;
26992 }
26993
26994
26995 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26996 PyObject *resultobj = 0;
26997 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26998 void *argp1 = 0 ;
26999 int res1 = 0 ;
27000 PyObject *swig_obj[1] ;
27001
27002 if (!args) SWIG_fail;
27003 swig_obj[0] = args;
27004 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
27005 if (!SWIG_IsOK(res1)) {
27006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
27007 }
27008 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
27009 {
27010 PyThreadState* __tstate = wxPyBeginAllowThreads();
27011 delete arg1;
27012
27013 wxPyEndAllowThreads(__tstate);
27014 if (PyErr_Occurred()) SWIG_fail;
27015 }
27016 resultobj = SWIG_Py_Void();
27017 return resultobj;
27018 fail:
27019 return NULL;
27020 }
27021
27022
27023 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27024 PyObject *resultobj = 0;
27025 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
27026 PyObject *arg2 = (PyObject *) 0 ;
27027 void *argp1 = 0 ;
27028 int res1 = 0 ;
27029 PyObject * obj0 = 0 ;
27030 PyObject * obj1 = 0 ;
27031 char * kwnames[] = {
27032 (char *) "self",(char *) "self", NULL
27033 };
27034
27035 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
27036 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
27037 if (!SWIG_IsOK(res1)) {
27038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
27039 }
27040 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
27041 arg2 = obj1;
27042 {
27043 PyThreadState* __tstate = wxPyBeginAllowThreads();
27044 (arg1)->SetSelf(arg2);
27045 wxPyEndAllowThreads(__tstate);
27046 if (PyErr_Occurred()) SWIG_fail;
27047 }
27048 resultobj = SWIG_Py_Void();
27049 return resultobj;
27050 fail:
27051 return NULL;
27052 }
27053
27054
27055 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27056 PyObject *resultobj = 0;
27057 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
27058 PyObject *result = 0 ;
27059 void *argp1 = 0 ;
27060 int res1 = 0 ;
27061 PyObject *swig_obj[1] ;
27062
27063 if (!args) SWIG_fail;
27064 swig_obj[0] = args;
27065 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
27066 if (!SWIG_IsOK(res1)) {
27067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
27068 }
27069 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
27070 {
27071 PyThreadState* __tstate = wxPyBeginAllowThreads();
27072 result = (PyObject *)(arg1)->GetSelf();
27073 wxPyEndAllowThreads(__tstate);
27074 if (PyErr_Occurred()) SWIG_fail;
27075 }
27076 resultobj = result;
27077 return resultobj;
27078 fail:
27079 return NULL;
27080 }
27081
27082
27083 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27084 PyObject *obj;
27085 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27086 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
27087 return SWIG_Py_Void();
27088 }
27089
27090 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27091 return SWIG_Python_InitShadowInstance(args);
27092 }
27093
27094 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27095 PyObject *resultobj = 0;
27096 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
27097 int arg2 = (int) 0 ;
27098 wxPyCommandEvent *result = 0 ;
27099 int val1 ;
27100 int ecode1 = 0 ;
27101 int val2 ;
27102 int ecode2 = 0 ;
27103 PyObject * obj0 = 0 ;
27104 PyObject * obj1 = 0 ;
27105 char * kwnames[] = {
27106 (char *) "eventType",(char *) "id", NULL
27107 };
27108
27109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27110 if (obj0) {
27111 ecode1 = SWIG_AsVal_int(obj0, &val1);
27112 if (!SWIG_IsOK(ecode1)) {
27113 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
27114 }
27115 arg1 = static_cast< wxEventType >(val1);
27116 }
27117 if (obj1) {
27118 ecode2 = SWIG_AsVal_int(obj1, &val2);
27119 if (!SWIG_IsOK(ecode2)) {
27120 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
27121 }
27122 arg2 = static_cast< int >(val2);
27123 }
27124 {
27125 PyThreadState* __tstate = wxPyBeginAllowThreads();
27126 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
27127 wxPyEndAllowThreads(__tstate);
27128 if (PyErr_Occurred()) SWIG_fail;
27129 }
27130 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
27131 return resultobj;
27132 fail:
27133 return NULL;
27134 }
27135
27136
27137 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27138 PyObject *resultobj = 0;
27139 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
27140 void *argp1 = 0 ;
27141 int res1 = 0 ;
27142 PyObject *swig_obj[1] ;
27143
27144 if (!args) SWIG_fail;
27145 swig_obj[0] = args;
27146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
27147 if (!SWIG_IsOK(res1)) {
27148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
27149 }
27150 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
27151 {
27152 PyThreadState* __tstate = wxPyBeginAllowThreads();
27153 delete arg1;
27154
27155 wxPyEndAllowThreads(__tstate);
27156 if (PyErr_Occurred()) SWIG_fail;
27157 }
27158 resultobj = SWIG_Py_Void();
27159 return resultobj;
27160 fail:
27161 return NULL;
27162 }
27163
27164
27165 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27166 PyObject *resultobj = 0;
27167 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
27168 PyObject *arg2 = (PyObject *) 0 ;
27169 void *argp1 = 0 ;
27170 int res1 = 0 ;
27171 PyObject * obj0 = 0 ;
27172 PyObject * obj1 = 0 ;
27173 char * kwnames[] = {
27174 (char *) "self",(char *) "self", NULL
27175 };
27176
27177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
27178 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
27179 if (!SWIG_IsOK(res1)) {
27180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
27181 }
27182 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
27183 arg2 = obj1;
27184 {
27185 PyThreadState* __tstate = wxPyBeginAllowThreads();
27186 (arg1)->SetSelf(arg2);
27187 wxPyEndAllowThreads(__tstate);
27188 if (PyErr_Occurred()) SWIG_fail;
27189 }
27190 resultobj = SWIG_Py_Void();
27191 return resultobj;
27192 fail:
27193 return NULL;
27194 }
27195
27196
27197 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27198 PyObject *resultobj = 0;
27199 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
27200 PyObject *result = 0 ;
27201 void *argp1 = 0 ;
27202 int res1 = 0 ;
27203 PyObject *swig_obj[1] ;
27204
27205 if (!args) SWIG_fail;
27206 swig_obj[0] = args;
27207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
27208 if (!SWIG_IsOK(res1)) {
27209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
27210 }
27211 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
27212 {
27213 PyThreadState* __tstate = wxPyBeginAllowThreads();
27214 result = (PyObject *)(arg1)->GetSelf();
27215 wxPyEndAllowThreads(__tstate);
27216 if (PyErr_Occurred()) SWIG_fail;
27217 }
27218 resultobj = result;
27219 return resultobj;
27220 fail:
27221 return NULL;
27222 }
27223
27224
27225 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27226 PyObject *obj;
27227 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27228 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
27229 return SWIG_Py_Void();
27230 }
27231
27232 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27233 return SWIG_Python_InitShadowInstance(args);
27234 }
27235
27236 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27237 PyObject *resultobj = 0;
27238 wxWindow *arg1 = (wxWindow *) 0 ;
27239 wxDateTime *arg2 = 0 ;
27240 wxEventType arg3 ;
27241 wxDateEvent *result = 0 ;
27242 void *argp1 = 0 ;
27243 int res1 = 0 ;
27244 void *argp2 = 0 ;
27245 int res2 = 0 ;
27246 int val3 ;
27247 int ecode3 = 0 ;
27248 PyObject * obj0 = 0 ;
27249 PyObject * obj1 = 0 ;
27250 PyObject * obj2 = 0 ;
27251 char * kwnames[] = {
27252 (char *) "win",(char *) "dt",(char *) "type", NULL
27253 };
27254
27255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27256 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
27257 if (!SWIG_IsOK(res1)) {
27258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
27259 }
27260 arg1 = reinterpret_cast< wxWindow * >(argp1);
27261 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27262 if (!SWIG_IsOK(res2)) {
27263 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27264 }
27265 if (!argp2) {
27266 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27267 }
27268 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27269 ecode3 = SWIG_AsVal_int(obj2, &val3);
27270 if (!SWIG_IsOK(ecode3)) {
27271 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
27272 }
27273 arg3 = static_cast< wxEventType >(val3);
27274 {
27275 PyThreadState* __tstate = wxPyBeginAllowThreads();
27276 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
27277 wxPyEndAllowThreads(__tstate);
27278 if (PyErr_Occurred()) SWIG_fail;
27279 }
27280 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
27281 return resultobj;
27282 fail:
27283 return NULL;
27284 }
27285
27286
27287 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27288 PyObject *resultobj = 0;
27289 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
27290 wxDateTime *result = 0 ;
27291 void *argp1 = 0 ;
27292 int res1 = 0 ;
27293 PyObject *swig_obj[1] ;
27294
27295 if (!args) SWIG_fail;
27296 swig_obj[0] = args;
27297 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
27298 if (!SWIG_IsOK(res1)) {
27299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
27300 }
27301 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
27302 {
27303 PyThreadState* __tstate = wxPyBeginAllowThreads();
27304 {
27305 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
27306 result = (wxDateTime *) &_result_ref;
27307 }
27308 wxPyEndAllowThreads(__tstate);
27309 if (PyErr_Occurred()) SWIG_fail;
27310 }
27311 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27312 return resultobj;
27313 fail:
27314 return NULL;
27315 }
27316
27317
27318 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27319 PyObject *resultobj = 0;
27320 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
27321 wxDateTime *arg2 = 0 ;
27322 void *argp1 = 0 ;
27323 int res1 = 0 ;
27324 void *argp2 = 0 ;
27325 int res2 = 0 ;
27326 PyObject * obj0 = 0 ;
27327 PyObject * obj1 = 0 ;
27328 char * kwnames[] = {
27329 (char *) "self",(char *) "date", NULL
27330 };
27331
27332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
27333 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
27334 if (!SWIG_IsOK(res1)) {
27335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
27336 }
27337 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
27338 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27339 if (!SWIG_IsOK(res2)) {
27340 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27341 }
27342 if (!argp2) {
27343 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27344 }
27345 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27346 {
27347 PyThreadState* __tstate = wxPyBeginAllowThreads();
27348 (arg1)->SetDate((wxDateTime const &)*arg2);
27349 wxPyEndAllowThreads(__tstate);
27350 if (PyErr_Occurred()) SWIG_fail;
27351 }
27352 resultobj = SWIG_Py_Void();
27353 return resultobj;
27354 fail:
27355 return NULL;
27356 }
27357
27358
27359 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27360 PyObject *obj;
27361 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27362 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
27363 return SWIG_Py_Void();
27364 }
27365
27366 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27367 return SWIG_Python_InitShadowInstance(args);
27368 }
27369
27370 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27371 PyObject *resultobj = 0;
27372 wxPyApp *result = 0 ;
27373
27374 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
27375 {
27376 PyThreadState* __tstate = wxPyBeginAllowThreads();
27377 result = (wxPyApp *)new_wxPyApp();
27378 wxPyEndAllowThreads(__tstate);
27379 if (PyErr_Occurred()) SWIG_fail;
27380 }
27381 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
27382 return resultobj;
27383 fail:
27384 return NULL;
27385 }
27386
27387
27388 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27389 PyObject *resultobj = 0;
27390 wxPyApp *arg1 = (wxPyApp *) 0 ;
27391 void *argp1 = 0 ;
27392 int res1 = 0 ;
27393 PyObject *swig_obj[1] ;
27394
27395 if (!args) SWIG_fail;
27396 swig_obj[0] = args;
27397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
27398 if (!SWIG_IsOK(res1)) {
27399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
27400 }
27401 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27402 {
27403 PyThreadState* __tstate = wxPyBeginAllowThreads();
27404 delete arg1;
27405
27406 wxPyEndAllowThreads(__tstate);
27407 if (PyErr_Occurred()) SWIG_fail;
27408 }
27409 resultobj = SWIG_Py_Void();
27410 return resultobj;
27411 fail:
27412 return NULL;
27413 }
27414
27415
27416 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27417 PyObject *resultobj = 0;
27418 wxPyApp *arg1 = (wxPyApp *) 0 ;
27419 PyObject *arg2 = (PyObject *) 0 ;
27420 PyObject *arg3 = (PyObject *) 0 ;
27421 bool arg4 ;
27422 void *argp1 = 0 ;
27423 int res1 = 0 ;
27424 bool val4 ;
27425 int ecode4 = 0 ;
27426 PyObject * obj0 = 0 ;
27427 PyObject * obj1 = 0 ;
27428 PyObject * obj2 = 0 ;
27429 PyObject * obj3 = 0 ;
27430 char * kwnames[] = {
27431 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
27432 };
27433
27434 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27435 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27436 if (!SWIG_IsOK(res1)) {
27437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
27438 }
27439 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27440 arg2 = obj1;
27441 arg3 = obj2;
27442 ecode4 = SWIG_AsVal_bool(obj3, &val4);
27443 if (!SWIG_IsOK(ecode4)) {
27444 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
27445 }
27446 arg4 = static_cast< bool >(val4);
27447 {
27448 PyThreadState* __tstate = wxPyBeginAllowThreads();
27449 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
27450 wxPyEndAllowThreads(__tstate);
27451 if (PyErr_Occurred()) SWIG_fail;
27452 }
27453 resultobj = SWIG_Py_Void();
27454 return resultobj;
27455 fail:
27456 return NULL;
27457 }
27458
27459
27460 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27461 PyObject *resultobj = 0;
27462 wxPyApp *arg1 = (wxPyApp *) 0 ;
27463 wxString result;
27464 void *argp1 = 0 ;
27465 int res1 = 0 ;
27466 PyObject *swig_obj[1] ;
27467
27468 if (!args) SWIG_fail;
27469 swig_obj[0] = args;
27470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27471 if (!SWIG_IsOK(res1)) {
27472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27473 }
27474 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27475 {
27476 PyThreadState* __tstate = wxPyBeginAllowThreads();
27477 result = ((wxPyApp const *)arg1)->GetAppName();
27478 wxPyEndAllowThreads(__tstate);
27479 if (PyErr_Occurred()) SWIG_fail;
27480 }
27481 {
27482 #if wxUSE_UNICODE
27483 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27484 #else
27485 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27486 #endif
27487 }
27488 return resultobj;
27489 fail:
27490 return NULL;
27491 }
27492
27493
27494 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27495 PyObject *resultobj = 0;
27496 wxPyApp *arg1 = (wxPyApp *) 0 ;
27497 wxString *arg2 = 0 ;
27498 void *argp1 = 0 ;
27499 int res1 = 0 ;
27500 bool temp2 = false ;
27501 PyObject * obj0 = 0 ;
27502 PyObject * obj1 = 0 ;
27503 char * kwnames[] = {
27504 (char *) "self",(char *) "name", NULL
27505 };
27506
27507 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
27508 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27509 if (!SWIG_IsOK(res1)) {
27510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27511 }
27512 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27513 {
27514 arg2 = wxString_in_helper(obj1);
27515 if (arg2 == NULL) SWIG_fail;
27516 temp2 = true;
27517 }
27518 {
27519 PyThreadState* __tstate = wxPyBeginAllowThreads();
27520 (arg1)->SetAppName((wxString const &)*arg2);
27521 wxPyEndAllowThreads(__tstate);
27522 if (PyErr_Occurred()) SWIG_fail;
27523 }
27524 resultobj = SWIG_Py_Void();
27525 {
27526 if (temp2)
27527 delete arg2;
27528 }
27529 return resultobj;
27530 fail:
27531 {
27532 if (temp2)
27533 delete arg2;
27534 }
27535 return NULL;
27536 }
27537
27538
27539 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27540 PyObject *resultobj = 0;
27541 wxPyApp *arg1 = (wxPyApp *) 0 ;
27542 wxString result;
27543 void *argp1 = 0 ;
27544 int res1 = 0 ;
27545 PyObject *swig_obj[1] ;
27546
27547 if (!args) SWIG_fail;
27548 swig_obj[0] = args;
27549 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27550 if (!SWIG_IsOK(res1)) {
27551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27552 }
27553 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27554 {
27555 PyThreadState* __tstate = wxPyBeginAllowThreads();
27556 result = ((wxPyApp const *)arg1)->GetClassName();
27557 wxPyEndAllowThreads(__tstate);
27558 if (PyErr_Occurred()) SWIG_fail;
27559 }
27560 {
27561 #if wxUSE_UNICODE
27562 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27563 #else
27564 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27565 #endif
27566 }
27567 return resultobj;
27568 fail:
27569 return NULL;
27570 }
27571
27572
27573 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27574 PyObject *resultobj = 0;
27575 wxPyApp *arg1 = (wxPyApp *) 0 ;
27576 wxString *arg2 = 0 ;
27577 void *argp1 = 0 ;
27578 int res1 = 0 ;
27579 bool temp2 = false ;
27580 PyObject * obj0 = 0 ;
27581 PyObject * obj1 = 0 ;
27582 char * kwnames[] = {
27583 (char *) "self",(char *) "name", NULL
27584 };
27585
27586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
27587 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27588 if (!SWIG_IsOK(res1)) {
27589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27590 }
27591 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27592 {
27593 arg2 = wxString_in_helper(obj1);
27594 if (arg2 == NULL) SWIG_fail;
27595 temp2 = true;
27596 }
27597 {
27598 PyThreadState* __tstate = wxPyBeginAllowThreads();
27599 (arg1)->SetClassName((wxString const &)*arg2);
27600 wxPyEndAllowThreads(__tstate);
27601 if (PyErr_Occurred()) SWIG_fail;
27602 }
27603 resultobj = SWIG_Py_Void();
27604 {
27605 if (temp2)
27606 delete arg2;
27607 }
27608 return resultobj;
27609 fail:
27610 {
27611 if (temp2)
27612 delete arg2;
27613 }
27614 return NULL;
27615 }
27616
27617
27618 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27619 PyObject *resultobj = 0;
27620 wxPyApp *arg1 = (wxPyApp *) 0 ;
27621 wxString *result = 0 ;
27622 void *argp1 = 0 ;
27623 int res1 = 0 ;
27624 PyObject *swig_obj[1] ;
27625
27626 if (!args) SWIG_fail;
27627 swig_obj[0] = args;
27628 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27629 if (!SWIG_IsOK(res1)) {
27630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27631 }
27632 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27633 {
27634 PyThreadState* __tstate = wxPyBeginAllowThreads();
27635 {
27636 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
27637 result = (wxString *) &_result_ref;
27638 }
27639 wxPyEndAllowThreads(__tstate);
27640 if (PyErr_Occurred()) SWIG_fail;
27641 }
27642 {
27643 #if wxUSE_UNICODE
27644 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
27645 #else
27646 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
27647 #endif
27648 }
27649 return resultobj;
27650 fail:
27651 return NULL;
27652 }
27653
27654
27655 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27656 PyObject *resultobj = 0;
27657 wxPyApp *arg1 = (wxPyApp *) 0 ;
27658 wxString *arg2 = 0 ;
27659 void *argp1 = 0 ;
27660 int res1 = 0 ;
27661 bool temp2 = false ;
27662 PyObject * obj0 = 0 ;
27663 PyObject * obj1 = 0 ;
27664 char * kwnames[] = {
27665 (char *) "self",(char *) "name", NULL
27666 };
27667
27668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
27669 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27670 if (!SWIG_IsOK(res1)) {
27671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27672 }
27673 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27674 {
27675 arg2 = wxString_in_helper(obj1);
27676 if (arg2 == NULL) SWIG_fail;
27677 temp2 = true;
27678 }
27679 {
27680 PyThreadState* __tstate = wxPyBeginAllowThreads();
27681 (arg1)->SetVendorName((wxString const &)*arg2);
27682 wxPyEndAllowThreads(__tstate);
27683 if (PyErr_Occurred()) SWIG_fail;
27684 }
27685 resultobj = SWIG_Py_Void();
27686 {
27687 if (temp2)
27688 delete arg2;
27689 }
27690 return resultobj;
27691 fail:
27692 {
27693 if (temp2)
27694 delete arg2;
27695 }
27696 return NULL;
27697 }
27698
27699
27700 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27701 PyObject *resultobj = 0;
27702 wxPyApp *arg1 = (wxPyApp *) 0 ;
27703 wxAppTraits *result = 0 ;
27704 void *argp1 = 0 ;
27705 int res1 = 0 ;
27706 PyObject *swig_obj[1] ;
27707
27708 if (!args) SWIG_fail;
27709 swig_obj[0] = args;
27710 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27711 if (!SWIG_IsOK(res1)) {
27712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
27713 }
27714 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27715 {
27716 PyThreadState* __tstate = wxPyBeginAllowThreads();
27717 result = (wxAppTraits *)(arg1)->GetTraits();
27718 wxPyEndAllowThreads(__tstate);
27719 if (PyErr_Occurred()) SWIG_fail;
27720 }
27721 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
27722 return resultobj;
27723 fail:
27724 return NULL;
27725 }
27726
27727
27728 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27729 PyObject *resultobj = 0;
27730 wxPyApp *arg1 = (wxPyApp *) 0 ;
27731 void *argp1 = 0 ;
27732 int res1 = 0 ;
27733 PyObject *swig_obj[1] ;
27734
27735 if (!args) SWIG_fail;
27736 swig_obj[0] = args;
27737 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27738 if (!SWIG_IsOK(res1)) {
27739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27740 }
27741 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27742 {
27743 PyThreadState* __tstate = wxPyBeginAllowThreads();
27744 (arg1)->ProcessPendingEvents();
27745 wxPyEndAllowThreads(__tstate);
27746 if (PyErr_Occurred()) SWIG_fail;
27747 }
27748 resultobj = SWIG_Py_Void();
27749 return resultobj;
27750 fail:
27751 return NULL;
27752 }
27753
27754
27755 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27756 PyObject *resultobj = 0;
27757 wxPyApp *arg1 = (wxPyApp *) 0 ;
27758 bool arg2 = (bool) false ;
27759 bool result;
27760 void *argp1 = 0 ;
27761 int res1 = 0 ;
27762 bool val2 ;
27763 int ecode2 = 0 ;
27764 PyObject * obj0 = 0 ;
27765 PyObject * obj1 = 0 ;
27766 char * kwnames[] = {
27767 (char *) "self",(char *) "onlyIfNeeded", NULL
27768 };
27769
27770 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
27771 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27772 if (!SWIG_IsOK(res1)) {
27773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
27774 }
27775 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27776 if (obj1) {
27777 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27778 if (!SWIG_IsOK(ecode2)) {
27779 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
27780 }
27781 arg2 = static_cast< bool >(val2);
27782 }
27783 {
27784 PyThreadState* __tstate = wxPyBeginAllowThreads();
27785 result = (bool)(arg1)->Yield(arg2);
27786 wxPyEndAllowThreads(__tstate);
27787 if (PyErr_Occurred()) SWIG_fail;
27788 }
27789 {
27790 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27791 }
27792 return resultobj;
27793 fail:
27794 return NULL;
27795 }
27796
27797
27798 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27799 PyObject *resultobj = 0;
27800 wxPyApp *arg1 = (wxPyApp *) 0 ;
27801 void *argp1 = 0 ;
27802 int res1 = 0 ;
27803 PyObject *swig_obj[1] ;
27804
27805 if (!args) SWIG_fail;
27806 swig_obj[0] = args;
27807 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27808 if (!SWIG_IsOK(res1)) {
27809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27810 }
27811 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27812 {
27813 PyThreadState* __tstate = wxPyBeginAllowThreads();
27814 (arg1)->WakeUpIdle();
27815 wxPyEndAllowThreads(__tstate);
27816 if (PyErr_Occurred()) SWIG_fail;
27817 }
27818 resultobj = SWIG_Py_Void();
27819 return resultobj;
27820 fail:
27821 return NULL;
27822 }
27823
27824
27825 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27826 PyObject *resultobj = 0;
27827 bool result;
27828
27829 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
27830 {
27831 PyThreadState* __tstate = wxPyBeginAllowThreads();
27832 result = (bool)wxPyApp::IsMainLoopRunning();
27833 wxPyEndAllowThreads(__tstate);
27834 if (PyErr_Occurred()) SWIG_fail;
27835 }
27836 {
27837 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27838 }
27839 return resultobj;
27840 fail:
27841 return NULL;
27842 }
27843
27844
27845 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27846 PyObject *resultobj = 0;
27847 wxPyApp *arg1 = (wxPyApp *) 0 ;
27848 int result;
27849 void *argp1 = 0 ;
27850 int res1 = 0 ;
27851 PyObject *swig_obj[1] ;
27852
27853 if (!args) SWIG_fail;
27854 swig_obj[0] = args;
27855 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27856 if (!SWIG_IsOK(res1)) {
27857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27858 }
27859 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27860 {
27861 PyThreadState* __tstate = wxPyBeginAllowThreads();
27862 result = (int)(arg1)->MainLoop();
27863 wxPyEndAllowThreads(__tstate);
27864 if (PyErr_Occurred()) SWIG_fail;
27865 }
27866 resultobj = SWIG_From_int(static_cast< int >(result));
27867 return resultobj;
27868 fail:
27869 return NULL;
27870 }
27871
27872
27873 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27874 PyObject *resultobj = 0;
27875 wxPyApp *arg1 = (wxPyApp *) 0 ;
27876 void *argp1 = 0 ;
27877 int res1 = 0 ;
27878 PyObject *swig_obj[1] ;
27879
27880 if (!args) SWIG_fail;
27881 swig_obj[0] = args;
27882 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27883 if (!SWIG_IsOK(res1)) {
27884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
27885 }
27886 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27887 {
27888 PyThreadState* __tstate = wxPyBeginAllowThreads();
27889 (arg1)->Exit();
27890 wxPyEndAllowThreads(__tstate);
27891 if (PyErr_Occurred()) SWIG_fail;
27892 }
27893 resultobj = SWIG_Py_Void();
27894 return resultobj;
27895 fail:
27896 return NULL;
27897 }
27898
27899
27900 SWIGINTERN PyObject *_wrap_PyApp_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27901 PyObject *resultobj = 0;
27902 wxPyApp *arg1 = (wxPyApp *) 0 ;
27903 wxLayoutDirection result;
27904 void *argp1 = 0 ;
27905 int res1 = 0 ;
27906 PyObject *swig_obj[1] ;
27907
27908 if (!args) SWIG_fail;
27909 swig_obj[0] = args;
27910 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27911 if (!SWIG_IsOK(res1)) {
27912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetLayoutDirection" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27913 }
27914 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27915 {
27916 PyThreadState* __tstate = wxPyBeginAllowThreads();
27917 result = (wxLayoutDirection)((wxPyApp const *)arg1)->GetLayoutDirection();
27918 wxPyEndAllowThreads(__tstate);
27919 if (PyErr_Occurred()) SWIG_fail;
27920 }
27921 resultobj = SWIG_From_int(static_cast< int >(result));
27922 return resultobj;
27923 fail:
27924 return NULL;
27925 }
27926
27927
27928 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27929 PyObject *resultobj = 0;
27930 wxPyApp *arg1 = (wxPyApp *) 0 ;
27931 void *argp1 = 0 ;
27932 int res1 = 0 ;
27933 PyObject *swig_obj[1] ;
27934
27935 if (!args) SWIG_fail;
27936 swig_obj[0] = args;
27937 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27938 if (!SWIG_IsOK(res1)) {
27939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27940 }
27941 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27942 {
27943 PyThreadState* __tstate = wxPyBeginAllowThreads();
27944 (arg1)->ExitMainLoop();
27945 wxPyEndAllowThreads(__tstate);
27946 if (PyErr_Occurred()) SWIG_fail;
27947 }
27948 resultobj = SWIG_Py_Void();
27949 return resultobj;
27950 fail:
27951 return NULL;
27952 }
27953
27954
27955 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27956 PyObject *resultobj = 0;
27957 wxPyApp *arg1 = (wxPyApp *) 0 ;
27958 bool result;
27959 void *argp1 = 0 ;
27960 int res1 = 0 ;
27961 PyObject *swig_obj[1] ;
27962
27963 if (!args) SWIG_fail;
27964 swig_obj[0] = args;
27965 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27966 if (!SWIG_IsOK(res1)) {
27967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
27968 }
27969 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27970 {
27971 PyThreadState* __tstate = wxPyBeginAllowThreads();
27972 result = (bool)(arg1)->Pending();
27973 wxPyEndAllowThreads(__tstate);
27974 if (PyErr_Occurred()) SWIG_fail;
27975 }
27976 {
27977 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27978 }
27979 return resultobj;
27980 fail:
27981 return NULL;
27982 }
27983
27984
27985 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27986 PyObject *resultobj = 0;
27987 wxPyApp *arg1 = (wxPyApp *) 0 ;
27988 bool result;
27989 void *argp1 = 0 ;
27990 int res1 = 0 ;
27991 PyObject *swig_obj[1] ;
27992
27993 if (!args) SWIG_fail;
27994 swig_obj[0] = args;
27995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27996 if (!SWIG_IsOK(res1)) {
27997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
27998 }
27999 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28000 {
28001 PyThreadState* __tstate = wxPyBeginAllowThreads();
28002 result = (bool)(arg1)->Dispatch();
28003 wxPyEndAllowThreads(__tstate);
28004 if (PyErr_Occurred()) SWIG_fail;
28005 }
28006 {
28007 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28008 }
28009 return resultobj;
28010 fail:
28011 return NULL;
28012 }
28013
28014
28015 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28016 PyObject *resultobj = 0;
28017 wxPyApp *arg1 = (wxPyApp *) 0 ;
28018 bool result;
28019 void *argp1 = 0 ;
28020 int res1 = 0 ;
28021 PyObject *swig_obj[1] ;
28022
28023 if (!args) SWIG_fail;
28024 swig_obj[0] = args;
28025 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28026 if (!SWIG_IsOK(res1)) {
28027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
28028 }
28029 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28030 {
28031 PyThreadState* __tstate = wxPyBeginAllowThreads();
28032 result = (bool)(arg1)->ProcessIdle();
28033 wxPyEndAllowThreads(__tstate);
28034 if (PyErr_Occurred()) SWIG_fail;
28035 }
28036 {
28037 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28038 }
28039 return resultobj;
28040 fail:
28041 return NULL;
28042 }
28043
28044
28045 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28046 PyObject *resultobj = 0;
28047 wxPyApp *arg1 = (wxPyApp *) 0 ;
28048 wxWindow *arg2 = (wxWindow *) 0 ;
28049 wxIdleEvent *arg3 = 0 ;
28050 bool result;
28051 void *argp1 = 0 ;
28052 int res1 = 0 ;
28053 void *argp2 = 0 ;
28054 int res2 = 0 ;
28055 void *argp3 = 0 ;
28056 int res3 = 0 ;
28057 PyObject * obj0 = 0 ;
28058 PyObject * obj1 = 0 ;
28059 PyObject * obj2 = 0 ;
28060 char * kwnames[] = {
28061 (char *) "self",(char *) "win",(char *) "event", NULL
28062 };
28063
28064 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28065 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28066 if (!SWIG_IsOK(res1)) {
28067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
28068 }
28069 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28070 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28071 if (!SWIG_IsOK(res2)) {
28072 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
28073 }
28074 arg2 = reinterpret_cast< wxWindow * >(argp2);
28075 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
28076 if (!SWIG_IsOK(res3)) {
28077 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
28078 }
28079 if (!argp3) {
28080 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
28081 }
28082 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
28083 {
28084 PyThreadState* __tstate = wxPyBeginAllowThreads();
28085 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
28086 wxPyEndAllowThreads(__tstate);
28087 if (PyErr_Occurred()) SWIG_fail;
28088 }
28089 {
28090 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28091 }
28092 return resultobj;
28093 fail:
28094 return NULL;
28095 }
28096
28097
28098 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28099 PyObject *resultobj = 0;
28100 wxPyApp *arg1 = (wxPyApp *) 0 ;
28101 bool result;
28102 void *argp1 = 0 ;
28103 int res1 = 0 ;
28104 PyObject *swig_obj[1] ;
28105
28106 if (!args) SWIG_fail;
28107 swig_obj[0] = args;
28108 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28109 if (!SWIG_IsOK(res1)) {
28110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28111 }
28112 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28113 {
28114 PyThreadState* __tstate = wxPyBeginAllowThreads();
28115 result = (bool)((wxPyApp const *)arg1)->IsActive();
28116 wxPyEndAllowThreads(__tstate);
28117 if (PyErr_Occurred()) SWIG_fail;
28118 }
28119 {
28120 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28121 }
28122 return resultobj;
28123 fail:
28124 return NULL;
28125 }
28126
28127
28128 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28129 PyObject *resultobj = 0;
28130 wxPyApp *arg1 = (wxPyApp *) 0 ;
28131 wxWindow *arg2 = (wxWindow *) 0 ;
28132 void *argp1 = 0 ;
28133 int res1 = 0 ;
28134 void *argp2 = 0 ;
28135 int res2 = 0 ;
28136 PyObject * obj0 = 0 ;
28137 PyObject * obj1 = 0 ;
28138 char * kwnames[] = {
28139 (char *) "self",(char *) "win", NULL
28140 };
28141
28142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
28143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28144 if (!SWIG_IsOK(res1)) {
28145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
28146 }
28147 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28148 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28149 if (!SWIG_IsOK(res2)) {
28150 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
28151 }
28152 arg2 = reinterpret_cast< wxWindow * >(argp2);
28153 {
28154 PyThreadState* __tstate = wxPyBeginAllowThreads();
28155 (arg1)->SetTopWindow(arg2);
28156 wxPyEndAllowThreads(__tstate);
28157 if (PyErr_Occurred()) SWIG_fail;
28158 }
28159 resultobj = SWIG_Py_Void();
28160 return resultobj;
28161 fail:
28162 return NULL;
28163 }
28164
28165
28166 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28167 PyObject *resultobj = 0;
28168 wxPyApp *arg1 = (wxPyApp *) 0 ;
28169 wxWindow *result = 0 ;
28170 void *argp1 = 0 ;
28171 int res1 = 0 ;
28172 PyObject *swig_obj[1] ;
28173
28174 if (!args) SWIG_fail;
28175 swig_obj[0] = args;
28176 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28177 if (!SWIG_IsOK(res1)) {
28178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28179 }
28180 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28181 {
28182 PyThreadState* __tstate = wxPyBeginAllowThreads();
28183 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
28184 wxPyEndAllowThreads(__tstate);
28185 if (PyErr_Occurred()) SWIG_fail;
28186 }
28187 {
28188 resultobj = wxPyMake_wxObject(result, (bool)0);
28189 }
28190 return resultobj;
28191 fail:
28192 return NULL;
28193 }
28194
28195
28196 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28197 PyObject *resultobj = 0;
28198 wxPyApp *arg1 = (wxPyApp *) 0 ;
28199 bool arg2 ;
28200 void *argp1 = 0 ;
28201 int res1 = 0 ;
28202 bool val2 ;
28203 int ecode2 = 0 ;
28204 PyObject * obj0 = 0 ;
28205 PyObject * obj1 = 0 ;
28206 char * kwnames[] = {
28207 (char *) "self",(char *) "flag", NULL
28208 };
28209
28210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
28211 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28212 if (!SWIG_IsOK(res1)) {
28213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
28214 }
28215 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28216 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28217 if (!SWIG_IsOK(ecode2)) {
28218 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
28219 }
28220 arg2 = static_cast< bool >(val2);
28221 {
28222 PyThreadState* __tstate = wxPyBeginAllowThreads();
28223 (arg1)->SetExitOnFrameDelete(arg2);
28224 wxPyEndAllowThreads(__tstate);
28225 if (PyErr_Occurred()) SWIG_fail;
28226 }
28227 resultobj = SWIG_Py_Void();
28228 return resultobj;
28229 fail:
28230 return NULL;
28231 }
28232
28233
28234 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28235 PyObject *resultobj = 0;
28236 wxPyApp *arg1 = (wxPyApp *) 0 ;
28237 bool result;
28238 void *argp1 = 0 ;
28239 int res1 = 0 ;
28240 PyObject *swig_obj[1] ;
28241
28242 if (!args) SWIG_fail;
28243 swig_obj[0] = args;
28244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28245 if (!SWIG_IsOK(res1)) {
28246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28247 }
28248 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28249 {
28250 PyThreadState* __tstate = wxPyBeginAllowThreads();
28251 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
28252 wxPyEndAllowThreads(__tstate);
28253 if (PyErr_Occurred()) SWIG_fail;
28254 }
28255 {
28256 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28257 }
28258 return resultobj;
28259 fail:
28260 return NULL;
28261 }
28262
28263
28264 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28265 PyObject *resultobj = 0;
28266 wxPyApp *arg1 = (wxPyApp *) 0 ;
28267 bool arg2 ;
28268 void *argp1 = 0 ;
28269 int res1 = 0 ;
28270 bool val2 ;
28271 int ecode2 = 0 ;
28272 PyObject * obj0 = 0 ;
28273 PyObject * obj1 = 0 ;
28274 char * kwnames[] = {
28275 (char *) "self",(char *) "flag", NULL
28276 };
28277
28278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) SWIG_fail;
28279 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28280 if (!SWIG_IsOK(res1)) {
28281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
28282 }
28283 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28284 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28285 if (!SWIG_IsOK(ecode2)) {
28286 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
28287 }
28288 arg2 = static_cast< bool >(val2);
28289 {
28290 PyThreadState* __tstate = wxPyBeginAllowThreads();
28291 (arg1)->SetUseBestVisual(arg2);
28292 wxPyEndAllowThreads(__tstate);
28293 if (PyErr_Occurred()) SWIG_fail;
28294 }
28295 resultobj = SWIG_Py_Void();
28296 return resultobj;
28297 fail:
28298 return NULL;
28299 }
28300
28301
28302 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28303 PyObject *resultobj = 0;
28304 wxPyApp *arg1 = (wxPyApp *) 0 ;
28305 bool result;
28306 void *argp1 = 0 ;
28307 int res1 = 0 ;
28308 PyObject *swig_obj[1] ;
28309
28310 if (!args) SWIG_fail;
28311 swig_obj[0] = args;
28312 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28313 if (!SWIG_IsOK(res1)) {
28314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28315 }
28316 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28317 {
28318 PyThreadState* __tstate = wxPyBeginAllowThreads();
28319 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
28320 wxPyEndAllowThreads(__tstate);
28321 if (PyErr_Occurred()) SWIG_fail;
28322 }
28323 {
28324 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28325 }
28326 return resultobj;
28327 fail:
28328 return NULL;
28329 }
28330
28331
28332 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28333 PyObject *resultobj = 0;
28334 wxPyApp *arg1 = (wxPyApp *) 0 ;
28335 int arg2 ;
28336 void *argp1 = 0 ;
28337 int res1 = 0 ;
28338 int val2 ;
28339 int ecode2 = 0 ;
28340 PyObject * obj0 = 0 ;
28341 PyObject * obj1 = 0 ;
28342 char * kwnames[] = {
28343 (char *) "self",(char *) "mode", NULL
28344 };
28345
28346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
28347 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28348 if (!SWIG_IsOK(res1)) {
28349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28350 }
28351 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28352 ecode2 = SWIG_AsVal_int(obj1, &val2);
28353 if (!SWIG_IsOK(ecode2)) {
28354 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
28355 }
28356 arg2 = static_cast< int >(val2);
28357 {
28358 PyThreadState* __tstate = wxPyBeginAllowThreads();
28359 (arg1)->SetPrintMode(arg2);
28360 wxPyEndAllowThreads(__tstate);
28361 if (PyErr_Occurred()) SWIG_fail;
28362 }
28363 resultobj = SWIG_Py_Void();
28364 return resultobj;
28365 fail:
28366 return NULL;
28367 }
28368
28369
28370 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28371 PyObject *resultobj = 0;
28372 wxPyApp *arg1 = (wxPyApp *) 0 ;
28373 int result;
28374 void *argp1 = 0 ;
28375 int res1 = 0 ;
28376 PyObject *swig_obj[1] ;
28377
28378 if (!args) SWIG_fail;
28379 swig_obj[0] = args;
28380 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28381 if (!SWIG_IsOK(res1)) {
28382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28383 }
28384 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28385 {
28386 PyThreadState* __tstate = wxPyBeginAllowThreads();
28387 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
28388 wxPyEndAllowThreads(__tstate);
28389 if (PyErr_Occurred()) SWIG_fail;
28390 }
28391 resultobj = SWIG_From_int(static_cast< int >(result));
28392 return resultobj;
28393 fail:
28394 return NULL;
28395 }
28396
28397
28398 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28399 PyObject *resultobj = 0;
28400 wxPyApp *arg1 = (wxPyApp *) 0 ;
28401 int arg2 ;
28402 void *argp1 = 0 ;
28403 int res1 = 0 ;
28404 int val2 ;
28405 int ecode2 = 0 ;
28406 PyObject * obj0 = 0 ;
28407 PyObject * obj1 = 0 ;
28408 char * kwnames[] = {
28409 (char *) "self",(char *) "mode", NULL
28410 };
28411
28412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
28413 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28414 if (!SWIG_IsOK(res1)) {
28415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28416 }
28417 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28418 ecode2 = SWIG_AsVal_int(obj1, &val2);
28419 if (!SWIG_IsOK(ecode2)) {
28420 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
28421 }
28422 arg2 = static_cast< int >(val2);
28423 {
28424 PyThreadState* __tstate = wxPyBeginAllowThreads();
28425 (arg1)->SetAssertMode(arg2);
28426 wxPyEndAllowThreads(__tstate);
28427 if (PyErr_Occurred()) SWIG_fail;
28428 }
28429 resultobj = SWIG_Py_Void();
28430 return resultobj;
28431 fail:
28432 return NULL;
28433 }
28434
28435
28436 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28437 PyObject *resultobj = 0;
28438 wxPyApp *arg1 = (wxPyApp *) 0 ;
28439 int result;
28440 void *argp1 = 0 ;
28441 int res1 = 0 ;
28442 PyObject *swig_obj[1] ;
28443
28444 if (!args) SWIG_fail;
28445 swig_obj[0] = args;
28446 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28447 if (!SWIG_IsOK(res1)) {
28448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28449 }
28450 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28451 {
28452 PyThreadState* __tstate = wxPyBeginAllowThreads();
28453 result = (int)(arg1)->GetAssertMode();
28454 wxPyEndAllowThreads(__tstate);
28455 if (PyErr_Occurred()) SWIG_fail;
28456 }
28457 resultobj = SWIG_From_int(static_cast< int >(result));
28458 return resultobj;
28459 fail:
28460 return NULL;
28461 }
28462
28463
28464 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28465 PyObject *resultobj = 0;
28466 bool result;
28467
28468 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
28469 {
28470 PyThreadState* __tstate = wxPyBeginAllowThreads();
28471 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
28472 wxPyEndAllowThreads(__tstate);
28473 if (PyErr_Occurred()) SWIG_fail;
28474 }
28475 {
28476 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28477 }
28478 return resultobj;
28479 fail:
28480 return NULL;
28481 }
28482
28483
28484 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28485 PyObject *resultobj = 0;
28486 long result;
28487
28488 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
28489 {
28490 PyThreadState* __tstate = wxPyBeginAllowThreads();
28491 result = (long)wxPyApp::GetMacAboutMenuItemId();
28492 wxPyEndAllowThreads(__tstate);
28493 if (PyErr_Occurred()) SWIG_fail;
28494 }
28495 resultobj = SWIG_From_long(static_cast< long >(result));
28496 return resultobj;
28497 fail:
28498 return NULL;
28499 }
28500
28501
28502 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28503 PyObject *resultobj = 0;
28504 long result;
28505
28506 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
28507 {
28508 PyThreadState* __tstate = wxPyBeginAllowThreads();
28509 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
28510 wxPyEndAllowThreads(__tstate);
28511 if (PyErr_Occurred()) SWIG_fail;
28512 }
28513 resultobj = SWIG_From_long(static_cast< long >(result));
28514 return resultobj;
28515 fail:
28516 return NULL;
28517 }
28518
28519
28520 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28521 PyObject *resultobj = 0;
28522 long result;
28523
28524 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
28525 {
28526 PyThreadState* __tstate = wxPyBeginAllowThreads();
28527 result = (long)wxPyApp::GetMacExitMenuItemId();
28528 wxPyEndAllowThreads(__tstate);
28529 if (PyErr_Occurred()) SWIG_fail;
28530 }
28531 resultobj = SWIG_From_long(static_cast< long >(result));
28532 return resultobj;
28533 fail:
28534 return NULL;
28535 }
28536
28537
28538 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28539 PyObject *resultobj = 0;
28540 wxString result;
28541
28542 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
28543 {
28544 PyThreadState* __tstate = wxPyBeginAllowThreads();
28545 result = wxPyApp::GetMacHelpMenuTitleName();
28546 wxPyEndAllowThreads(__tstate);
28547 if (PyErr_Occurred()) SWIG_fail;
28548 }
28549 {
28550 #if wxUSE_UNICODE
28551 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28552 #else
28553 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28554 #endif
28555 }
28556 return resultobj;
28557 fail:
28558 return NULL;
28559 }
28560
28561
28562 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28563 PyObject *resultobj = 0;
28564 bool arg1 ;
28565 bool val1 ;
28566 int ecode1 = 0 ;
28567 PyObject * obj0 = 0 ;
28568 char * kwnames[] = {
28569 (char *) "val", NULL
28570 };
28571
28572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
28573 ecode1 = SWIG_AsVal_bool(obj0, &val1);
28574 if (!SWIG_IsOK(ecode1)) {
28575 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
28576 }
28577 arg1 = static_cast< bool >(val1);
28578 {
28579 PyThreadState* __tstate = wxPyBeginAllowThreads();
28580 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
28581 wxPyEndAllowThreads(__tstate);
28582 if (PyErr_Occurred()) SWIG_fail;
28583 }
28584 resultobj = SWIG_Py_Void();
28585 return resultobj;
28586 fail:
28587 return NULL;
28588 }
28589
28590
28591 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28592 PyObject *resultobj = 0;
28593 long arg1 ;
28594 long val1 ;
28595 int ecode1 = 0 ;
28596 PyObject * obj0 = 0 ;
28597 char * kwnames[] = {
28598 (char *) "val", NULL
28599 };
28600
28601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
28602 ecode1 = SWIG_AsVal_long(obj0, &val1);
28603 if (!SWIG_IsOK(ecode1)) {
28604 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
28605 }
28606 arg1 = static_cast< long >(val1);
28607 {
28608 PyThreadState* __tstate = wxPyBeginAllowThreads();
28609 wxPyApp::SetMacAboutMenuItemId(arg1);
28610 wxPyEndAllowThreads(__tstate);
28611 if (PyErr_Occurred()) SWIG_fail;
28612 }
28613 resultobj = SWIG_Py_Void();
28614 return resultobj;
28615 fail:
28616 return NULL;
28617 }
28618
28619
28620 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28621 PyObject *resultobj = 0;
28622 long arg1 ;
28623 long val1 ;
28624 int ecode1 = 0 ;
28625 PyObject * obj0 = 0 ;
28626 char * kwnames[] = {
28627 (char *) "val", NULL
28628 };
28629
28630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
28631 ecode1 = SWIG_AsVal_long(obj0, &val1);
28632 if (!SWIG_IsOK(ecode1)) {
28633 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
28634 }
28635 arg1 = static_cast< long >(val1);
28636 {
28637 PyThreadState* __tstate = wxPyBeginAllowThreads();
28638 wxPyApp::SetMacPreferencesMenuItemId(arg1);
28639 wxPyEndAllowThreads(__tstate);
28640 if (PyErr_Occurred()) SWIG_fail;
28641 }
28642 resultobj = SWIG_Py_Void();
28643 return resultobj;
28644 fail:
28645 return NULL;
28646 }
28647
28648
28649 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28650 PyObject *resultobj = 0;
28651 long arg1 ;
28652 long val1 ;
28653 int ecode1 = 0 ;
28654 PyObject * obj0 = 0 ;
28655 char * kwnames[] = {
28656 (char *) "val", NULL
28657 };
28658
28659 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
28660 ecode1 = SWIG_AsVal_long(obj0, &val1);
28661 if (!SWIG_IsOK(ecode1)) {
28662 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
28663 }
28664 arg1 = static_cast< long >(val1);
28665 {
28666 PyThreadState* __tstate = wxPyBeginAllowThreads();
28667 wxPyApp::SetMacExitMenuItemId(arg1);
28668 wxPyEndAllowThreads(__tstate);
28669 if (PyErr_Occurred()) SWIG_fail;
28670 }
28671 resultobj = SWIG_Py_Void();
28672 return resultobj;
28673 fail:
28674 return NULL;
28675 }
28676
28677
28678 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28679 PyObject *resultobj = 0;
28680 wxString *arg1 = 0 ;
28681 bool temp1 = false ;
28682 PyObject * obj0 = 0 ;
28683 char * kwnames[] = {
28684 (char *) "val", NULL
28685 };
28686
28687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
28688 {
28689 arg1 = wxString_in_helper(obj0);
28690 if (arg1 == NULL) SWIG_fail;
28691 temp1 = true;
28692 }
28693 {
28694 PyThreadState* __tstate = wxPyBeginAllowThreads();
28695 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
28696 wxPyEndAllowThreads(__tstate);
28697 if (PyErr_Occurred()) SWIG_fail;
28698 }
28699 resultobj = SWIG_Py_Void();
28700 {
28701 if (temp1)
28702 delete arg1;
28703 }
28704 return resultobj;
28705 fail:
28706 {
28707 if (temp1)
28708 delete arg1;
28709 }
28710 return NULL;
28711 }
28712
28713
28714 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28715 PyObject *resultobj = 0;
28716 wxPyApp *arg1 = (wxPyApp *) 0 ;
28717 void *argp1 = 0 ;
28718 int res1 = 0 ;
28719 PyObject *swig_obj[1] ;
28720
28721 if (!args) SWIG_fail;
28722 swig_obj[0] = args;
28723 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28724 if (!SWIG_IsOK(res1)) {
28725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
28726 }
28727 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28728 {
28729 PyThreadState* __tstate = wxPyBeginAllowThreads();
28730 (arg1)->_BootstrapApp();
28731 wxPyEndAllowThreads(__tstate);
28732 if (PyErr_Occurred()) SWIG_fail;
28733 }
28734 resultobj = SWIG_Py_Void();
28735 return resultobj;
28736 fail:
28737 return NULL;
28738 }
28739
28740
28741 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28742 PyObject *resultobj = 0;
28743 int result;
28744
28745 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
28746 {
28747 PyThreadState* __tstate = wxPyBeginAllowThreads();
28748 result = (int)wxPyApp_GetComCtl32Version();
28749 wxPyEndAllowThreads(__tstate);
28750 if (PyErr_Occurred()) SWIG_fail;
28751 }
28752 resultobj = SWIG_From_int(static_cast< int >(result));
28753 return resultobj;
28754 fail:
28755 return NULL;
28756 }
28757
28758
28759 SWIGINTERN PyObject *_wrap_PyApp_IsDisplayAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28760 PyObject *resultobj = 0;
28761 bool result;
28762
28763 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsDisplayAvailable",0,0,0)) SWIG_fail;
28764 {
28765 PyThreadState* __tstate = wxPyBeginAllowThreads();
28766 result = (bool)wxPyApp_IsDisplayAvailable();
28767 wxPyEndAllowThreads(__tstate);
28768 if (PyErr_Occurred()) SWIG_fail;
28769 }
28770 {
28771 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28772 }
28773 return resultobj;
28774 fail:
28775 return NULL;
28776 }
28777
28778
28779 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28780 PyObject *obj;
28781 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28782 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
28783 return SWIG_Py_Void();
28784 }
28785
28786 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28787 return SWIG_Python_InitShadowInstance(args);
28788 }
28789
28790 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28791 PyObject *resultobj = 0;
28792
28793 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
28794 {
28795 PyThreadState* __tstate = wxPyBeginAllowThreads();
28796 wxExit();
28797 wxPyEndAllowThreads(__tstate);
28798 if (PyErr_Occurred()) SWIG_fail;
28799 }
28800 resultobj = SWIG_Py_Void();
28801 return resultobj;
28802 fail:
28803 return NULL;
28804 }
28805
28806
28807 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28808 PyObject *resultobj = 0;
28809 bool result;
28810
28811 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
28812 {
28813 PyThreadState* __tstate = wxPyBeginAllowThreads();
28814 result = (bool)wxYield();
28815 wxPyEndAllowThreads(__tstate);
28816 if (PyErr_Occurred()) SWIG_fail;
28817 }
28818 {
28819 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28820 }
28821 return resultobj;
28822 fail:
28823 return NULL;
28824 }
28825
28826
28827 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28828 PyObject *resultobj = 0;
28829 bool result;
28830
28831 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
28832 {
28833 PyThreadState* __tstate = wxPyBeginAllowThreads();
28834 result = (bool)wxYieldIfNeeded();
28835 wxPyEndAllowThreads(__tstate);
28836 if (PyErr_Occurred()) SWIG_fail;
28837 }
28838 {
28839 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28840 }
28841 return resultobj;
28842 fail:
28843 return NULL;
28844 }
28845
28846
28847 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28848 PyObject *resultobj = 0;
28849 wxWindow *arg1 = (wxWindow *) NULL ;
28850 bool arg2 = (bool) false ;
28851 bool result;
28852 void *argp1 = 0 ;
28853 int res1 = 0 ;
28854 bool val2 ;
28855 int ecode2 = 0 ;
28856 PyObject * obj0 = 0 ;
28857 PyObject * obj1 = 0 ;
28858 char * kwnames[] = {
28859 (char *) "win",(char *) "onlyIfNeeded", NULL
28860 };
28861
28862 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
28863 if (obj0) {
28864 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28865 if (!SWIG_IsOK(res1)) {
28866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
28867 }
28868 arg1 = reinterpret_cast< wxWindow * >(argp1);
28869 }
28870 if (obj1) {
28871 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28872 if (!SWIG_IsOK(ecode2)) {
28873 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
28874 }
28875 arg2 = static_cast< bool >(val2);
28876 }
28877 {
28878 PyThreadState* __tstate = wxPyBeginAllowThreads();
28879 result = (bool)wxSafeYield(arg1,arg2);
28880 wxPyEndAllowThreads(__tstate);
28881 if (PyErr_Occurred()) SWIG_fail;
28882 }
28883 {
28884 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28885 }
28886 return resultobj;
28887 fail:
28888 return NULL;
28889 }
28890
28891
28892 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28893 PyObject *resultobj = 0;
28894
28895 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
28896 {
28897 PyThreadState* __tstate = wxPyBeginAllowThreads();
28898 wxWakeUpIdle();
28899 wxPyEndAllowThreads(__tstate);
28900 if (PyErr_Occurred()) SWIG_fail;
28901 }
28902 resultobj = SWIG_Py_Void();
28903 return resultobj;
28904 fail:
28905 return NULL;
28906 }
28907
28908
28909 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28910 PyObject *resultobj = 0;
28911 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
28912 wxEvent *arg2 = 0 ;
28913 void *argp1 = 0 ;
28914 int res1 = 0 ;
28915 void *argp2 = 0 ;
28916 int res2 = 0 ;
28917 PyObject * obj0 = 0 ;
28918 PyObject * obj1 = 0 ;
28919 char * kwnames[] = {
28920 (char *) "dest",(char *) "event", NULL
28921 };
28922
28923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
28925 if (!SWIG_IsOK(res1)) {
28926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
28927 }
28928 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
28929 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
28930 if (!SWIG_IsOK(res2)) {
28931 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28932 }
28933 if (!argp2) {
28934 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28935 }
28936 arg2 = reinterpret_cast< wxEvent * >(argp2);
28937 {
28938 PyThreadState* __tstate = wxPyBeginAllowThreads();
28939 wxPostEvent(arg1,*arg2);
28940 wxPyEndAllowThreads(__tstate);
28941 if (PyErr_Occurred()) SWIG_fail;
28942 }
28943 resultobj = SWIG_Py_Void();
28944 return resultobj;
28945 fail:
28946 return NULL;
28947 }
28948
28949
28950 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28951 PyObject *resultobj = 0;
28952
28953 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
28954 {
28955 PyThreadState* __tstate = wxPyBeginAllowThreads();
28956 wxApp_CleanUp();
28957 wxPyEndAllowThreads(__tstate);
28958 if (PyErr_Occurred()) SWIG_fail;
28959 }
28960 resultobj = SWIG_Py_Void();
28961 return resultobj;
28962 fail:
28963 return NULL;
28964 }
28965
28966
28967 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28968 PyObject *resultobj = 0;
28969 wxPyApp *result = 0 ;
28970
28971 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
28972 {
28973 PyThreadState* __tstate = wxPyBeginAllowThreads();
28974 result = (wxPyApp *)wxPyGetApp();
28975 wxPyEndAllowThreads(__tstate);
28976 if (PyErr_Occurred()) SWIG_fail;
28977 }
28978 {
28979 resultobj = wxPyMake_wxObject(result, 0);
28980 }
28981 return resultobj;
28982 fail:
28983 return NULL;
28984 }
28985
28986
28987 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28988 PyObject *resultobj = 0;
28989 char *arg1 = (char *) 0 ;
28990 int res1 ;
28991 char *buf1 = 0 ;
28992 int alloc1 = 0 ;
28993 PyObject * obj0 = 0 ;
28994 char * kwnames[] = {
28995 (char *) "encoding", NULL
28996 };
28997
28998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
28999 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
29000 if (!SWIG_IsOK(res1)) {
29001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
29002 }
29003 arg1 = buf1;
29004 {
29005 PyThreadState* __tstate = wxPyBeginAllowThreads();
29006 wxSetDefaultPyEncoding((char const *)arg1);
29007 wxPyEndAllowThreads(__tstate);
29008 if (PyErr_Occurred()) SWIG_fail;
29009 }
29010 resultobj = SWIG_Py_Void();
29011 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
29012 return resultobj;
29013 fail:
29014 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
29015 return NULL;
29016 }
29017
29018
29019 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29020 PyObject *resultobj = 0;
29021 char *result = 0 ;
29022
29023 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
29024 {
29025 PyThreadState* __tstate = wxPyBeginAllowThreads();
29026 result = (char *)wxGetDefaultPyEncoding();
29027 wxPyEndAllowThreads(__tstate);
29028 if (PyErr_Occurred()) SWIG_fail;
29029 }
29030 resultobj = SWIG_FromCharPtr(result);
29031 return resultobj;
29032 fail:
29033 return NULL;
29034 }
29035
29036
29037 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29038 PyObject *resultobj = 0;
29039 wxEventLoop *result = 0 ;
29040
29041 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
29042 {
29043 PyThreadState* __tstate = wxPyBeginAllowThreads();
29044 result = (wxEventLoop *)new wxEventLoop();
29045 wxPyEndAllowThreads(__tstate);
29046 if (PyErr_Occurred()) SWIG_fail;
29047 }
29048 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
29049 return resultobj;
29050 fail:
29051 return NULL;
29052 }
29053
29054
29055 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29056 PyObject *resultobj = 0;
29057 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29058 void *argp1 = 0 ;
29059 int res1 = 0 ;
29060 PyObject *swig_obj[1] ;
29061
29062 if (!args) SWIG_fail;
29063 swig_obj[0] = args;
29064 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
29065 if (!SWIG_IsOK(res1)) {
29066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29067 }
29068 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29069 {
29070 PyThreadState* __tstate = wxPyBeginAllowThreads();
29071 delete arg1;
29072
29073 wxPyEndAllowThreads(__tstate);
29074 if (PyErr_Occurred()) SWIG_fail;
29075 }
29076 resultobj = SWIG_Py_Void();
29077 return resultobj;
29078 fail:
29079 return NULL;
29080 }
29081
29082
29083 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29084 PyObject *resultobj = 0;
29085 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29086 int result;
29087 void *argp1 = 0 ;
29088 int res1 = 0 ;
29089 PyObject *swig_obj[1] ;
29090
29091 if (!args) SWIG_fail;
29092 swig_obj[0] = args;
29093 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29094 if (!SWIG_IsOK(res1)) {
29095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29096 }
29097 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29098 {
29099 PyThreadState* __tstate = wxPyBeginAllowThreads();
29100 result = (int)(arg1)->Run();
29101 wxPyEndAllowThreads(__tstate);
29102 if (PyErr_Occurred()) SWIG_fail;
29103 }
29104 resultobj = SWIG_From_int(static_cast< int >(result));
29105 return resultobj;
29106 fail:
29107 return NULL;
29108 }
29109
29110
29111 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29112 PyObject *resultobj = 0;
29113 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29114 int arg2 = (int) 0 ;
29115 void *argp1 = 0 ;
29116 int res1 = 0 ;
29117 int val2 ;
29118 int ecode2 = 0 ;
29119 PyObject * obj0 = 0 ;
29120 PyObject * obj1 = 0 ;
29121 char * kwnames[] = {
29122 (char *) "self",(char *) "rc", NULL
29123 };
29124
29125 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
29126 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29127 if (!SWIG_IsOK(res1)) {
29128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29129 }
29130 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29131 if (obj1) {
29132 ecode2 = SWIG_AsVal_int(obj1, &val2);
29133 if (!SWIG_IsOK(ecode2)) {
29134 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
29135 }
29136 arg2 = static_cast< int >(val2);
29137 }
29138 {
29139 PyThreadState* __tstate = wxPyBeginAllowThreads();
29140 (arg1)->Exit(arg2);
29141 wxPyEndAllowThreads(__tstate);
29142 if (PyErr_Occurred()) SWIG_fail;
29143 }
29144 resultobj = SWIG_Py_Void();
29145 return resultobj;
29146 fail:
29147 return NULL;
29148 }
29149
29150
29151 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29152 PyObject *resultobj = 0;
29153 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29154 bool result;
29155 void *argp1 = 0 ;
29156 int res1 = 0 ;
29157 PyObject *swig_obj[1] ;
29158
29159 if (!args) SWIG_fail;
29160 swig_obj[0] = args;
29161 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29162 if (!SWIG_IsOK(res1)) {
29163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
29164 }
29165 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29166 {
29167 PyThreadState* __tstate = wxPyBeginAllowThreads();
29168 result = (bool)((wxEventLoop const *)arg1)->Pending();
29169 wxPyEndAllowThreads(__tstate);
29170 if (PyErr_Occurred()) SWIG_fail;
29171 }
29172 {
29173 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29174 }
29175 return resultobj;
29176 fail:
29177 return NULL;
29178 }
29179
29180
29181 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29182 PyObject *resultobj = 0;
29183 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29184 bool result;
29185 void *argp1 = 0 ;
29186 int res1 = 0 ;
29187 PyObject *swig_obj[1] ;
29188
29189 if (!args) SWIG_fail;
29190 swig_obj[0] = args;
29191 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29192 if (!SWIG_IsOK(res1)) {
29193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29194 }
29195 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29196 {
29197 PyThreadState* __tstate = wxPyBeginAllowThreads();
29198 result = (bool)(arg1)->Dispatch();
29199 wxPyEndAllowThreads(__tstate);
29200 if (PyErr_Occurred()) SWIG_fail;
29201 }
29202 {
29203 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29204 }
29205 return resultobj;
29206 fail:
29207 return NULL;
29208 }
29209
29210
29211 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29212 PyObject *resultobj = 0;
29213 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29214 bool result;
29215 void *argp1 = 0 ;
29216 int res1 = 0 ;
29217 PyObject *swig_obj[1] ;
29218
29219 if (!args) SWIG_fail;
29220 swig_obj[0] = args;
29221 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29222 if (!SWIG_IsOK(res1)) {
29223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
29224 }
29225 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29226 {
29227 PyThreadState* __tstate = wxPyBeginAllowThreads();
29228 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
29229 wxPyEndAllowThreads(__tstate);
29230 if (PyErr_Occurred()) SWIG_fail;
29231 }
29232 {
29233 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29234 }
29235 return resultobj;
29236 fail:
29237 return NULL;
29238 }
29239
29240
29241 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29242 PyObject *resultobj = 0;
29243 wxEventLoop *result = 0 ;
29244
29245 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
29246 {
29247 PyThreadState* __tstate = wxPyBeginAllowThreads();
29248 result = (wxEventLoop *)wxEventLoop::GetActive();
29249 wxPyEndAllowThreads(__tstate);
29250 if (PyErr_Occurred()) SWIG_fail;
29251 }
29252 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
29253 return resultobj;
29254 fail:
29255 return NULL;
29256 }
29257
29258
29259 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29260 PyObject *resultobj = 0;
29261 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29262 void *argp1 = 0 ;
29263 int res1 = 0 ;
29264 PyObject * obj0 = 0 ;
29265 char * kwnames[] = {
29266 (char *) "loop", NULL
29267 };
29268
29269 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
29270 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29271 if (!SWIG_IsOK(res1)) {
29272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29273 }
29274 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29275 {
29276 PyThreadState* __tstate = wxPyBeginAllowThreads();
29277 wxEventLoop::SetActive(arg1);
29278 wxPyEndAllowThreads(__tstate);
29279 if (PyErr_Occurred()) SWIG_fail;
29280 }
29281 resultobj = SWIG_Py_Void();
29282 return resultobj;
29283 fail:
29284 return NULL;
29285 }
29286
29287
29288 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29289 PyObject *obj;
29290 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29291 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
29292 return SWIG_Py_Void();
29293 }
29294
29295 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29296 return SWIG_Python_InitShadowInstance(args);
29297 }
29298
29299 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29300 PyObject *resultobj = 0;
29301 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29302 wxEventLoopActivator *result = 0 ;
29303 void *argp1 = 0 ;
29304 int res1 = 0 ;
29305 PyObject * obj0 = 0 ;
29306 char * kwnames[] = {
29307 (char *) "evtLoop", NULL
29308 };
29309
29310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
29311 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29312 if (!SWIG_IsOK(res1)) {
29313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29314 }
29315 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29316 {
29317 PyThreadState* __tstate = wxPyBeginAllowThreads();
29318 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
29319 wxPyEndAllowThreads(__tstate);
29320 if (PyErr_Occurred()) SWIG_fail;
29321 }
29322 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
29323 return resultobj;
29324 fail:
29325 return NULL;
29326 }
29327
29328
29329 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29330 PyObject *resultobj = 0;
29331 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
29332 void *argp1 = 0 ;
29333 int res1 = 0 ;
29334 PyObject *swig_obj[1] ;
29335
29336 if (!args) SWIG_fail;
29337 swig_obj[0] = args;
29338 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
29339 if (!SWIG_IsOK(res1)) {
29340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
29341 }
29342 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
29343 {
29344 PyThreadState* __tstate = wxPyBeginAllowThreads();
29345 delete arg1;
29346
29347 wxPyEndAllowThreads(__tstate);
29348 if (PyErr_Occurred()) SWIG_fail;
29349 }
29350 resultobj = SWIG_Py_Void();
29351 return resultobj;
29352 fail:
29353 return NULL;
29354 }
29355
29356
29357 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29358 PyObject *obj;
29359 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29360 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
29361 return SWIG_Py_Void();
29362 }
29363
29364 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29365 return SWIG_Python_InitShadowInstance(args);
29366 }
29367
29368 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29369 PyObject *resultobj = 0;
29370 int arg1 = (int) 0 ;
29371 int arg2 = (int) 0 ;
29372 int arg3 = (int) 0 ;
29373 wxAcceleratorEntry *result = 0 ;
29374 int val1 ;
29375 int ecode1 = 0 ;
29376 int val2 ;
29377 int ecode2 = 0 ;
29378 int val3 ;
29379 int ecode3 = 0 ;
29380 PyObject * obj0 = 0 ;
29381 PyObject * obj1 = 0 ;
29382 PyObject * obj2 = 0 ;
29383 char * kwnames[] = {
29384 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
29385 };
29386
29387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29388 if (obj0) {
29389 ecode1 = SWIG_AsVal_int(obj0, &val1);
29390 if (!SWIG_IsOK(ecode1)) {
29391 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
29392 }
29393 arg1 = static_cast< int >(val1);
29394 }
29395 if (obj1) {
29396 ecode2 = SWIG_AsVal_int(obj1, &val2);
29397 if (!SWIG_IsOK(ecode2)) {
29398 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
29399 }
29400 arg2 = static_cast< int >(val2);
29401 }
29402 if (obj2) {
29403 ecode3 = SWIG_AsVal_int(obj2, &val3);
29404 if (!SWIG_IsOK(ecode3)) {
29405 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
29406 }
29407 arg3 = static_cast< int >(val3);
29408 }
29409 {
29410 PyThreadState* __tstate = wxPyBeginAllowThreads();
29411 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
29412 wxPyEndAllowThreads(__tstate);
29413 if (PyErr_Occurred()) SWIG_fail;
29414 }
29415 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
29416 return resultobj;
29417 fail:
29418 return NULL;
29419 }
29420
29421
29422 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29423 PyObject *resultobj = 0;
29424 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29425 void *argp1 = 0 ;
29426 int res1 = 0 ;
29427 PyObject *swig_obj[1] ;
29428
29429 if (!args) SWIG_fail;
29430 swig_obj[0] = args;
29431 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
29432 if (!SWIG_IsOK(res1)) {
29433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29434 }
29435 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29436 {
29437 PyThreadState* __tstate = wxPyBeginAllowThreads();
29438 delete arg1;
29439
29440 wxPyEndAllowThreads(__tstate);
29441 if (PyErr_Occurred()) SWIG_fail;
29442 }
29443 resultobj = SWIG_Py_Void();
29444 return resultobj;
29445 fail:
29446 return NULL;
29447 }
29448
29449
29450 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29451 PyObject *resultobj = 0;
29452 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29453 int arg2 ;
29454 int arg3 ;
29455 int arg4 ;
29456 void *argp1 = 0 ;
29457 int res1 = 0 ;
29458 int val2 ;
29459 int ecode2 = 0 ;
29460 int val3 ;
29461 int ecode3 = 0 ;
29462 int val4 ;
29463 int ecode4 = 0 ;
29464 PyObject * obj0 = 0 ;
29465 PyObject * obj1 = 0 ;
29466 PyObject * obj2 = 0 ;
29467 PyObject * obj3 = 0 ;
29468 char * kwnames[] = {
29469 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
29470 };
29471
29472 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29473 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29474 if (!SWIG_IsOK(res1)) {
29475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29476 }
29477 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29478 ecode2 = SWIG_AsVal_int(obj1, &val2);
29479 if (!SWIG_IsOK(ecode2)) {
29480 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
29481 }
29482 arg2 = static_cast< int >(val2);
29483 ecode3 = SWIG_AsVal_int(obj2, &val3);
29484 if (!SWIG_IsOK(ecode3)) {
29485 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
29486 }
29487 arg3 = static_cast< int >(val3);
29488 ecode4 = SWIG_AsVal_int(obj3, &val4);
29489 if (!SWIG_IsOK(ecode4)) {
29490 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
29491 }
29492 arg4 = static_cast< int >(val4);
29493 {
29494 PyThreadState* __tstate = wxPyBeginAllowThreads();
29495 (arg1)->Set(arg2,arg3,arg4);
29496 wxPyEndAllowThreads(__tstate);
29497 if (PyErr_Occurred()) SWIG_fail;
29498 }
29499 resultobj = SWIG_Py_Void();
29500 return resultobj;
29501 fail:
29502 return NULL;
29503 }
29504
29505
29506 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29507 PyObject *resultobj = 0;
29508 wxString *arg1 = 0 ;
29509 wxAcceleratorEntry *result = 0 ;
29510 bool temp1 = false ;
29511 PyObject * obj0 = 0 ;
29512 char * kwnames[] = {
29513 (char *) "str", NULL
29514 };
29515
29516 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_Create",kwnames,&obj0)) SWIG_fail;
29517 {
29518 arg1 = wxString_in_helper(obj0);
29519 if (arg1 == NULL) SWIG_fail;
29520 temp1 = true;
29521 }
29522 {
29523 PyThreadState* __tstate = wxPyBeginAllowThreads();
29524 result = (wxAcceleratorEntry *)wxAcceleratorEntry::Create((wxString const &)*arg1);
29525 wxPyEndAllowThreads(__tstate);
29526 if (PyErr_Occurred()) SWIG_fail;
29527 }
29528 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_OWN | 0 );
29529 {
29530 if (temp1)
29531 delete arg1;
29532 }
29533 return resultobj;
29534 fail:
29535 {
29536 if (temp1)
29537 delete arg1;
29538 }
29539 return NULL;
29540 }
29541
29542
29543 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29544 PyObject *resultobj = 0;
29545 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29546 int result;
29547 void *argp1 = 0 ;
29548 int res1 = 0 ;
29549 PyObject *swig_obj[1] ;
29550
29551 if (!args) SWIG_fail;
29552 swig_obj[0] = args;
29553 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29554 if (!SWIG_IsOK(res1)) {
29555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29556 }
29557 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29558 {
29559 PyThreadState* __tstate = wxPyBeginAllowThreads();
29560 result = (int)(arg1)->GetFlags();
29561 wxPyEndAllowThreads(__tstate);
29562 if (PyErr_Occurred()) SWIG_fail;
29563 }
29564 resultobj = SWIG_From_int(static_cast< int >(result));
29565 return resultobj;
29566 fail:
29567 return NULL;
29568 }
29569
29570
29571 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29572 PyObject *resultobj = 0;
29573 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29574 int result;
29575 void *argp1 = 0 ;
29576 int res1 = 0 ;
29577 PyObject *swig_obj[1] ;
29578
29579 if (!args) SWIG_fail;
29580 swig_obj[0] = args;
29581 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29582 if (!SWIG_IsOK(res1)) {
29583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29584 }
29585 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29586 {
29587 PyThreadState* __tstate = wxPyBeginAllowThreads();
29588 result = (int)(arg1)->GetKeyCode();
29589 wxPyEndAllowThreads(__tstate);
29590 if (PyErr_Occurred()) SWIG_fail;
29591 }
29592 resultobj = SWIG_From_int(static_cast< int >(result));
29593 return resultobj;
29594 fail:
29595 return NULL;
29596 }
29597
29598
29599 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29600 PyObject *resultobj = 0;
29601 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29602 int result;
29603 void *argp1 = 0 ;
29604 int res1 = 0 ;
29605 PyObject *swig_obj[1] ;
29606
29607 if (!args) SWIG_fail;
29608 swig_obj[0] = args;
29609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29610 if (!SWIG_IsOK(res1)) {
29611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29612 }
29613 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29614 {
29615 PyThreadState* __tstate = wxPyBeginAllowThreads();
29616 result = (int)(arg1)->GetCommand();
29617 wxPyEndAllowThreads(__tstate);
29618 if (PyErr_Occurred()) SWIG_fail;
29619 }
29620 resultobj = SWIG_From_int(static_cast< int >(result));
29621 return resultobj;
29622 fail:
29623 return NULL;
29624 }
29625
29626
29627 SWIGINTERN PyObject *_wrap_AcceleratorEntry_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29628 PyObject *resultobj = 0;
29629 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29630 bool result;
29631 void *argp1 = 0 ;
29632 int res1 = 0 ;
29633 PyObject *swig_obj[1] ;
29634
29635 if (!args) SWIG_fail;
29636 swig_obj[0] = args;
29637 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29638 if (!SWIG_IsOK(res1)) {
29639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
29640 }
29641 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29642 {
29643 PyThreadState* __tstate = wxPyBeginAllowThreads();
29644 result = (bool)((wxAcceleratorEntry const *)arg1)->IsOk();
29645 wxPyEndAllowThreads(__tstate);
29646 if (PyErr_Occurred()) SWIG_fail;
29647 }
29648 {
29649 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29650 }
29651 return resultobj;
29652 fail:
29653 return NULL;
29654 }
29655
29656
29657 SWIGINTERN PyObject *_wrap_AcceleratorEntry_ToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29658 PyObject *resultobj = 0;
29659 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29660 wxString result;
29661 void *argp1 = 0 ;
29662 int res1 = 0 ;
29663 PyObject *swig_obj[1] ;
29664
29665 if (!args) SWIG_fail;
29666 swig_obj[0] = args;
29667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29668 if (!SWIG_IsOK(res1)) {
29669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_ToString" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
29670 }
29671 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29672 {
29673 PyThreadState* __tstate = wxPyBeginAllowThreads();
29674 result = ((wxAcceleratorEntry const *)arg1)->ToString();
29675 wxPyEndAllowThreads(__tstate);
29676 if (PyErr_Occurred()) SWIG_fail;
29677 }
29678 {
29679 #if wxUSE_UNICODE
29680 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29681 #else
29682 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29683 #endif
29684 }
29685 return resultobj;
29686 fail:
29687 return NULL;
29688 }
29689
29690
29691 SWIGINTERN PyObject *_wrap_AcceleratorEntry_FromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29692 PyObject *resultobj = 0;
29693 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29694 wxString *arg2 = 0 ;
29695 bool result;
29696 void *argp1 = 0 ;
29697 int res1 = 0 ;
29698 bool temp2 = false ;
29699 PyObject * obj0 = 0 ;
29700 PyObject * obj1 = 0 ;
29701 char * kwnames[] = {
29702 (char *) "self",(char *) "str", NULL
29703 };
29704
29705 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AcceleratorEntry_FromString",kwnames,&obj0,&obj1)) SWIG_fail;
29706 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29707 if (!SWIG_IsOK(res1)) {
29708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_FromString" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29709 }
29710 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29711 {
29712 arg2 = wxString_in_helper(obj1);
29713 if (arg2 == NULL) SWIG_fail;
29714 temp2 = true;
29715 }
29716 {
29717 PyThreadState* __tstate = wxPyBeginAllowThreads();
29718 result = (bool)(arg1)->FromString((wxString const &)*arg2);
29719 wxPyEndAllowThreads(__tstate);
29720 if (PyErr_Occurred()) SWIG_fail;
29721 }
29722 {
29723 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29724 }
29725 {
29726 if (temp2)
29727 delete arg2;
29728 }
29729 return resultobj;
29730 fail:
29731 {
29732 if (temp2)
29733 delete arg2;
29734 }
29735 return NULL;
29736 }
29737
29738
29739 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29740 PyObject *obj;
29741 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29742 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
29743 return SWIG_Py_Void();
29744 }
29745
29746 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29747 return SWIG_Python_InitShadowInstance(args);
29748 }
29749
29750 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29751 PyObject *resultobj = 0;
29752 int arg1 ;
29753 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
29754 wxAcceleratorTable *result = 0 ;
29755 PyObject * obj0 = 0 ;
29756 char * kwnames[] = {
29757 (char *) "n", NULL
29758 };
29759
29760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
29761 {
29762 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
29763 if (arg2) arg1 = PyList_Size(obj0);
29764 else arg1 = 0;
29765 }
29766 {
29767 PyThreadState* __tstate = wxPyBeginAllowThreads();
29768 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
29769 wxPyEndAllowThreads(__tstate);
29770 if (PyErr_Occurred()) SWIG_fail;
29771 }
29772 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
29773 return resultobj;
29774 fail:
29775 return NULL;
29776 }
29777
29778
29779 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29780 PyObject *resultobj = 0;
29781 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29782 void *argp1 = 0 ;
29783 int res1 = 0 ;
29784 PyObject *swig_obj[1] ;
29785
29786 if (!args) SWIG_fail;
29787 swig_obj[0] = args;
29788 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
29789 if (!SWIG_IsOK(res1)) {
29790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
29791 }
29792 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29793 {
29794 PyThreadState* __tstate = wxPyBeginAllowThreads();
29795 delete arg1;
29796
29797 wxPyEndAllowThreads(__tstate);
29798 if (PyErr_Occurred()) SWIG_fail;
29799 }
29800 resultobj = SWIG_Py_Void();
29801 return resultobj;
29802 fail:
29803 return NULL;
29804 }
29805
29806
29807 SWIGINTERN PyObject *_wrap_AcceleratorTable_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29808 PyObject *resultobj = 0;
29809 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29810 bool result;
29811 void *argp1 = 0 ;
29812 int res1 = 0 ;
29813 PyObject *swig_obj[1] ;
29814
29815 if (!args) SWIG_fail;
29816 swig_obj[0] = args;
29817 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
29818 if (!SWIG_IsOK(res1)) {
29819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_Ok" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
29820 }
29821 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29822 {
29823 PyThreadState* __tstate = wxPyBeginAllowThreads();
29824 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
29825 wxPyEndAllowThreads(__tstate);
29826 if (PyErr_Occurred()) SWIG_fail;
29827 }
29828 {
29829 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29830 }
29831 return resultobj;
29832 fail:
29833 return NULL;
29834 }
29835
29836
29837 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29838 PyObject *obj;
29839 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29840 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
29841 return SWIG_Py_Void();
29842 }
29843
29844 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29845 return SWIG_Python_InitShadowInstance(args);
29846 }
29847
29848 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
29849 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
29850 return 1;
29851 }
29852
29853
29854 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
29855 PyObject *pyobj = 0;
29856
29857 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
29858 return pyobj;
29859 }
29860
29861
29862 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29863 PyObject *resultobj = 0;
29864 wxString *arg1 = 0 ;
29865 wxAcceleratorEntry *result = 0 ;
29866 bool temp1 = false ;
29867 PyObject * obj0 = 0 ;
29868 char * kwnames[] = {
29869 (char *) "label", NULL
29870 };
29871
29872 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
29873 {
29874 arg1 = wxString_in_helper(obj0);
29875 if (arg1 == NULL) SWIG_fail;
29876 temp1 = true;
29877 }
29878 {
29879 PyThreadState* __tstate = wxPyBeginAllowThreads();
29880 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
29881 wxPyEndAllowThreads(__tstate);
29882 if (PyErr_Occurred()) SWIG_fail;
29883 }
29884 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29885 {
29886 if (temp1)
29887 delete arg1;
29888 }
29889 return resultobj;
29890 fail:
29891 {
29892 if (temp1)
29893 delete arg1;
29894 }
29895 return NULL;
29896 }
29897
29898
29899 SWIGINTERN int PanelNameStr_set(PyObject *) {
29900 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
29901 return 1;
29902 }
29903
29904
29905 SWIGINTERN PyObject *PanelNameStr_get(void) {
29906 PyObject *pyobj = 0;
29907
29908 {
29909 #if wxUSE_UNICODE
29910 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29911 #else
29912 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29913 #endif
29914 }
29915 return pyobj;
29916 }
29917
29918
29919 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29920 PyObject *resultobj = 0;
29921 wxVisualAttributes *result = 0 ;
29922
29923 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
29924 {
29925 PyThreadState* __tstate = wxPyBeginAllowThreads();
29926 result = (wxVisualAttributes *)new_wxVisualAttributes();
29927 wxPyEndAllowThreads(__tstate);
29928 if (PyErr_Occurred()) SWIG_fail;
29929 }
29930 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
29931 return resultobj;
29932 fail:
29933 return NULL;
29934 }
29935
29936
29937 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29938 PyObject *resultobj = 0;
29939 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29940 void *argp1 = 0 ;
29941 int res1 = 0 ;
29942 PyObject *swig_obj[1] ;
29943
29944 if (!args) SWIG_fail;
29945 swig_obj[0] = args;
29946 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
29947 if (!SWIG_IsOK(res1)) {
29948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29949 }
29950 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29951 {
29952 PyThreadState* __tstate = wxPyBeginAllowThreads();
29953 delete_wxVisualAttributes(arg1);
29954
29955 wxPyEndAllowThreads(__tstate);
29956 if (PyErr_Occurred()) SWIG_fail;
29957 }
29958 resultobj = SWIG_Py_Void();
29959 return resultobj;
29960 fail:
29961 return NULL;
29962 }
29963
29964
29965 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29966 PyObject *resultobj = 0;
29967 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29968 wxFont *arg2 = (wxFont *) 0 ;
29969 void *argp1 = 0 ;
29970 int res1 = 0 ;
29971 void *argp2 = 0 ;
29972 int res2 = 0 ;
29973 PyObject *swig_obj[2] ;
29974
29975 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
29976 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29977 if (!SWIG_IsOK(res1)) {
29978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29979 }
29980 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29981 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
29982 if (!SWIG_IsOK(res2)) {
29983 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
29984 }
29985 arg2 = reinterpret_cast< wxFont * >(argp2);
29986 if (arg1) (arg1)->font = *arg2;
29987
29988 resultobj = SWIG_Py_Void();
29989 return resultobj;
29990 fail:
29991 return NULL;
29992 }
29993
29994
29995 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29996 PyObject *resultobj = 0;
29997 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29998 wxFont *result = 0 ;
29999 void *argp1 = 0 ;
30000 int res1 = 0 ;
30001 PyObject *swig_obj[1] ;
30002
30003 if (!args) SWIG_fail;
30004 swig_obj[0] = args;
30005 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
30006 if (!SWIG_IsOK(res1)) {
30007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
30008 }
30009 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
30010 result = (wxFont *)& ((arg1)->font);
30011 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
30012 return resultobj;
30013 fail:
30014 return NULL;
30015 }
30016
30017
30018 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30019 PyObject *resultobj = 0;
30020 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
30021 wxColour *arg2 = (wxColour *) 0 ;
30022 void *argp1 = 0 ;
30023 int res1 = 0 ;
30024 void *argp2 = 0 ;
30025 int res2 = 0 ;
30026 PyObject *swig_obj[2] ;
30027
30028 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
30029 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
30030 if (!SWIG_IsOK(res1)) {
30031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
30032 }
30033 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
30034 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
30035 if (!SWIG_IsOK(res2)) {
30036 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
30037 }
30038 arg2 = reinterpret_cast< wxColour * >(argp2);
30039 if (arg1) (arg1)->colFg = *arg2;
30040
30041 resultobj = SWIG_Py_Void();
30042 return resultobj;
30043 fail:
30044 return NULL;
30045 }
30046
30047
30048 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30049 PyObject *resultobj = 0;
30050 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
30051 wxColour *result = 0 ;
30052 void *argp1 = 0 ;
30053 int res1 = 0 ;
30054 PyObject *swig_obj[1] ;
30055
30056 if (!args) SWIG_fail;
30057 swig_obj[0] = args;
30058 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
30059 if (!SWIG_IsOK(res1)) {
30060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
30061 }
30062 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
30063 result = (wxColour *)& ((arg1)->colFg);
30064 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
30065 return resultobj;
30066 fail:
30067 return NULL;
30068 }
30069
30070
30071 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30072 PyObject *resultobj = 0;
30073 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
30074 wxColour *arg2 = (wxColour *) 0 ;
30075 void *argp1 = 0 ;
30076 int res1 = 0 ;
30077 void *argp2 = 0 ;
30078 int res2 = 0 ;
30079 PyObject *swig_obj[2] ;
30080
30081 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
30082 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
30083 if (!SWIG_IsOK(res1)) {
30084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
30085 }
30086 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
30087 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
30088 if (!SWIG_IsOK(res2)) {
30089 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
30090 }
30091 arg2 = reinterpret_cast< wxColour * >(argp2);
30092 if (arg1) (arg1)->colBg = *arg2;
30093
30094 resultobj = SWIG_Py_Void();
30095 return resultobj;
30096 fail:
30097 return NULL;
30098 }
30099
30100
30101 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30102 PyObject *resultobj = 0;
30103 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
30104 wxColour *result = 0 ;
30105 void *argp1 = 0 ;
30106 int res1 = 0 ;
30107 PyObject *swig_obj[1] ;
30108
30109 if (!args) SWIG_fail;
30110 swig_obj[0] = args;
30111 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
30112 if (!SWIG_IsOK(res1)) {
30113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
30114 }
30115 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
30116 result = (wxColour *)& ((arg1)->colBg);
30117 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
30118 return resultobj;
30119 fail:
30120 return NULL;
30121 }
30122
30123
30124 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30125 PyObject *obj;
30126 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30127 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
30128 return SWIG_Py_Void();
30129 }
30130
30131 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30132 return SWIG_Python_InitShadowInstance(args);
30133 }
30134
30135 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30136 PyObject *resultobj = 0;
30137 wxWindow *arg1 = (wxWindow *) 0 ;
30138 int arg2 = (int) (int)-1 ;
30139 wxPoint const &arg3_defvalue = wxDefaultPosition ;
30140 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
30141 wxSize const &arg4_defvalue = wxDefaultSize ;
30142 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
30143 long arg5 = (long) 0 ;
30144 wxString const &arg6_defvalue = wxPyPanelNameStr ;
30145 wxString *arg6 = (wxString *) &arg6_defvalue ;
30146 wxWindow *result = 0 ;
30147 void *argp1 = 0 ;
30148 int res1 = 0 ;
30149 int val2 ;
30150 int ecode2 = 0 ;
30151 wxPoint temp3 ;
30152 wxSize temp4 ;
30153 long val5 ;
30154 int ecode5 = 0 ;
30155 bool temp6 = false ;
30156 PyObject * obj0 = 0 ;
30157 PyObject * obj1 = 0 ;
30158 PyObject * obj2 = 0 ;
30159 PyObject * obj3 = 0 ;
30160 PyObject * obj4 = 0 ;
30161 PyObject * obj5 = 0 ;
30162 char * kwnames[] = {
30163 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
30164 };
30165
30166 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
30167 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30168 if (!SWIG_IsOK(res1)) {
30169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
30170 }
30171 arg1 = reinterpret_cast< wxWindow * >(argp1);
30172 if (obj1) {
30173 ecode2 = SWIG_AsVal_int(obj1, &val2);
30174 if (!SWIG_IsOK(ecode2)) {
30175 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
30176 }
30177 arg2 = static_cast< int >(val2);
30178 }
30179 if (obj2) {
30180 {
30181 arg3 = &temp3;
30182 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
30183 }
30184 }
30185 if (obj3) {
30186 {
30187 arg4 = &temp4;
30188 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
30189 }
30190 }
30191 if (obj4) {
30192 ecode5 = SWIG_AsVal_long(obj4, &val5);
30193 if (!SWIG_IsOK(ecode5)) {
30194 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
30195 }
30196 arg5 = static_cast< long >(val5);
30197 }
30198 if (obj5) {
30199 {
30200 arg6 = wxString_in_helper(obj5);
30201 if (arg6 == NULL) SWIG_fail;
30202 temp6 = true;
30203 }
30204 }
30205 {
30206 if (!wxPyCheckForApp()) SWIG_fail;
30207 PyThreadState* __tstate = wxPyBeginAllowThreads();
30208 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
30209 wxPyEndAllowThreads(__tstate);
30210 if (PyErr_Occurred()) SWIG_fail;
30211 }
30212 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
30213 {
30214 if (temp6)
30215 delete arg6;
30216 }
30217 return resultobj;
30218 fail:
30219 {
30220 if (temp6)
30221 delete arg6;
30222 }
30223 return NULL;
30224 }
30225
30226
30227 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30228 PyObject *resultobj = 0;
30229 wxWindow *result = 0 ;
30230
30231 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
30232 {
30233 if (!wxPyCheckForApp()) SWIG_fail;
30234 PyThreadState* __tstate = wxPyBeginAllowThreads();
30235 result = (wxWindow *)new wxWindow();
30236 wxPyEndAllowThreads(__tstate);
30237 if (PyErr_Occurred()) SWIG_fail;
30238 }
30239 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
30240 return resultobj;
30241 fail:
30242 return NULL;
30243 }
30244
30245
30246 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30247 PyObject *resultobj = 0;
30248 wxWindow *arg1 = (wxWindow *) 0 ;
30249 wxWindow *arg2 = (wxWindow *) 0 ;
30250 int arg3 = (int) (int)-1 ;
30251 wxPoint const &arg4_defvalue = wxDefaultPosition ;
30252 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
30253 wxSize const &arg5_defvalue = wxDefaultSize ;
30254 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
30255 long arg6 = (long) 0 ;
30256 wxString const &arg7_defvalue = wxPyPanelNameStr ;
30257 wxString *arg7 = (wxString *) &arg7_defvalue ;
30258 bool result;
30259 void *argp1 = 0 ;
30260 int res1 = 0 ;
30261 void *argp2 = 0 ;
30262 int res2 = 0 ;
30263 int val3 ;
30264 int ecode3 = 0 ;
30265 wxPoint temp4 ;
30266 wxSize temp5 ;
30267 long val6 ;
30268 int ecode6 = 0 ;
30269 bool temp7 = false ;
30270 PyObject * obj0 = 0 ;
30271 PyObject * obj1 = 0 ;
30272 PyObject * obj2 = 0 ;
30273 PyObject * obj3 = 0 ;
30274 PyObject * obj4 = 0 ;
30275 PyObject * obj5 = 0 ;
30276 PyObject * obj6 = 0 ;
30277 char * kwnames[] = {
30278 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
30279 };
30280
30281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
30282 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30283 if (!SWIG_IsOK(res1)) {
30284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
30285 }
30286 arg1 = reinterpret_cast< wxWindow * >(argp1);
30287 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
30288 if (!SWIG_IsOK(res2)) {
30289 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
30290 }
30291 arg2 = reinterpret_cast< wxWindow * >(argp2);
30292 if (obj2) {
30293 ecode3 = SWIG_AsVal_int(obj2, &val3);
30294 if (!SWIG_IsOK(ecode3)) {
30295 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
30296 }
30297 arg3 = static_cast< int >(val3);
30298 }
30299 if (obj3) {
30300 {
30301 arg4 = &temp4;
30302 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
30303 }
30304 }
30305 if (obj4) {
30306 {
30307 arg5 = &temp5;
30308 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
30309 }
30310 }
30311 if (obj5) {
30312 ecode6 = SWIG_AsVal_long(obj5, &val6);
30313 if (!SWIG_IsOK(ecode6)) {
30314 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
30315 }
30316 arg6 = static_cast< long >(val6);
30317 }
30318 if (obj6) {
30319 {
30320 arg7 = wxString_in_helper(obj6);
30321 if (arg7 == NULL) SWIG_fail;
30322 temp7 = true;
30323 }
30324 }
30325 {
30326 PyThreadState* __tstate = wxPyBeginAllowThreads();
30327 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
30328 wxPyEndAllowThreads(__tstate);
30329 if (PyErr_Occurred()) SWIG_fail;
30330 }
30331 {
30332 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30333 }
30334 {
30335 if (temp7)
30336 delete arg7;
30337 }
30338 return resultobj;
30339 fail:
30340 {
30341 if (temp7)
30342 delete arg7;
30343 }
30344 return NULL;
30345 }
30346
30347
30348 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30349 PyObject *resultobj = 0;
30350 wxWindow *arg1 = (wxWindow *) 0 ;
30351 bool arg2 = (bool) false ;
30352 bool result;
30353 void *argp1 = 0 ;
30354 int res1 = 0 ;
30355 bool val2 ;
30356 int ecode2 = 0 ;
30357 PyObject * obj0 = 0 ;
30358 PyObject * obj1 = 0 ;
30359 char * kwnames[] = {
30360 (char *) "self",(char *) "force", NULL
30361 };
30362
30363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
30364 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30365 if (!SWIG_IsOK(res1)) {
30366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
30367 }
30368 arg1 = reinterpret_cast< wxWindow * >(argp1);
30369 if (obj1) {
30370 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30371 if (!SWIG_IsOK(ecode2)) {
30372 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
30373 }
30374 arg2 = static_cast< bool >(val2);
30375 }
30376 {
30377 PyThreadState* __tstate = wxPyBeginAllowThreads();
30378 result = (bool)(arg1)->Close(arg2);
30379 wxPyEndAllowThreads(__tstate);
30380 if (PyErr_Occurred()) SWIG_fail;
30381 }
30382 {
30383 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30384 }
30385 return resultobj;
30386 fail:
30387 return NULL;
30388 }
30389
30390
30391 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30392 PyObject *resultobj = 0;
30393 wxWindow *arg1 = (wxWindow *) 0 ;
30394 bool result;
30395 void *argp1 = 0 ;
30396 int res1 = 0 ;
30397 PyObject *swig_obj[1] ;
30398
30399 if (!args) SWIG_fail;
30400 swig_obj[0] = args;
30401 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30402 if (!SWIG_IsOK(res1)) {
30403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
30404 }
30405 arg1 = reinterpret_cast< wxWindow * >(argp1);
30406 {
30407 PyThreadState* __tstate = wxPyBeginAllowThreads();
30408 result = (bool)(arg1)->Destroy();
30409 wxPyEndAllowThreads(__tstate);
30410 if (PyErr_Occurred()) SWIG_fail;
30411 }
30412 {
30413 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30414 }
30415 return resultobj;
30416 fail:
30417 return NULL;
30418 }
30419
30420
30421 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30422 PyObject *resultobj = 0;
30423 wxWindow *arg1 = (wxWindow *) 0 ;
30424 bool result;
30425 void *argp1 = 0 ;
30426 int res1 = 0 ;
30427 PyObject *swig_obj[1] ;
30428
30429 if (!args) SWIG_fail;
30430 swig_obj[0] = args;
30431 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30432 if (!SWIG_IsOK(res1)) {
30433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
30434 }
30435 arg1 = reinterpret_cast< wxWindow * >(argp1);
30436 {
30437 PyThreadState* __tstate = wxPyBeginAllowThreads();
30438 result = (bool)(arg1)->DestroyChildren();
30439 wxPyEndAllowThreads(__tstate);
30440 if (PyErr_Occurred()) SWIG_fail;
30441 }
30442 {
30443 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30444 }
30445 return resultobj;
30446 fail:
30447 return NULL;
30448 }
30449
30450
30451 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30452 PyObject *resultobj = 0;
30453 wxWindow *arg1 = (wxWindow *) 0 ;
30454 bool result;
30455 void *argp1 = 0 ;
30456 int res1 = 0 ;
30457 PyObject *swig_obj[1] ;
30458
30459 if (!args) SWIG_fail;
30460 swig_obj[0] = args;
30461 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30462 if (!SWIG_IsOK(res1)) {
30463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
30464 }
30465 arg1 = reinterpret_cast< wxWindow * >(argp1);
30466 {
30467 PyThreadState* __tstate = wxPyBeginAllowThreads();
30468 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
30469 wxPyEndAllowThreads(__tstate);
30470 if (PyErr_Occurred()) SWIG_fail;
30471 }
30472 {
30473 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30474 }
30475 return resultobj;
30476 fail:
30477 return NULL;
30478 }
30479
30480
30481 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30482 PyObject *resultobj = 0;
30483 wxWindow *arg1 = (wxWindow *) 0 ;
30484 wxString *arg2 = 0 ;
30485 void *argp1 = 0 ;
30486 int res1 = 0 ;
30487 bool temp2 = false ;
30488 PyObject * obj0 = 0 ;
30489 PyObject * obj1 = 0 ;
30490 char * kwnames[] = {
30491 (char *) "self",(char *) "label", NULL
30492 };
30493
30494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",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_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
30498 }
30499 arg1 = reinterpret_cast< wxWindow * >(argp1);
30500 {
30501 arg2 = wxString_in_helper(obj1);
30502 if (arg2 == NULL) SWIG_fail;
30503 temp2 = true;
30504 }
30505 {
30506 PyThreadState* __tstate = wxPyBeginAllowThreads();
30507 (arg1)->SetLabel((wxString const &)*arg2);
30508 wxPyEndAllowThreads(__tstate);
30509 if (PyErr_Occurred()) SWIG_fail;
30510 }
30511 resultobj = SWIG_Py_Void();
30512 {
30513 if (temp2)
30514 delete arg2;
30515 }
30516 return resultobj;
30517 fail:
30518 {
30519 if (temp2)
30520 delete arg2;
30521 }
30522 return NULL;
30523 }
30524
30525
30526 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30527 PyObject *resultobj = 0;
30528 wxWindow *arg1 = (wxWindow *) 0 ;
30529 wxString result;
30530 void *argp1 = 0 ;
30531 int res1 = 0 ;
30532 PyObject *swig_obj[1] ;
30533
30534 if (!args) SWIG_fail;
30535 swig_obj[0] = args;
30536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30537 if (!SWIG_IsOK(res1)) {
30538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
30539 }
30540 arg1 = reinterpret_cast< wxWindow * >(argp1);
30541 {
30542 PyThreadState* __tstate = wxPyBeginAllowThreads();
30543 result = ((wxWindow const *)arg1)->GetLabel();
30544 wxPyEndAllowThreads(__tstate);
30545 if (PyErr_Occurred()) SWIG_fail;
30546 }
30547 {
30548 #if wxUSE_UNICODE
30549 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30550 #else
30551 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30552 #endif
30553 }
30554 return resultobj;
30555 fail:
30556 return NULL;
30557 }
30558
30559
30560 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30561 PyObject *resultobj = 0;
30562 wxWindow *arg1 = (wxWindow *) 0 ;
30563 wxString *arg2 = 0 ;
30564 void *argp1 = 0 ;
30565 int res1 = 0 ;
30566 bool temp2 = false ;
30567 PyObject * obj0 = 0 ;
30568 PyObject * obj1 = 0 ;
30569 char * kwnames[] = {
30570 (char *) "self",(char *) "name", NULL
30571 };
30572
30573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
30574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30575 if (!SWIG_IsOK(res1)) {
30576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
30577 }
30578 arg1 = reinterpret_cast< wxWindow * >(argp1);
30579 {
30580 arg2 = wxString_in_helper(obj1);
30581 if (arg2 == NULL) SWIG_fail;
30582 temp2 = true;
30583 }
30584 {
30585 PyThreadState* __tstate = wxPyBeginAllowThreads();
30586 (arg1)->SetName((wxString const &)*arg2);
30587 wxPyEndAllowThreads(__tstate);
30588 if (PyErr_Occurred()) SWIG_fail;
30589 }
30590 resultobj = SWIG_Py_Void();
30591 {
30592 if (temp2)
30593 delete arg2;
30594 }
30595 return resultobj;
30596 fail:
30597 {
30598 if (temp2)
30599 delete arg2;
30600 }
30601 return NULL;
30602 }
30603
30604
30605 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30606 PyObject *resultobj = 0;
30607 wxWindow *arg1 = (wxWindow *) 0 ;
30608 wxString result;
30609 void *argp1 = 0 ;
30610 int res1 = 0 ;
30611 PyObject *swig_obj[1] ;
30612
30613 if (!args) SWIG_fail;
30614 swig_obj[0] = args;
30615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30616 if (!SWIG_IsOK(res1)) {
30617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
30618 }
30619 arg1 = reinterpret_cast< wxWindow * >(argp1);
30620 {
30621 PyThreadState* __tstate = wxPyBeginAllowThreads();
30622 result = ((wxWindow const *)arg1)->GetName();
30623 wxPyEndAllowThreads(__tstate);
30624 if (PyErr_Occurred()) SWIG_fail;
30625 }
30626 {
30627 #if wxUSE_UNICODE
30628 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30629 #else
30630 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30631 #endif
30632 }
30633 return resultobj;
30634 fail:
30635 return NULL;
30636 }
30637
30638
30639 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30640 PyObject *resultobj = 0;
30641 wxWindow *arg1 = (wxWindow *) 0 ;
30642 wxWindowVariant arg2 ;
30643 void *argp1 = 0 ;
30644 int res1 = 0 ;
30645 int val2 ;
30646 int ecode2 = 0 ;
30647 PyObject * obj0 = 0 ;
30648 PyObject * obj1 = 0 ;
30649 char * kwnames[] = {
30650 (char *) "self",(char *) "variant", NULL
30651 };
30652
30653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
30654 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30655 if (!SWIG_IsOK(res1)) {
30656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
30657 }
30658 arg1 = reinterpret_cast< wxWindow * >(argp1);
30659 ecode2 = SWIG_AsVal_int(obj1, &val2);
30660 if (!SWIG_IsOK(ecode2)) {
30661 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
30662 }
30663 arg2 = static_cast< wxWindowVariant >(val2);
30664 {
30665 PyThreadState* __tstate = wxPyBeginAllowThreads();
30666 (arg1)->SetWindowVariant(arg2);
30667 wxPyEndAllowThreads(__tstate);
30668 if (PyErr_Occurred()) SWIG_fail;
30669 }
30670 resultobj = SWIG_Py_Void();
30671 return resultobj;
30672 fail:
30673 return NULL;
30674 }
30675
30676
30677 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30678 PyObject *resultobj = 0;
30679 wxWindow *arg1 = (wxWindow *) 0 ;
30680 wxWindowVariant result;
30681 void *argp1 = 0 ;
30682 int res1 = 0 ;
30683 PyObject *swig_obj[1] ;
30684
30685 if (!args) SWIG_fail;
30686 swig_obj[0] = args;
30687 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30688 if (!SWIG_IsOK(res1)) {
30689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
30690 }
30691 arg1 = reinterpret_cast< wxWindow * >(argp1);
30692 {
30693 PyThreadState* __tstate = wxPyBeginAllowThreads();
30694 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
30695 wxPyEndAllowThreads(__tstate);
30696 if (PyErr_Occurred()) SWIG_fail;
30697 }
30698 resultobj = SWIG_From_int(static_cast< int >(result));
30699 return resultobj;
30700 fail:
30701 return NULL;
30702 }
30703
30704
30705 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30706 PyObject *resultobj = 0;
30707 wxWindow *arg1 = (wxWindow *) 0 ;
30708 int arg2 ;
30709 void *argp1 = 0 ;
30710 int res1 = 0 ;
30711 int val2 ;
30712 int ecode2 = 0 ;
30713 PyObject * obj0 = 0 ;
30714 PyObject * obj1 = 0 ;
30715 char * kwnames[] = {
30716 (char *) "self",(char *) "winid", NULL
30717 };
30718
30719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
30720 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30721 if (!SWIG_IsOK(res1)) {
30722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
30723 }
30724 arg1 = reinterpret_cast< wxWindow * >(argp1);
30725 ecode2 = SWIG_AsVal_int(obj1, &val2);
30726 if (!SWIG_IsOK(ecode2)) {
30727 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
30728 }
30729 arg2 = static_cast< int >(val2);
30730 {
30731 PyThreadState* __tstate = wxPyBeginAllowThreads();
30732 (arg1)->SetId(arg2);
30733 wxPyEndAllowThreads(__tstate);
30734 if (PyErr_Occurred()) SWIG_fail;
30735 }
30736 resultobj = SWIG_Py_Void();
30737 return resultobj;
30738 fail:
30739 return NULL;
30740 }
30741
30742
30743 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30744 PyObject *resultobj = 0;
30745 wxWindow *arg1 = (wxWindow *) 0 ;
30746 int result;
30747 void *argp1 = 0 ;
30748 int res1 = 0 ;
30749 PyObject *swig_obj[1] ;
30750
30751 if (!args) SWIG_fail;
30752 swig_obj[0] = args;
30753 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30754 if (!SWIG_IsOK(res1)) {
30755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
30756 }
30757 arg1 = reinterpret_cast< wxWindow * >(argp1);
30758 {
30759 PyThreadState* __tstate = wxPyBeginAllowThreads();
30760 result = (int)((wxWindow const *)arg1)->GetId();
30761 wxPyEndAllowThreads(__tstate);
30762 if (PyErr_Occurred()) SWIG_fail;
30763 }
30764 resultobj = SWIG_From_int(static_cast< int >(result));
30765 return resultobj;
30766 fail:
30767 return NULL;
30768 }
30769
30770
30771 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30772 PyObject *resultobj = 0;
30773 int result;
30774
30775 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
30776 {
30777 PyThreadState* __tstate = wxPyBeginAllowThreads();
30778 result = (int)wxWindow::NewControlId();
30779 wxPyEndAllowThreads(__tstate);
30780 if (PyErr_Occurred()) SWIG_fail;
30781 }
30782 resultobj = SWIG_From_int(static_cast< int >(result));
30783 return resultobj;
30784 fail:
30785 return NULL;
30786 }
30787
30788
30789 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30790 PyObject *resultobj = 0;
30791 int arg1 ;
30792 int result;
30793 int val1 ;
30794 int ecode1 = 0 ;
30795 PyObject * obj0 = 0 ;
30796 char * kwnames[] = {
30797 (char *) "winid", NULL
30798 };
30799
30800 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
30801 ecode1 = SWIG_AsVal_int(obj0, &val1);
30802 if (!SWIG_IsOK(ecode1)) {
30803 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
30804 }
30805 arg1 = static_cast< int >(val1);
30806 {
30807 PyThreadState* __tstate = wxPyBeginAllowThreads();
30808 result = (int)wxWindow::NextControlId(arg1);
30809 wxPyEndAllowThreads(__tstate);
30810 if (PyErr_Occurred()) SWIG_fail;
30811 }
30812 resultobj = SWIG_From_int(static_cast< int >(result));
30813 return resultobj;
30814 fail:
30815 return NULL;
30816 }
30817
30818
30819 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30820 PyObject *resultobj = 0;
30821 int arg1 ;
30822 int result;
30823 int val1 ;
30824 int ecode1 = 0 ;
30825 PyObject * obj0 = 0 ;
30826 char * kwnames[] = {
30827 (char *) "winid", NULL
30828 };
30829
30830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
30831 ecode1 = SWIG_AsVal_int(obj0, &val1);
30832 if (!SWIG_IsOK(ecode1)) {
30833 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
30834 }
30835 arg1 = static_cast< int >(val1);
30836 {
30837 PyThreadState* __tstate = wxPyBeginAllowThreads();
30838 result = (int)wxWindow::PrevControlId(arg1);
30839 wxPyEndAllowThreads(__tstate);
30840 if (PyErr_Occurred()) SWIG_fail;
30841 }
30842 resultobj = SWIG_From_int(static_cast< int >(result));
30843 return resultobj;
30844 fail:
30845 return NULL;
30846 }
30847
30848
30849 SWIGINTERN PyObject *_wrap_Window_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30850 PyObject *resultobj = 0;
30851 wxWindow *arg1 = (wxWindow *) 0 ;
30852 wxLayoutDirection result;
30853 void *argp1 = 0 ;
30854 int res1 = 0 ;
30855 PyObject *swig_obj[1] ;
30856
30857 if (!args) SWIG_fail;
30858 swig_obj[0] = args;
30859 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30860 if (!SWIG_IsOK(res1)) {
30861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
30862 }
30863 arg1 = reinterpret_cast< wxWindow * >(argp1);
30864 {
30865 PyThreadState* __tstate = wxPyBeginAllowThreads();
30866 result = (wxLayoutDirection)((wxWindow const *)arg1)->GetLayoutDirection();
30867 wxPyEndAllowThreads(__tstate);
30868 if (PyErr_Occurred()) SWIG_fail;
30869 }
30870 resultobj = SWIG_From_int(static_cast< int >(result));
30871 return resultobj;
30872 fail:
30873 return NULL;
30874 }
30875
30876
30877 SWIGINTERN PyObject *_wrap_Window_SetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30878 PyObject *resultobj = 0;
30879 wxWindow *arg1 = (wxWindow *) 0 ;
30880 wxLayoutDirection arg2 ;
30881 void *argp1 = 0 ;
30882 int res1 = 0 ;
30883 int val2 ;
30884 int ecode2 = 0 ;
30885 PyObject * obj0 = 0 ;
30886 PyObject * obj1 = 0 ;
30887 char * kwnames[] = {
30888 (char *) "self",(char *) "dir", NULL
30889 };
30890
30891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLayoutDirection",kwnames,&obj0,&obj1)) SWIG_fail;
30892 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30893 if (!SWIG_IsOK(res1)) {
30894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow *""'");
30895 }
30896 arg1 = reinterpret_cast< wxWindow * >(argp1);
30897 ecode2 = SWIG_AsVal_int(obj1, &val2);
30898 if (!SWIG_IsOK(ecode2)) {
30899 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetLayoutDirection" "', expected argument " "2"" of type '" "wxLayoutDirection""'");
30900 }
30901 arg2 = static_cast< wxLayoutDirection >(val2);
30902 {
30903 PyThreadState* __tstate = wxPyBeginAllowThreads();
30904 (arg1)->SetLayoutDirection(arg2);
30905 wxPyEndAllowThreads(__tstate);
30906 if (PyErr_Occurred()) SWIG_fail;
30907 }
30908 resultobj = SWIG_Py_Void();
30909 return resultobj;
30910 fail:
30911 return NULL;
30912 }
30913
30914
30915 SWIGINTERN PyObject *_wrap_Window_AdjustForLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30916 PyObject *resultobj = 0;
30917 wxWindow *arg1 = (wxWindow *) 0 ;
30918 int arg2 ;
30919 int arg3 ;
30920 int arg4 ;
30921 int result;
30922 void *argp1 = 0 ;
30923 int res1 = 0 ;
30924 int val2 ;
30925 int ecode2 = 0 ;
30926 int val3 ;
30927 int ecode3 = 0 ;
30928 int val4 ;
30929 int ecode4 = 0 ;
30930 PyObject * obj0 = 0 ;
30931 PyObject * obj1 = 0 ;
30932 PyObject * obj2 = 0 ;
30933 PyObject * obj3 = 0 ;
30934 char * kwnames[] = {
30935 (char *) "self",(char *) "x",(char *) "width",(char *) "widthTotal", NULL
30936 };
30937
30938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_AdjustForLayoutDirection",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30939 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30940 if (!SWIG_IsOK(res1)) {
30941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
30942 }
30943 arg1 = reinterpret_cast< wxWindow * >(argp1);
30944 ecode2 = SWIG_AsVal_int(obj1, &val2);
30945 if (!SWIG_IsOK(ecode2)) {
30946 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "2"" of type '" "int""'");
30947 }
30948 arg2 = static_cast< int >(val2);
30949 ecode3 = SWIG_AsVal_int(obj2, &val3);
30950 if (!SWIG_IsOK(ecode3)) {
30951 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "3"" of type '" "int""'");
30952 }
30953 arg3 = static_cast< int >(val3);
30954 ecode4 = SWIG_AsVal_int(obj3, &val4);
30955 if (!SWIG_IsOK(ecode4)) {
30956 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "4"" of type '" "int""'");
30957 }
30958 arg4 = static_cast< int >(val4);
30959 {
30960 PyThreadState* __tstate = wxPyBeginAllowThreads();
30961 result = (int)((wxWindow const *)arg1)->AdjustForLayoutDirection(arg2,arg3,arg4);
30962 wxPyEndAllowThreads(__tstate);
30963 if (PyErr_Occurred()) SWIG_fail;
30964 }
30965 resultobj = SWIG_From_int(static_cast< int >(result));
30966 return resultobj;
30967 fail:
30968 return NULL;
30969 }
30970
30971
30972 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30973 PyObject *resultobj = 0;
30974 wxWindow *arg1 = (wxWindow *) 0 ;
30975 wxSize *arg2 = 0 ;
30976 void *argp1 = 0 ;
30977 int res1 = 0 ;
30978 wxSize temp2 ;
30979 PyObject * obj0 = 0 ;
30980 PyObject * obj1 = 0 ;
30981 char * kwnames[] = {
30982 (char *) "self",(char *) "size", NULL
30983 };
30984
30985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
30986 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30987 if (!SWIG_IsOK(res1)) {
30988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30989 }
30990 arg1 = reinterpret_cast< wxWindow * >(argp1);
30991 {
30992 arg2 = &temp2;
30993 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30994 }
30995 {
30996 PyThreadState* __tstate = wxPyBeginAllowThreads();
30997 (arg1)->SetSize((wxSize const &)*arg2);
30998 wxPyEndAllowThreads(__tstate);
30999 if (PyErr_Occurred()) SWIG_fail;
31000 }
31001 resultobj = SWIG_Py_Void();
31002 return resultobj;
31003 fail:
31004 return NULL;
31005 }
31006
31007
31008 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31009 PyObject *resultobj = 0;
31010 wxWindow *arg1 = (wxWindow *) 0 ;
31011 int arg2 ;
31012 int arg3 ;
31013 int arg4 ;
31014 int arg5 ;
31015 int arg6 = (int) wxSIZE_AUTO ;
31016 void *argp1 = 0 ;
31017 int res1 = 0 ;
31018 int val2 ;
31019 int ecode2 = 0 ;
31020 int val3 ;
31021 int ecode3 = 0 ;
31022 int val4 ;
31023 int ecode4 = 0 ;
31024 int val5 ;
31025 int ecode5 = 0 ;
31026 int val6 ;
31027 int ecode6 = 0 ;
31028 PyObject * obj0 = 0 ;
31029 PyObject * obj1 = 0 ;
31030 PyObject * obj2 = 0 ;
31031 PyObject * obj3 = 0 ;
31032 PyObject * obj4 = 0 ;
31033 PyObject * obj5 = 0 ;
31034 char * kwnames[] = {
31035 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
31036 };
31037
31038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
31039 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31040 if (!SWIG_IsOK(res1)) {
31041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
31042 }
31043 arg1 = reinterpret_cast< wxWindow * >(argp1);
31044 ecode2 = SWIG_AsVal_int(obj1, &val2);
31045 if (!SWIG_IsOK(ecode2)) {
31046 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
31047 }
31048 arg2 = static_cast< int >(val2);
31049 ecode3 = SWIG_AsVal_int(obj2, &val3);
31050 if (!SWIG_IsOK(ecode3)) {
31051 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
31052 }
31053 arg3 = static_cast< int >(val3);
31054 ecode4 = SWIG_AsVal_int(obj3, &val4);
31055 if (!SWIG_IsOK(ecode4)) {
31056 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
31057 }
31058 arg4 = static_cast< int >(val4);
31059 ecode5 = SWIG_AsVal_int(obj4, &val5);
31060 if (!SWIG_IsOK(ecode5)) {
31061 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
31062 }
31063 arg5 = static_cast< int >(val5);
31064 if (obj5) {
31065 ecode6 = SWIG_AsVal_int(obj5, &val6);
31066 if (!SWIG_IsOK(ecode6)) {
31067 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
31068 }
31069 arg6 = static_cast< int >(val6);
31070 }
31071 {
31072 PyThreadState* __tstate = wxPyBeginAllowThreads();
31073 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
31074 wxPyEndAllowThreads(__tstate);
31075 if (PyErr_Occurred()) SWIG_fail;
31076 }
31077 resultobj = SWIG_Py_Void();
31078 return resultobj;
31079 fail:
31080 return NULL;
31081 }
31082
31083
31084 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31085 PyObject *resultobj = 0;
31086 wxWindow *arg1 = (wxWindow *) 0 ;
31087 wxRect *arg2 = 0 ;
31088 int arg3 = (int) wxSIZE_AUTO ;
31089 void *argp1 = 0 ;
31090 int res1 = 0 ;
31091 wxRect temp2 ;
31092 int val3 ;
31093 int ecode3 = 0 ;
31094 PyObject * obj0 = 0 ;
31095 PyObject * obj1 = 0 ;
31096 PyObject * obj2 = 0 ;
31097 char * kwnames[] = {
31098 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
31099 };
31100
31101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31102 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31103 if (!SWIG_IsOK(res1)) {
31104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
31105 }
31106 arg1 = reinterpret_cast< wxWindow * >(argp1);
31107 {
31108 arg2 = &temp2;
31109 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
31110 }
31111 if (obj2) {
31112 ecode3 = SWIG_AsVal_int(obj2, &val3);
31113 if (!SWIG_IsOK(ecode3)) {
31114 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
31115 }
31116 arg3 = static_cast< int >(val3);
31117 }
31118 {
31119 PyThreadState* __tstate = wxPyBeginAllowThreads();
31120 (arg1)->SetSize((wxRect const &)*arg2,arg3);
31121 wxPyEndAllowThreads(__tstate);
31122 if (PyErr_Occurred()) SWIG_fail;
31123 }
31124 resultobj = SWIG_Py_Void();
31125 return resultobj;
31126 fail:
31127 return NULL;
31128 }
31129
31130
31131 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31132 PyObject *resultobj = 0;
31133 wxWindow *arg1 = (wxWindow *) 0 ;
31134 int arg2 ;
31135 int arg3 ;
31136 void *argp1 = 0 ;
31137 int res1 = 0 ;
31138 int val2 ;
31139 int ecode2 = 0 ;
31140 int val3 ;
31141 int ecode3 = 0 ;
31142 PyObject * obj0 = 0 ;
31143 PyObject * obj1 = 0 ;
31144 PyObject * obj2 = 0 ;
31145 char * kwnames[] = {
31146 (char *) "self",(char *) "width",(char *) "height", NULL
31147 };
31148
31149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31150 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31151 if (!SWIG_IsOK(res1)) {
31152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
31153 }
31154 arg1 = reinterpret_cast< wxWindow * >(argp1);
31155 ecode2 = SWIG_AsVal_int(obj1, &val2);
31156 if (!SWIG_IsOK(ecode2)) {
31157 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
31158 }
31159 arg2 = static_cast< int >(val2);
31160 ecode3 = SWIG_AsVal_int(obj2, &val3);
31161 if (!SWIG_IsOK(ecode3)) {
31162 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
31163 }
31164 arg3 = static_cast< int >(val3);
31165 {
31166 PyThreadState* __tstate = wxPyBeginAllowThreads();
31167 (arg1)->SetSize(arg2,arg3);
31168 wxPyEndAllowThreads(__tstate);
31169 if (PyErr_Occurred()) SWIG_fail;
31170 }
31171 resultobj = SWIG_Py_Void();
31172 return resultobj;
31173 fail:
31174 return NULL;
31175 }
31176
31177
31178 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31179 PyObject *resultobj = 0;
31180 wxWindow *arg1 = (wxWindow *) 0 ;
31181 wxPoint *arg2 = 0 ;
31182 int arg3 = (int) wxSIZE_USE_EXISTING ;
31183 void *argp1 = 0 ;
31184 int res1 = 0 ;
31185 wxPoint temp2 ;
31186 int val3 ;
31187 int ecode3 = 0 ;
31188 PyObject * obj0 = 0 ;
31189 PyObject * obj1 = 0 ;
31190 PyObject * obj2 = 0 ;
31191 char * kwnames[] = {
31192 (char *) "self",(char *) "pt",(char *) "flags", NULL
31193 };
31194
31195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31196 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31197 if (!SWIG_IsOK(res1)) {
31198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
31199 }
31200 arg1 = reinterpret_cast< wxWindow * >(argp1);
31201 {
31202 arg2 = &temp2;
31203 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
31204 }
31205 if (obj2) {
31206 ecode3 = SWIG_AsVal_int(obj2, &val3);
31207 if (!SWIG_IsOK(ecode3)) {
31208 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
31209 }
31210 arg3 = static_cast< int >(val3);
31211 }
31212 {
31213 PyThreadState* __tstate = wxPyBeginAllowThreads();
31214 (arg1)->Move((wxPoint const &)*arg2,arg3);
31215 wxPyEndAllowThreads(__tstate);
31216 if (PyErr_Occurred()) SWIG_fail;
31217 }
31218 resultobj = SWIG_Py_Void();
31219 return resultobj;
31220 fail:
31221 return NULL;
31222 }
31223
31224
31225 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31226 PyObject *resultobj = 0;
31227 wxWindow *arg1 = (wxWindow *) 0 ;
31228 int arg2 ;
31229 int arg3 ;
31230 int arg4 = (int) wxSIZE_USE_EXISTING ;
31231 void *argp1 = 0 ;
31232 int res1 = 0 ;
31233 int val2 ;
31234 int ecode2 = 0 ;
31235 int val3 ;
31236 int ecode3 = 0 ;
31237 int val4 ;
31238 int ecode4 = 0 ;
31239 PyObject * obj0 = 0 ;
31240 PyObject * obj1 = 0 ;
31241 PyObject * obj2 = 0 ;
31242 PyObject * obj3 = 0 ;
31243 char * kwnames[] = {
31244 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
31245 };
31246
31247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
31248 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31249 if (!SWIG_IsOK(res1)) {
31250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
31251 }
31252 arg1 = reinterpret_cast< wxWindow * >(argp1);
31253 ecode2 = SWIG_AsVal_int(obj1, &val2);
31254 if (!SWIG_IsOK(ecode2)) {
31255 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
31256 }
31257 arg2 = static_cast< int >(val2);
31258 ecode3 = SWIG_AsVal_int(obj2, &val3);
31259 if (!SWIG_IsOK(ecode3)) {
31260 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
31261 }
31262 arg3 = static_cast< int >(val3);
31263 if (obj3) {
31264 ecode4 = SWIG_AsVal_int(obj3, &val4);
31265 if (!SWIG_IsOK(ecode4)) {
31266 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
31267 }
31268 arg4 = static_cast< int >(val4);
31269 }
31270 {
31271 PyThreadState* __tstate = wxPyBeginAllowThreads();
31272 (arg1)->Move(arg2,arg3,arg4);
31273 wxPyEndAllowThreads(__tstate);
31274 if (PyErr_Occurred()) SWIG_fail;
31275 }
31276 resultobj = SWIG_Py_Void();
31277 return resultobj;
31278 fail:
31279 return NULL;
31280 }
31281
31282
31283 SWIGINTERN PyObject *_wrap_Window_SetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31284 PyObject *resultobj = 0;
31285 wxWindow *arg1 = (wxWindow *) 0 ;
31286 wxSize const &arg2_defvalue = wxDefaultSize ;
31287 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
31288 void *argp1 = 0 ;
31289 int res1 = 0 ;
31290 wxSize temp2 ;
31291 PyObject * obj0 = 0 ;
31292 PyObject * obj1 = 0 ;
31293 char * kwnames[] = {
31294 (char *) "self",(char *) "size", NULL
31295 };
31296
31297 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) SWIG_fail;
31298 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31299 if (!SWIG_IsOK(res1)) {
31300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31301 }
31302 arg1 = reinterpret_cast< wxWindow * >(argp1);
31303 if (obj1) {
31304 {
31305 arg2 = &temp2;
31306 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31307 }
31308 }
31309 {
31310 PyThreadState* __tstate = wxPyBeginAllowThreads();
31311 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
31312 wxPyEndAllowThreads(__tstate);
31313 if (PyErr_Occurred()) SWIG_fail;
31314 }
31315 resultobj = SWIG_Py_Void();
31316 return resultobj;
31317 fail:
31318 return NULL;
31319 }
31320
31321
31322 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31323 PyObject *resultobj = 0;
31324 wxWindow *arg1 = (wxWindow *) 0 ;
31325 void *argp1 = 0 ;
31326 int res1 = 0 ;
31327 PyObject *swig_obj[1] ;
31328
31329 if (!args) SWIG_fail;
31330 swig_obj[0] = args;
31331 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31332 if (!SWIG_IsOK(res1)) {
31333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
31334 }
31335 arg1 = reinterpret_cast< wxWindow * >(argp1);
31336 {
31337 PyThreadState* __tstate = wxPyBeginAllowThreads();
31338 (arg1)->Raise();
31339 wxPyEndAllowThreads(__tstate);
31340 if (PyErr_Occurred()) SWIG_fail;
31341 }
31342 resultobj = SWIG_Py_Void();
31343 return resultobj;
31344 fail:
31345 return NULL;
31346 }
31347
31348
31349 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31350 PyObject *resultobj = 0;
31351 wxWindow *arg1 = (wxWindow *) 0 ;
31352 void *argp1 = 0 ;
31353 int res1 = 0 ;
31354 PyObject *swig_obj[1] ;
31355
31356 if (!args) SWIG_fail;
31357 swig_obj[0] = args;
31358 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31359 if (!SWIG_IsOK(res1)) {
31360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
31361 }
31362 arg1 = reinterpret_cast< wxWindow * >(argp1);
31363 {
31364 PyThreadState* __tstate = wxPyBeginAllowThreads();
31365 (arg1)->Lower();
31366 wxPyEndAllowThreads(__tstate);
31367 if (PyErr_Occurred()) SWIG_fail;
31368 }
31369 resultobj = SWIG_Py_Void();
31370 return resultobj;
31371 fail:
31372 return NULL;
31373 }
31374
31375
31376 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31377 PyObject *resultobj = 0;
31378 wxWindow *arg1 = (wxWindow *) 0 ;
31379 wxSize *arg2 = 0 ;
31380 void *argp1 = 0 ;
31381 int res1 = 0 ;
31382 wxSize temp2 ;
31383 PyObject * obj0 = 0 ;
31384 PyObject * obj1 = 0 ;
31385 char * kwnames[] = {
31386 (char *) "self",(char *) "size", NULL
31387 };
31388
31389 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
31390 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31391 if (!SWIG_IsOK(res1)) {
31392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31393 }
31394 arg1 = reinterpret_cast< wxWindow * >(argp1);
31395 {
31396 arg2 = &temp2;
31397 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31398 }
31399 {
31400 PyThreadState* __tstate = wxPyBeginAllowThreads();
31401 (arg1)->SetClientSize((wxSize const &)*arg2);
31402 wxPyEndAllowThreads(__tstate);
31403 if (PyErr_Occurred()) SWIG_fail;
31404 }
31405 resultobj = SWIG_Py_Void();
31406 return resultobj;
31407 fail:
31408 return NULL;
31409 }
31410
31411
31412 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31413 PyObject *resultobj = 0;
31414 wxWindow *arg1 = (wxWindow *) 0 ;
31415 int arg2 ;
31416 int arg3 ;
31417 void *argp1 = 0 ;
31418 int res1 = 0 ;
31419 int val2 ;
31420 int ecode2 = 0 ;
31421 int val3 ;
31422 int ecode3 = 0 ;
31423 PyObject * obj0 = 0 ;
31424 PyObject * obj1 = 0 ;
31425 PyObject * obj2 = 0 ;
31426 char * kwnames[] = {
31427 (char *) "self",(char *) "width",(char *) "height", NULL
31428 };
31429
31430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31431 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31432 if (!SWIG_IsOK(res1)) {
31433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
31434 }
31435 arg1 = reinterpret_cast< wxWindow * >(argp1);
31436 ecode2 = SWIG_AsVal_int(obj1, &val2);
31437 if (!SWIG_IsOK(ecode2)) {
31438 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
31439 }
31440 arg2 = static_cast< int >(val2);
31441 ecode3 = SWIG_AsVal_int(obj2, &val3);
31442 if (!SWIG_IsOK(ecode3)) {
31443 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
31444 }
31445 arg3 = static_cast< int >(val3);
31446 {
31447 PyThreadState* __tstate = wxPyBeginAllowThreads();
31448 (arg1)->SetClientSize(arg2,arg3);
31449 wxPyEndAllowThreads(__tstate);
31450 if (PyErr_Occurred()) SWIG_fail;
31451 }
31452 resultobj = SWIG_Py_Void();
31453 return resultobj;
31454 fail:
31455 return NULL;
31456 }
31457
31458
31459 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31460 PyObject *resultobj = 0;
31461 wxWindow *arg1 = (wxWindow *) 0 ;
31462 wxRect *arg2 = 0 ;
31463 void *argp1 = 0 ;
31464 int res1 = 0 ;
31465 wxRect temp2 ;
31466 PyObject * obj0 = 0 ;
31467 PyObject * obj1 = 0 ;
31468 char * kwnames[] = {
31469 (char *) "self",(char *) "rect", NULL
31470 };
31471
31472 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
31473 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31474 if (!SWIG_IsOK(res1)) {
31475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
31476 }
31477 arg1 = reinterpret_cast< wxWindow * >(argp1);
31478 {
31479 arg2 = &temp2;
31480 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
31481 }
31482 {
31483 PyThreadState* __tstate = wxPyBeginAllowThreads();
31484 (arg1)->SetClientSize((wxRect const &)*arg2);
31485 wxPyEndAllowThreads(__tstate);
31486 if (PyErr_Occurred()) SWIG_fail;
31487 }
31488 resultobj = SWIG_Py_Void();
31489 return resultobj;
31490 fail:
31491 return NULL;
31492 }
31493
31494
31495 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31496 PyObject *resultobj = 0;
31497 wxWindow *arg1 = (wxWindow *) 0 ;
31498 wxPoint result;
31499 void *argp1 = 0 ;
31500 int res1 = 0 ;
31501 PyObject *swig_obj[1] ;
31502
31503 if (!args) SWIG_fail;
31504 swig_obj[0] = args;
31505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31506 if (!SWIG_IsOK(res1)) {
31507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
31508 }
31509 arg1 = reinterpret_cast< wxWindow * >(argp1);
31510 {
31511 PyThreadState* __tstate = wxPyBeginAllowThreads();
31512 result = ((wxWindow const *)arg1)->GetPosition();
31513 wxPyEndAllowThreads(__tstate);
31514 if (PyErr_Occurred()) SWIG_fail;
31515 }
31516 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31517 return resultobj;
31518 fail:
31519 return NULL;
31520 }
31521
31522
31523 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31524 PyObject *resultobj = 0;
31525 wxWindow *arg1 = (wxWindow *) 0 ;
31526 int *arg2 = (int *) 0 ;
31527 int *arg3 = (int *) 0 ;
31528 void *argp1 = 0 ;
31529 int res1 = 0 ;
31530 int temp2 ;
31531 int res2 = SWIG_TMPOBJ ;
31532 int temp3 ;
31533 int res3 = SWIG_TMPOBJ ;
31534 PyObject *swig_obj[1] ;
31535
31536 arg2 = &temp2;
31537 arg3 = &temp3;
31538 if (!args) SWIG_fail;
31539 swig_obj[0] = args;
31540 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31541 if (!SWIG_IsOK(res1)) {
31542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31543 }
31544 arg1 = reinterpret_cast< wxWindow * >(argp1);
31545 {
31546 PyThreadState* __tstate = wxPyBeginAllowThreads();
31547 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
31548 wxPyEndAllowThreads(__tstate);
31549 if (PyErr_Occurred()) SWIG_fail;
31550 }
31551 resultobj = SWIG_Py_Void();
31552 if (SWIG_IsTmpObj(res2)) {
31553 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31554 } else {
31555 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31556 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31557 }
31558 if (SWIG_IsTmpObj(res3)) {
31559 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31560 } else {
31561 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31562 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31563 }
31564 return resultobj;
31565 fail:
31566 return NULL;
31567 }
31568
31569
31570 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31571 PyObject *resultobj = 0;
31572 wxWindow *arg1 = (wxWindow *) 0 ;
31573 wxPoint result;
31574 void *argp1 = 0 ;
31575 int res1 = 0 ;
31576 PyObject *swig_obj[1] ;
31577
31578 if (!args) SWIG_fail;
31579 swig_obj[0] = args;
31580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31581 if (!SWIG_IsOK(res1)) {
31582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
31583 }
31584 arg1 = reinterpret_cast< wxWindow * >(argp1);
31585 {
31586 PyThreadState* __tstate = wxPyBeginAllowThreads();
31587 result = ((wxWindow const *)arg1)->GetScreenPosition();
31588 wxPyEndAllowThreads(__tstate);
31589 if (PyErr_Occurred()) SWIG_fail;
31590 }
31591 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31592 return resultobj;
31593 fail:
31594 return NULL;
31595 }
31596
31597
31598 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31599 PyObject *resultobj = 0;
31600 wxWindow *arg1 = (wxWindow *) 0 ;
31601 int *arg2 = (int *) 0 ;
31602 int *arg3 = (int *) 0 ;
31603 void *argp1 = 0 ;
31604 int res1 = 0 ;
31605 int temp2 ;
31606 int res2 = SWIG_TMPOBJ ;
31607 int temp3 ;
31608 int res3 = SWIG_TMPOBJ ;
31609 PyObject *swig_obj[1] ;
31610
31611 arg2 = &temp2;
31612 arg3 = &temp3;
31613 if (!args) SWIG_fail;
31614 swig_obj[0] = args;
31615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31616 if (!SWIG_IsOK(res1)) {
31617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31618 }
31619 arg1 = reinterpret_cast< wxWindow * >(argp1);
31620 {
31621 PyThreadState* __tstate = wxPyBeginAllowThreads();
31622 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
31623 wxPyEndAllowThreads(__tstate);
31624 if (PyErr_Occurred()) SWIG_fail;
31625 }
31626 resultobj = SWIG_Py_Void();
31627 if (SWIG_IsTmpObj(res2)) {
31628 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31629 } else {
31630 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31631 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31632 }
31633 if (SWIG_IsTmpObj(res3)) {
31634 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31635 } else {
31636 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31637 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31638 }
31639 return resultobj;
31640 fail:
31641 return NULL;
31642 }
31643
31644
31645 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31646 PyObject *resultobj = 0;
31647 wxWindow *arg1 = (wxWindow *) 0 ;
31648 wxRect result;
31649 void *argp1 = 0 ;
31650 int res1 = 0 ;
31651 PyObject *swig_obj[1] ;
31652
31653 if (!args) SWIG_fail;
31654 swig_obj[0] = args;
31655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31656 if (!SWIG_IsOK(res1)) {
31657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31658 }
31659 arg1 = reinterpret_cast< wxWindow * >(argp1);
31660 {
31661 PyThreadState* __tstate = wxPyBeginAllowThreads();
31662 result = ((wxWindow const *)arg1)->GetScreenRect();
31663 wxPyEndAllowThreads(__tstate);
31664 if (PyErr_Occurred()) SWIG_fail;
31665 }
31666 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31667 return resultobj;
31668 fail:
31669 return NULL;
31670 }
31671
31672
31673 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31674 PyObject *resultobj = 0;
31675 wxWindow *arg1 = (wxWindow *) 0 ;
31676 wxSize result;
31677 void *argp1 = 0 ;
31678 int res1 = 0 ;
31679 PyObject *swig_obj[1] ;
31680
31681 if (!args) SWIG_fail;
31682 swig_obj[0] = args;
31683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31684 if (!SWIG_IsOK(res1)) {
31685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31686 }
31687 arg1 = reinterpret_cast< wxWindow * >(argp1);
31688 {
31689 PyThreadState* __tstate = wxPyBeginAllowThreads();
31690 result = ((wxWindow const *)arg1)->GetSize();
31691 wxPyEndAllowThreads(__tstate);
31692 if (PyErr_Occurred()) SWIG_fail;
31693 }
31694 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31695 return resultobj;
31696 fail:
31697 return NULL;
31698 }
31699
31700
31701 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31702 PyObject *resultobj = 0;
31703 wxWindow *arg1 = (wxWindow *) 0 ;
31704 int *arg2 = (int *) 0 ;
31705 int *arg3 = (int *) 0 ;
31706 void *argp1 = 0 ;
31707 int res1 = 0 ;
31708 int temp2 ;
31709 int res2 = SWIG_TMPOBJ ;
31710 int temp3 ;
31711 int res3 = SWIG_TMPOBJ ;
31712 PyObject *swig_obj[1] ;
31713
31714 arg2 = &temp2;
31715 arg3 = &temp3;
31716 if (!args) SWIG_fail;
31717 swig_obj[0] = args;
31718 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31719 if (!SWIG_IsOK(res1)) {
31720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31721 }
31722 arg1 = reinterpret_cast< wxWindow * >(argp1);
31723 {
31724 PyThreadState* __tstate = wxPyBeginAllowThreads();
31725 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
31726 wxPyEndAllowThreads(__tstate);
31727 if (PyErr_Occurred()) SWIG_fail;
31728 }
31729 resultobj = SWIG_Py_Void();
31730 if (SWIG_IsTmpObj(res2)) {
31731 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31732 } else {
31733 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31734 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31735 }
31736 if (SWIG_IsTmpObj(res3)) {
31737 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31738 } else {
31739 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31740 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31741 }
31742 return resultobj;
31743 fail:
31744 return NULL;
31745 }
31746
31747
31748 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31749 PyObject *resultobj = 0;
31750 wxWindow *arg1 = (wxWindow *) 0 ;
31751 wxRect result;
31752 void *argp1 = 0 ;
31753 int res1 = 0 ;
31754 PyObject *swig_obj[1] ;
31755
31756 if (!args) SWIG_fail;
31757 swig_obj[0] = args;
31758 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31759 if (!SWIG_IsOK(res1)) {
31760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31761 }
31762 arg1 = reinterpret_cast< wxWindow * >(argp1);
31763 {
31764 PyThreadState* __tstate = wxPyBeginAllowThreads();
31765 result = ((wxWindow const *)arg1)->GetRect();
31766 wxPyEndAllowThreads(__tstate);
31767 if (PyErr_Occurred()) SWIG_fail;
31768 }
31769 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31770 return resultobj;
31771 fail:
31772 return NULL;
31773 }
31774
31775
31776 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31777 PyObject *resultobj = 0;
31778 wxWindow *arg1 = (wxWindow *) 0 ;
31779 wxSize result;
31780 void *argp1 = 0 ;
31781 int res1 = 0 ;
31782 PyObject *swig_obj[1] ;
31783
31784 if (!args) SWIG_fail;
31785 swig_obj[0] = args;
31786 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31787 if (!SWIG_IsOK(res1)) {
31788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31789 }
31790 arg1 = reinterpret_cast< wxWindow * >(argp1);
31791 {
31792 PyThreadState* __tstate = wxPyBeginAllowThreads();
31793 result = ((wxWindow const *)arg1)->GetClientSize();
31794 wxPyEndAllowThreads(__tstate);
31795 if (PyErr_Occurred()) SWIG_fail;
31796 }
31797 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31798 return resultobj;
31799 fail:
31800 return NULL;
31801 }
31802
31803
31804 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31805 PyObject *resultobj = 0;
31806 wxWindow *arg1 = (wxWindow *) 0 ;
31807 int *arg2 = (int *) 0 ;
31808 int *arg3 = (int *) 0 ;
31809 void *argp1 = 0 ;
31810 int res1 = 0 ;
31811 int temp2 ;
31812 int res2 = SWIG_TMPOBJ ;
31813 int temp3 ;
31814 int res3 = SWIG_TMPOBJ ;
31815 PyObject *swig_obj[1] ;
31816
31817 arg2 = &temp2;
31818 arg3 = &temp3;
31819 if (!args) SWIG_fail;
31820 swig_obj[0] = args;
31821 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31822 if (!SWIG_IsOK(res1)) {
31823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31824 }
31825 arg1 = reinterpret_cast< wxWindow * >(argp1);
31826 {
31827 PyThreadState* __tstate = wxPyBeginAllowThreads();
31828 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
31829 wxPyEndAllowThreads(__tstate);
31830 if (PyErr_Occurred()) SWIG_fail;
31831 }
31832 resultobj = SWIG_Py_Void();
31833 if (SWIG_IsTmpObj(res2)) {
31834 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31835 } else {
31836 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31837 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31838 }
31839 if (SWIG_IsTmpObj(res3)) {
31840 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31841 } else {
31842 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31843 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31844 }
31845 return resultobj;
31846 fail:
31847 return NULL;
31848 }
31849
31850
31851 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31852 PyObject *resultobj = 0;
31853 wxWindow *arg1 = (wxWindow *) 0 ;
31854 wxPoint result;
31855 void *argp1 = 0 ;
31856 int res1 = 0 ;
31857 PyObject *swig_obj[1] ;
31858
31859 if (!args) SWIG_fail;
31860 swig_obj[0] = args;
31861 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31862 if (!SWIG_IsOK(res1)) {
31863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
31864 }
31865 arg1 = reinterpret_cast< wxWindow * >(argp1);
31866 {
31867 PyThreadState* __tstate = wxPyBeginAllowThreads();
31868 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
31869 wxPyEndAllowThreads(__tstate);
31870 if (PyErr_Occurred()) SWIG_fail;
31871 }
31872 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31873 return resultobj;
31874 fail:
31875 return NULL;
31876 }
31877
31878
31879 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31880 PyObject *resultobj = 0;
31881 wxWindow *arg1 = (wxWindow *) 0 ;
31882 wxRect result;
31883 void *argp1 = 0 ;
31884 int res1 = 0 ;
31885 PyObject *swig_obj[1] ;
31886
31887 if (!args) SWIG_fail;
31888 swig_obj[0] = args;
31889 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31890 if (!SWIG_IsOK(res1)) {
31891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31892 }
31893 arg1 = reinterpret_cast< wxWindow * >(argp1);
31894 {
31895 PyThreadState* __tstate = wxPyBeginAllowThreads();
31896 result = ((wxWindow const *)arg1)->GetClientRect();
31897 wxPyEndAllowThreads(__tstate);
31898 if (PyErr_Occurred()) SWIG_fail;
31899 }
31900 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31901 return resultobj;
31902 fail:
31903 return NULL;
31904 }
31905
31906
31907 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31908 PyObject *resultobj = 0;
31909 wxWindow *arg1 = (wxWindow *) 0 ;
31910 wxSize result;
31911 void *argp1 = 0 ;
31912 int res1 = 0 ;
31913 PyObject *swig_obj[1] ;
31914
31915 if (!args) SWIG_fail;
31916 swig_obj[0] = args;
31917 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31918 if (!SWIG_IsOK(res1)) {
31919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31920 }
31921 arg1 = reinterpret_cast< wxWindow * >(argp1);
31922 {
31923 PyThreadState* __tstate = wxPyBeginAllowThreads();
31924 result = ((wxWindow const *)arg1)->GetBestSize();
31925 wxPyEndAllowThreads(__tstate);
31926 if (PyErr_Occurred()) SWIG_fail;
31927 }
31928 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31929 return resultobj;
31930 fail:
31931 return NULL;
31932 }
31933
31934
31935 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31936 PyObject *resultobj = 0;
31937 wxWindow *arg1 = (wxWindow *) 0 ;
31938 int *arg2 = (int *) 0 ;
31939 int *arg3 = (int *) 0 ;
31940 void *argp1 = 0 ;
31941 int res1 = 0 ;
31942 int temp2 ;
31943 int res2 = SWIG_TMPOBJ ;
31944 int temp3 ;
31945 int res3 = SWIG_TMPOBJ ;
31946 PyObject *swig_obj[1] ;
31947
31948 arg2 = &temp2;
31949 arg3 = &temp3;
31950 if (!args) SWIG_fail;
31951 swig_obj[0] = args;
31952 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31953 if (!SWIG_IsOK(res1)) {
31954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31955 }
31956 arg1 = reinterpret_cast< wxWindow * >(argp1);
31957 {
31958 PyThreadState* __tstate = wxPyBeginAllowThreads();
31959 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
31960 wxPyEndAllowThreads(__tstate);
31961 if (PyErr_Occurred()) SWIG_fail;
31962 }
31963 resultobj = SWIG_Py_Void();
31964 if (SWIG_IsTmpObj(res2)) {
31965 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31966 } else {
31967 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31968 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31969 }
31970 if (SWIG_IsTmpObj(res3)) {
31971 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31972 } else {
31973 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31974 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31975 }
31976 return resultobj;
31977 fail:
31978 return NULL;
31979 }
31980
31981
31982 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31983 PyObject *resultobj = 0;
31984 wxWindow *arg1 = (wxWindow *) 0 ;
31985 void *argp1 = 0 ;
31986 int res1 = 0 ;
31987 PyObject *swig_obj[1] ;
31988
31989 if (!args) SWIG_fail;
31990 swig_obj[0] = args;
31991 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31992 if (!SWIG_IsOK(res1)) {
31993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31994 }
31995 arg1 = reinterpret_cast< wxWindow * >(argp1);
31996 {
31997 PyThreadState* __tstate = wxPyBeginAllowThreads();
31998 (arg1)->InvalidateBestSize();
31999 wxPyEndAllowThreads(__tstate);
32000 if (PyErr_Occurred()) SWIG_fail;
32001 }
32002 resultobj = SWIG_Py_Void();
32003 return resultobj;
32004 fail:
32005 return NULL;
32006 }
32007
32008
32009 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32010 PyObject *resultobj = 0;
32011 wxWindow *arg1 = (wxWindow *) 0 ;
32012 wxSize *arg2 = 0 ;
32013 void *argp1 = 0 ;
32014 int res1 = 0 ;
32015 wxSize temp2 ;
32016 PyObject * obj0 = 0 ;
32017 PyObject * obj1 = 0 ;
32018 char * kwnames[] = {
32019 (char *) "self",(char *) "size", NULL
32020 };
32021
32022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
32023 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32024 if (!SWIG_IsOK(res1)) {
32025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32026 }
32027 arg1 = reinterpret_cast< wxWindow * >(argp1);
32028 {
32029 arg2 = &temp2;
32030 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32031 }
32032 {
32033 PyThreadState* __tstate = wxPyBeginAllowThreads();
32034 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
32035 wxPyEndAllowThreads(__tstate);
32036 if (PyErr_Occurred()) SWIG_fail;
32037 }
32038 resultobj = SWIG_Py_Void();
32039 return resultobj;
32040 fail:
32041 return NULL;
32042 }
32043
32044
32045 SWIGINTERN PyObject *_wrap_Window_GetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32046 PyObject *resultobj = 0;
32047 wxWindow *arg1 = (wxWindow *) 0 ;
32048 wxSize result;
32049 void *argp1 = 0 ;
32050 int res1 = 0 ;
32051 PyObject *swig_obj[1] ;
32052
32053 if (!args) SWIG_fail;
32054 swig_obj[0] = args;
32055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32056 if (!SWIG_IsOK(res1)) {
32057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32058 }
32059 arg1 = reinterpret_cast< wxWindow * >(argp1);
32060 {
32061 PyThreadState* __tstate = wxPyBeginAllowThreads();
32062 result = ((wxWindow const *)arg1)->GetBestFittingSize();
32063 wxPyEndAllowThreads(__tstate);
32064 if (PyErr_Occurred()) SWIG_fail;
32065 }
32066 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32067 return resultobj;
32068 fail:
32069 return NULL;
32070 }
32071
32072
32073 SWIGINTERN PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32074 PyObject *resultobj = 0;
32075 wxWindow *arg1 = (wxWindow *) 0 ;
32076 wxSize result;
32077 void *argp1 = 0 ;
32078 int res1 = 0 ;
32079 PyObject *swig_obj[1] ;
32080
32081 if (!args) SWIG_fail;
32082 swig_obj[0] = args;
32083 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32084 if (!SWIG_IsOK(res1)) {
32085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAdjustedBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32086 }
32087 arg1 = reinterpret_cast< wxWindow * >(argp1);
32088 {
32089 PyThreadState* __tstate = wxPyBeginAllowThreads();
32090 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
32091 wxPyEndAllowThreads(__tstate);
32092 if (PyErr_Occurred()) SWIG_fail;
32093 }
32094 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32095 return resultobj;
32096 fail:
32097 return NULL;
32098 }
32099
32100
32101 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32102 PyObject *resultobj = 0;
32103 wxWindow *arg1 = (wxWindow *) 0 ;
32104 int arg2 = (int) wxBOTH ;
32105 void *argp1 = 0 ;
32106 int res1 = 0 ;
32107 int val2 ;
32108 int ecode2 = 0 ;
32109 PyObject * obj0 = 0 ;
32110 PyObject * obj1 = 0 ;
32111 char * kwnames[] = {
32112 (char *) "self",(char *) "direction", NULL
32113 };
32114
32115 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
32116 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32117 if (!SWIG_IsOK(res1)) {
32118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
32119 }
32120 arg1 = reinterpret_cast< wxWindow * >(argp1);
32121 if (obj1) {
32122 ecode2 = SWIG_AsVal_int(obj1, &val2);
32123 if (!SWIG_IsOK(ecode2)) {
32124 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
32125 }
32126 arg2 = static_cast< int >(val2);
32127 }
32128 {
32129 PyThreadState* __tstate = wxPyBeginAllowThreads();
32130 (arg1)->Center(arg2);
32131 wxPyEndAllowThreads(__tstate);
32132 if (PyErr_Occurred()) SWIG_fail;
32133 }
32134 resultobj = SWIG_Py_Void();
32135 return resultobj;
32136 fail:
32137 return NULL;
32138 }
32139
32140
32141 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32142 PyObject *resultobj = 0;
32143 wxWindow *arg1 = (wxWindow *) 0 ;
32144 int arg2 = (int) wxBOTH ;
32145 void *argp1 = 0 ;
32146 int res1 = 0 ;
32147 int val2 ;
32148 int ecode2 = 0 ;
32149 PyObject * obj0 = 0 ;
32150 PyObject * obj1 = 0 ;
32151 char * kwnames[] = {
32152 (char *) "self",(char *) "dir", NULL
32153 };
32154
32155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
32156 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32157 if (!SWIG_IsOK(res1)) {
32158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
32159 }
32160 arg1 = reinterpret_cast< wxWindow * >(argp1);
32161 if (obj1) {
32162 ecode2 = SWIG_AsVal_int(obj1, &val2);
32163 if (!SWIG_IsOK(ecode2)) {
32164 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
32165 }
32166 arg2 = static_cast< int >(val2);
32167 }
32168 {
32169 PyThreadState* __tstate = wxPyBeginAllowThreads();
32170 (arg1)->CenterOnParent(arg2);
32171 wxPyEndAllowThreads(__tstate);
32172 if (PyErr_Occurred()) SWIG_fail;
32173 }
32174 resultobj = SWIG_Py_Void();
32175 return resultobj;
32176 fail:
32177 return NULL;
32178 }
32179
32180
32181 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32182 PyObject *resultobj = 0;
32183 wxWindow *arg1 = (wxWindow *) 0 ;
32184 void *argp1 = 0 ;
32185 int res1 = 0 ;
32186 PyObject *swig_obj[1] ;
32187
32188 if (!args) SWIG_fail;
32189 swig_obj[0] = args;
32190 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32191 if (!SWIG_IsOK(res1)) {
32192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
32193 }
32194 arg1 = reinterpret_cast< wxWindow * >(argp1);
32195 {
32196 PyThreadState* __tstate = wxPyBeginAllowThreads();
32197 (arg1)->Fit();
32198 wxPyEndAllowThreads(__tstate);
32199 if (PyErr_Occurred()) SWIG_fail;
32200 }
32201 resultobj = SWIG_Py_Void();
32202 return resultobj;
32203 fail:
32204 return NULL;
32205 }
32206
32207
32208 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32209 PyObject *resultobj = 0;
32210 wxWindow *arg1 = (wxWindow *) 0 ;
32211 void *argp1 = 0 ;
32212 int res1 = 0 ;
32213 PyObject *swig_obj[1] ;
32214
32215 if (!args) SWIG_fail;
32216 swig_obj[0] = args;
32217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32218 if (!SWIG_IsOK(res1)) {
32219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
32220 }
32221 arg1 = reinterpret_cast< wxWindow * >(argp1);
32222 {
32223 PyThreadState* __tstate = wxPyBeginAllowThreads();
32224 (arg1)->FitInside();
32225 wxPyEndAllowThreads(__tstate);
32226 if (PyErr_Occurred()) SWIG_fail;
32227 }
32228 resultobj = SWIG_Py_Void();
32229 return resultobj;
32230 fail:
32231 return NULL;
32232 }
32233
32234
32235 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32236 PyObject *resultobj = 0;
32237 wxWindow *arg1 = (wxWindow *) 0 ;
32238 int arg2 ;
32239 int arg3 ;
32240 int arg4 = (int) -1 ;
32241 int arg5 = (int) -1 ;
32242 int arg6 = (int) -1 ;
32243 int arg7 = (int) -1 ;
32244 void *argp1 = 0 ;
32245 int res1 = 0 ;
32246 int val2 ;
32247 int ecode2 = 0 ;
32248 int val3 ;
32249 int ecode3 = 0 ;
32250 int val4 ;
32251 int ecode4 = 0 ;
32252 int val5 ;
32253 int ecode5 = 0 ;
32254 int val6 ;
32255 int ecode6 = 0 ;
32256 int val7 ;
32257 int ecode7 = 0 ;
32258 PyObject * obj0 = 0 ;
32259 PyObject * obj1 = 0 ;
32260 PyObject * obj2 = 0 ;
32261 PyObject * obj3 = 0 ;
32262 PyObject * obj4 = 0 ;
32263 PyObject * obj5 = 0 ;
32264 PyObject * obj6 = 0 ;
32265 char * kwnames[] = {
32266 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
32267 };
32268
32269 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
32270 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32271 if (!SWIG_IsOK(res1)) {
32272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
32273 }
32274 arg1 = reinterpret_cast< wxWindow * >(argp1);
32275 ecode2 = SWIG_AsVal_int(obj1, &val2);
32276 if (!SWIG_IsOK(ecode2)) {
32277 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
32278 }
32279 arg2 = static_cast< int >(val2);
32280 ecode3 = SWIG_AsVal_int(obj2, &val3);
32281 if (!SWIG_IsOK(ecode3)) {
32282 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
32283 }
32284 arg3 = static_cast< int >(val3);
32285 if (obj3) {
32286 ecode4 = SWIG_AsVal_int(obj3, &val4);
32287 if (!SWIG_IsOK(ecode4)) {
32288 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
32289 }
32290 arg4 = static_cast< int >(val4);
32291 }
32292 if (obj4) {
32293 ecode5 = SWIG_AsVal_int(obj4, &val5);
32294 if (!SWIG_IsOK(ecode5)) {
32295 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
32296 }
32297 arg5 = static_cast< int >(val5);
32298 }
32299 if (obj5) {
32300 ecode6 = SWIG_AsVal_int(obj5, &val6);
32301 if (!SWIG_IsOK(ecode6)) {
32302 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
32303 }
32304 arg6 = static_cast< int >(val6);
32305 }
32306 if (obj6) {
32307 ecode7 = SWIG_AsVal_int(obj6, &val7);
32308 if (!SWIG_IsOK(ecode7)) {
32309 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
32310 }
32311 arg7 = static_cast< int >(val7);
32312 }
32313 {
32314 PyThreadState* __tstate = wxPyBeginAllowThreads();
32315 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
32316 wxPyEndAllowThreads(__tstate);
32317 if (PyErr_Occurred()) SWIG_fail;
32318 }
32319 resultobj = SWIG_Py_Void();
32320 return resultobj;
32321 fail:
32322 return NULL;
32323 }
32324
32325
32326 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32327 PyObject *resultobj = 0;
32328 wxWindow *arg1 = (wxWindow *) 0 ;
32329 wxSize *arg2 = 0 ;
32330 wxSize const &arg3_defvalue = wxDefaultSize ;
32331 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
32332 wxSize const &arg4_defvalue = wxDefaultSize ;
32333 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
32334 void *argp1 = 0 ;
32335 int res1 = 0 ;
32336 wxSize temp2 ;
32337 wxSize temp3 ;
32338 wxSize temp4 ;
32339 PyObject * obj0 = 0 ;
32340 PyObject * obj1 = 0 ;
32341 PyObject * obj2 = 0 ;
32342 PyObject * obj3 = 0 ;
32343 char * kwnames[] = {
32344 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
32345 };
32346
32347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32348 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32349 if (!SWIG_IsOK(res1)) {
32350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
32351 }
32352 arg1 = reinterpret_cast< wxWindow * >(argp1);
32353 {
32354 arg2 = &temp2;
32355 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32356 }
32357 if (obj2) {
32358 {
32359 arg3 = &temp3;
32360 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
32361 }
32362 }
32363 if (obj3) {
32364 {
32365 arg4 = &temp4;
32366 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
32367 }
32368 }
32369 {
32370 PyThreadState* __tstate = wxPyBeginAllowThreads();
32371 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
32372 wxPyEndAllowThreads(__tstate);
32373 if (PyErr_Occurred()) SWIG_fail;
32374 }
32375 resultobj = SWIG_Py_Void();
32376 return resultobj;
32377 fail:
32378 return NULL;
32379 }
32380
32381
32382 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32383 PyObject *resultobj = 0;
32384 wxWindow *arg1 = (wxWindow *) 0 ;
32385 int arg2 ;
32386 int arg3 ;
32387 int arg4 = (int) -1 ;
32388 int arg5 = (int) -1 ;
32389 void *argp1 = 0 ;
32390 int res1 = 0 ;
32391 int val2 ;
32392 int ecode2 = 0 ;
32393 int val3 ;
32394 int ecode3 = 0 ;
32395 int val4 ;
32396 int ecode4 = 0 ;
32397 int val5 ;
32398 int ecode5 = 0 ;
32399 PyObject * obj0 = 0 ;
32400 PyObject * obj1 = 0 ;
32401 PyObject * obj2 = 0 ;
32402 PyObject * obj3 = 0 ;
32403 PyObject * obj4 = 0 ;
32404 char * kwnames[] = {
32405 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
32406 };
32407
32408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
32409 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32410 if (!SWIG_IsOK(res1)) {
32411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
32412 }
32413 arg1 = reinterpret_cast< wxWindow * >(argp1);
32414 ecode2 = SWIG_AsVal_int(obj1, &val2);
32415 if (!SWIG_IsOK(ecode2)) {
32416 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
32417 }
32418 arg2 = static_cast< int >(val2);
32419 ecode3 = SWIG_AsVal_int(obj2, &val3);
32420 if (!SWIG_IsOK(ecode3)) {
32421 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
32422 }
32423 arg3 = static_cast< int >(val3);
32424 if (obj3) {
32425 ecode4 = SWIG_AsVal_int(obj3, &val4);
32426 if (!SWIG_IsOK(ecode4)) {
32427 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
32428 }
32429 arg4 = static_cast< int >(val4);
32430 }
32431 if (obj4) {
32432 ecode5 = SWIG_AsVal_int(obj4, &val5);
32433 if (!SWIG_IsOK(ecode5)) {
32434 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
32435 }
32436 arg5 = static_cast< int >(val5);
32437 }
32438 {
32439 PyThreadState* __tstate = wxPyBeginAllowThreads();
32440 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
32441 wxPyEndAllowThreads(__tstate);
32442 if (PyErr_Occurred()) SWIG_fail;
32443 }
32444 resultobj = SWIG_Py_Void();
32445 return resultobj;
32446 fail:
32447 return NULL;
32448 }
32449
32450
32451 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32452 PyObject *resultobj = 0;
32453 wxWindow *arg1 = (wxWindow *) 0 ;
32454 wxSize *arg2 = 0 ;
32455 wxSize const &arg3_defvalue = wxDefaultSize ;
32456 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
32457 void *argp1 = 0 ;
32458 int res1 = 0 ;
32459 wxSize temp2 ;
32460 wxSize temp3 ;
32461 PyObject * obj0 = 0 ;
32462 PyObject * obj1 = 0 ;
32463 PyObject * obj2 = 0 ;
32464 char * kwnames[] = {
32465 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
32466 };
32467
32468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32469 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32470 if (!SWIG_IsOK(res1)) {
32471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
32472 }
32473 arg1 = reinterpret_cast< wxWindow * >(argp1);
32474 {
32475 arg2 = &temp2;
32476 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32477 }
32478 if (obj2) {
32479 {
32480 arg3 = &temp3;
32481 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
32482 }
32483 }
32484 {
32485 PyThreadState* __tstate = wxPyBeginAllowThreads();
32486 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
32487 wxPyEndAllowThreads(__tstate);
32488 if (PyErr_Occurred()) SWIG_fail;
32489 }
32490 resultobj = SWIG_Py_Void();
32491 return resultobj;
32492 fail:
32493 return NULL;
32494 }
32495
32496
32497 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32498 PyObject *resultobj = 0;
32499 wxWindow *arg1 = (wxWindow *) 0 ;
32500 wxSize result;
32501 void *argp1 = 0 ;
32502 int res1 = 0 ;
32503 PyObject *swig_obj[1] ;
32504
32505 if (!args) SWIG_fail;
32506 swig_obj[0] = args;
32507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32508 if (!SWIG_IsOK(res1)) {
32509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32510 }
32511 arg1 = reinterpret_cast< wxWindow * >(argp1);
32512 {
32513 PyThreadState* __tstate = wxPyBeginAllowThreads();
32514 result = ((wxWindow const *)arg1)->GetMaxSize();
32515 wxPyEndAllowThreads(__tstate);
32516 if (PyErr_Occurred()) SWIG_fail;
32517 }
32518 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32519 return resultobj;
32520 fail:
32521 return NULL;
32522 }
32523
32524
32525 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32526 PyObject *resultobj = 0;
32527 wxWindow *arg1 = (wxWindow *) 0 ;
32528 wxSize result;
32529 void *argp1 = 0 ;
32530 int res1 = 0 ;
32531 PyObject *swig_obj[1] ;
32532
32533 if (!args) SWIG_fail;
32534 swig_obj[0] = args;
32535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32536 if (!SWIG_IsOK(res1)) {
32537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32538 }
32539 arg1 = reinterpret_cast< wxWindow * >(argp1);
32540 {
32541 PyThreadState* __tstate = wxPyBeginAllowThreads();
32542 result = ((wxWindow const *)arg1)->GetMinSize();
32543 wxPyEndAllowThreads(__tstate);
32544 if (PyErr_Occurred()) SWIG_fail;
32545 }
32546 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32547 return resultobj;
32548 fail:
32549 return NULL;
32550 }
32551
32552
32553 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32554 PyObject *resultobj = 0;
32555 wxWindow *arg1 = (wxWindow *) 0 ;
32556 wxSize *arg2 = 0 ;
32557 void *argp1 = 0 ;
32558 int res1 = 0 ;
32559 wxSize temp2 ;
32560 PyObject * obj0 = 0 ;
32561 PyObject * obj1 = 0 ;
32562 char * kwnames[] = {
32563 (char *) "self",(char *) "minSize", NULL
32564 };
32565
32566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
32567 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32568 if (!SWIG_IsOK(res1)) {
32569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32570 }
32571 arg1 = reinterpret_cast< wxWindow * >(argp1);
32572 {
32573 arg2 = &temp2;
32574 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32575 }
32576 {
32577 PyThreadState* __tstate = wxPyBeginAllowThreads();
32578 (arg1)->SetMinSize((wxSize const &)*arg2);
32579 wxPyEndAllowThreads(__tstate);
32580 if (PyErr_Occurred()) SWIG_fail;
32581 }
32582 resultobj = SWIG_Py_Void();
32583 return resultobj;
32584 fail:
32585 return NULL;
32586 }
32587
32588
32589 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32590 PyObject *resultobj = 0;
32591 wxWindow *arg1 = (wxWindow *) 0 ;
32592 wxSize *arg2 = 0 ;
32593 void *argp1 = 0 ;
32594 int res1 = 0 ;
32595 wxSize temp2 ;
32596 PyObject * obj0 = 0 ;
32597 PyObject * obj1 = 0 ;
32598 char * kwnames[] = {
32599 (char *) "self",(char *) "maxSize", NULL
32600 };
32601
32602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
32603 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32604 if (!SWIG_IsOK(res1)) {
32605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32606 }
32607 arg1 = reinterpret_cast< wxWindow * >(argp1);
32608 {
32609 arg2 = &temp2;
32610 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32611 }
32612 {
32613 PyThreadState* __tstate = wxPyBeginAllowThreads();
32614 (arg1)->SetMaxSize((wxSize const &)*arg2);
32615 wxPyEndAllowThreads(__tstate);
32616 if (PyErr_Occurred()) SWIG_fail;
32617 }
32618 resultobj = SWIG_Py_Void();
32619 return resultobj;
32620 fail:
32621 return NULL;
32622 }
32623
32624
32625 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32626 PyObject *resultobj = 0;
32627 wxWindow *arg1 = (wxWindow *) 0 ;
32628 int result;
32629 void *argp1 = 0 ;
32630 int res1 = 0 ;
32631 PyObject *swig_obj[1] ;
32632
32633 if (!args) SWIG_fail;
32634 swig_obj[0] = args;
32635 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32636 if (!SWIG_IsOK(res1)) {
32637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
32638 }
32639 arg1 = reinterpret_cast< wxWindow * >(argp1);
32640 {
32641 PyThreadState* __tstate = wxPyBeginAllowThreads();
32642 result = (int)((wxWindow const *)arg1)->GetMinWidth();
32643 wxPyEndAllowThreads(__tstate);
32644 if (PyErr_Occurred()) SWIG_fail;
32645 }
32646 resultobj = SWIG_From_int(static_cast< int >(result));
32647 return resultobj;
32648 fail:
32649 return NULL;
32650 }
32651
32652
32653 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32654 PyObject *resultobj = 0;
32655 wxWindow *arg1 = (wxWindow *) 0 ;
32656 int result;
32657 void *argp1 = 0 ;
32658 int res1 = 0 ;
32659 PyObject *swig_obj[1] ;
32660
32661 if (!args) SWIG_fail;
32662 swig_obj[0] = args;
32663 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32664 if (!SWIG_IsOK(res1)) {
32665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
32666 }
32667 arg1 = reinterpret_cast< wxWindow * >(argp1);
32668 {
32669 PyThreadState* __tstate = wxPyBeginAllowThreads();
32670 result = (int)((wxWindow const *)arg1)->GetMinHeight();
32671 wxPyEndAllowThreads(__tstate);
32672 if (PyErr_Occurred()) SWIG_fail;
32673 }
32674 resultobj = SWIG_From_int(static_cast< int >(result));
32675 return resultobj;
32676 fail:
32677 return NULL;
32678 }
32679
32680
32681 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32682 PyObject *resultobj = 0;
32683 wxWindow *arg1 = (wxWindow *) 0 ;
32684 int result;
32685 void *argp1 = 0 ;
32686 int res1 = 0 ;
32687 PyObject *swig_obj[1] ;
32688
32689 if (!args) SWIG_fail;
32690 swig_obj[0] = args;
32691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32692 if (!SWIG_IsOK(res1)) {
32693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
32694 }
32695 arg1 = reinterpret_cast< wxWindow * >(argp1);
32696 {
32697 PyThreadState* __tstate = wxPyBeginAllowThreads();
32698 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
32699 wxPyEndAllowThreads(__tstate);
32700 if (PyErr_Occurred()) SWIG_fail;
32701 }
32702 resultobj = SWIG_From_int(static_cast< int >(result));
32703 return resultobj;
32704 fail:
32705 return NULL;
32706 }
32707
32708
32709 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32710 PyObject *resultobj = 0;
32711 wxWindow *arg1 = (wxWindow *) 0 ;
32712 int result;
32713 void *argp1 = 0 ;
32714 int res1 = 0 ;
32715 PyObject *swig_obj[1] ;
32716
32717 if (!args) SWIG_fail;
32718 swig_obj[0] = args;
32719 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32720 if (!SWIG_IsOK(res1)) {
32721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
32722 }
32723 arg1 = reinterpret_cast< wxWindow * >(argp1);
32724 {
32725 PyThreadState* __tstate = wxPyBeginAllowThreads();
32726 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
32727 wxPyEndAllowThreads(__tstate);
32728 if (PyErr_Occurred()) SWIG_fail;
32729 }
32730 resultobj = SWIG_From_int(static_cast< int >(result));
32731 return resultobj;
32732 fail:
32733 return NULL;
32734 }
32735
32736
32737 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32738 PyObject *resultobj = 0;
32739 wxWindow *arg1 = (wxWindow *) 0 ;
32740 wxSize *arg2 = 0 ;
32741 void *argp1 = 0 ;
32742 int res1 = 0 ;
32743 wxSize temp2 ;
32744 PyObject * obj0 = 0 ;
32745 PyObject * obj1 = 0 ;
32746 char * kwnames[] = {
32747 (char *) "self",(char *) "size", NULL
32748 };
32749
32750 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
32751 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32752 if (!SWIG_IsOK(res1)) {
32753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32754 }
32755 arg1 = reinterpret_cast< wxWindow * >(argp1);
32756 {
32757 arg2 = &temp2;
32758 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32759 }
32760 {
32761 PyThreadState* __tstate = wxPyBeginAllowThreads();
32762 (arg1)->SetVirtualSize((wxSize const &)*arg2);
32763 wxPyEndAllowThreads(__tstate);
32764 if (PyErr_Occurred()) SWIG_fail;
32765 }
32766 resultobj = SWIG_Py_Void();
32767 return resultobj;
32768 fail:
32769 return NULL;
32770 }
32771
32772
32773 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32774 PyObject *resultobj = 0;
32775 wxWindow *arg1 = (wxWindow *) 0 ;
32776 int arg2 ;
32777 int arg3 ;
32778 void *argp1 = 0 ;
32779 int res1 = 0 ;
32780 int val2 ;
32781 int ecode2 = 0 ;
32782 int val3 ;
32783 int ecode3 = 0 ;
32784 PyObject * obj0 = 0 ;
32785 PyObject * obj1 = 0 ;
32786 PyObject * obj2 = 0 ;
32787 char * kwnames[] = {
32788 (char *) "self",(char *) "w",(char *) "h", NULL
32789 };
32790
32791 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32792 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32793 if (!SWIG_IsOK(res1)) {
32794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
32795 }
32796 arg1 = reinterpret_cast< wxWindow * >(argp1);
32797 ecode2 = SWIG_AsVal_int(obj1, &val2);
32798 if (!SWIG_IsOK(ecode2)) {
32799 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
32800 }
32801 arg2 = static_cast< int >(val2);
32802 ecode3 = SWIG_AsVal_int(obj2, &val3);
32803 if (!SWIG_IsOK(ecode3)) {
32804 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
32805 }
32806 arg3 = static_cast< int >(val3);
32807 {
32808 PyThreadState* __tstate = wxPyBeginAllowThreads();
32809 (arg1)->SetVirtualSize(arg2,arg3);
32810 wxPyEndAllowThreads(__tstate);
32811 if (PyErr_Occurred()) SWIG_fail;
32812 }
32813 resultobj = SWIG_Py_Void();
32814 return resultobj;
32815 fail:
32816 return NULL;
32817 }
32818
32819
32820 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32821 PyObject *resultobj = 0;
32822 wxWindow *arg1 = (wxWindow *) 0 ;
32823 wxSize result;
32824 void *argp1 = 0 ;
32825 int res1 = 0 ;
32826 PyObject *swig_obj[1] ;
32827
32828 if (!args) SWIG_fail;
32829 swig_obj[0] = args;
32830 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32831 if (!SWIG_IsOK(res1)) {
32832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32833 }
32834 arg1 = reinterpret_cast< wxWindow * >(argp1);
32835 {
32836 PyThreadState* __tstate = wxPyBeginAllowThreads();
32837 result = ((wxWindow const *)arg1)->GetVirtualSize();
32838 wxPyEndAllowThreads(__tstate);
32839 if (PyErr_Occurred()) SWIG_fail;
32840 }
32841 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32842 return resultobj;
32843 fail:
32844 return NULL;
32845 }
32846
32847
32848 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32849 PyObject *resultobj = 0;
32850 wxWindow *arg1 = (wxWindow *) 0 ;
32851 int *arg2 = (int *) 0 ;
32852 int *arg3 = (int *) 0 ;
32853 void *argp1 = 0 ;
32854 int res1 = 0 ;
32855 int temp2 ;
32856 int res2 = SWIG_TMPOBJ ;
32857 int temp3 ;
32858 int res3 = SWIG_TMPOBJ ;
32859 PyObject *swig_obj[1] ;
32860
32861 arg2 = &temp2;
32862 arg3 = &temp3;
32863 if (!args) SWIG_fail;
32864 swig_obj[0] = args;
32865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32866 if (!SWIG_IsOK(res1)) {
32867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
32868 }
32869 arg1 = reinterpret_cast< wxWindow * >(argp1);
32870 {
32871 PyThreadState* __tstate = wxPyBeginAllowThreads();
32872 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
32873 wxPyEndAllowThreads(__tstate);
32874 if (PyErr_Occurred()) SWIG_fail;
32875 }
32876 resultobj = SWIG_Py_Void();
32877 if (SWIG_IsTmpObj(res2)) {
32878 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
32879 } else {
32880 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32881 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32882 }
32883 if (SWIG_IsTmpObj(res3)) {
32884 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32885 } else {
32886 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32887 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32888 }
32889 return resultobj;
32890 fail:
32891 return NULL;
32892 }
32893
32894
32895 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32896 PyObject *resultobj = 0;
32897 wxWindow *arg1 = (wxWindow *) 0 ;
32898 wxSize result;
32899 void *argp1 = 0 ;
32900 int res1 = 0 ;
32901 PyObject *swig_obj[1] ;
32902
32903 if (!args) SWIG_fail;
32904 swig_obj[0] = args;
32905 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32906 if (!SWIG_IsOK(res1)) {
32907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32908 }
32909 arg1 = reinterpret_cast< wxWindow * >(argp1);
32910 {
32911 PyThreadState* __tstate = wxPyBeginAllowThreads();
32912 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
32913 wxPyEndAllowThreads(__tstate);
32914 if (PyErr_Occurred()) SWIG_fail;
32915 }
32916 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32917 return resultobj;
32918 fail:
32919 return NULL;
32920 }
32921
32922
32923 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32924 PyObject *resultobj = 0;
32925 wxWindow *arg1 = (wxWindow *) 0 ;
32926 bool arg2 = (bool) true ;
32927 bool result;
32928 void *argp1 = 0 ;
32929 int res1 = 0 ;
32930 bool val2 ;
32931 int ecode2 = 0 ;
32932 PyObject * obj0 = 0 ;
32933 PyObject * obj1 = 0 ;
32934 char * kwnames[] = {
32935 (char *) "self",(char *) "show", NULL
32936 };
32937
32938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
32939 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32940 if (!SWIG_IsOK(res1)) {
32941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
32942 }
32943 arg1 = reinterpret_cast< wxWindow * >(argp1);
32944 if (obj1) {
32945 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32946 if (!SWIG_IsOK(ecode2)) {
32947 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
32948 }
32949 arg2 = static_cast< bool >(val2);
32950 }
32951 {
32952 PyThreadState* __tstate = wxPyBeginAllowThreads();
32953 result = (bool)(arg1)->Show(arg2);
32954 wxPyEndAllowThreads(__tstate);
32955 if (PyErr_Occurred()) SWIG_fail;
32956 }
32957 {
32958 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32959 }
32960 return resultobj;
32961 fail:
32962 return NULL;
32963 }
32964
32965
32966 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32967 PyObject *resultobj = 0;
32968 wxWindow *arg1 = (wxWindow *) 0 ;
32969 bool result;
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_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
32979 }
32980 arg1 = reinterpret_cast< wxWindow * >(argp1);
32981 {
32982 PyThreadState* __tstate = wxPyBeginAllowThreads();
32983 result = (bool)(arg1)->Hide();
32984 wxPyEndAllowThreads(__tstate);
32985 if (PyErr_Occurred()) SWIG_fail;
32986 }
32987 {
32988 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32989 }
32990 return resultobj;
32991 fail:
32992 return NULL;
32993 }
32994
32995
32996 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32997 PyObject *resultobj = 0;
32998 wxWindow *arg1 = (wxWindow *) 0 ;
32999 bool arg2 = (bool) true ;
33000 bool result;
33001 void *argp1 = 0 ;
33002 int res1 = 0 ;
33003 bool val2 ;
33004 int ecode2 = 0 ;
33005 PyObject * obj0 = 0 ;
33006 PyObject * obj1 = 0 ;
33007 char * kwnames[] = {
33008 (char *) "self",(char *) "enable", NULL
33009 };
33010
33011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
33012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33013 if (!SWIG_IsOK(res1)) {
33014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
33015 }
33016 arg1 = reinterpret_cast< wxWindow * >(argp1);
33017 if (obj1) {
33018 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33019 if (!SWIG_IsOK(ecode2)) {
33020 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
33021 }
33022 arg2 = static_cast< bool >(val2);
33023 }
33024 {
33025 PyThreadState* __tstate = wxPyBeginAllowThreads();
33026 result = (bool)(arg1)->Enable(arg2);
33027 wxPyEndAllowThreads(__tstate);
33028 if (PyErr_Occurred()) SWIG_fail;
33029 }
33030 {
33031 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33032 }
33033 return resultobj;
33034 fail:
33035 return NULL;
33036 }
33037
33038
33039 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33040 PyObject *resultobj = 0;
33041 wxWindow *arg1 = (wxWindow *) 0 ;
33042 bool result;
33043 void *argp1 = 0 ;
33044 int res1 = 0 ;
33045 PyObject *swig_obj[1] ;
33046
33047 if (!args) SWIG_fail;
33048 swig_obj[0] = args;
33049 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33050 if (!SWIG_IsOK(res1)) {
33051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
33052 }
33053 arg1 = reinterpret_cast< wxWindow * >(argp1);
33054 {
33055 PyThreadState* __tstate = wxPyBeginAllowThreads();
33056 result = (bool)(arg1)->Disable();
33057 wxPyEndAllowThreads(__tstate);
33058 if (PyErr_Occurred()) SWIG_fail;
33059 }
33060 {
33061 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33062 }
33063 return resultobj;
33064 fail:
33065 return NULL;
33066 }
33067
33068
33069 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33070 PyObject *resultobj = 0;
33071 wxWindow *arg1 = (wxWindow *) 0 ;
33072 bool result;
33073 void *argp1 = 0 ;
33074 int res1 = 0 ;
33075 PyObject *swig_obj[1] ;
33076
33077 if (!args) SWIG_fail;
33078 swig_obj[0] = args;
33079 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33080 if (!SWIG_IsOK(res1)) {
33081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
33082 }
33083 arg1 = reinterpret_cast< wxWindow * >(argp1);
33084 {
33085 PyThreadState* __tstate = wxPyBeginAllowThreads();
33086 result = (bool)((wxWindow const *)arg1)->IsShown();
33087 wxPyEndAllowThreads(__tstate);
33088 if (PyErr_Occurred()) SWIG_fail;
33089 }
33090 {
33091 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33092 }
33093 return resultobj;
33094 fail:
33095 return NULL;
33096 }
33097
33098
33099 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33100 PyObject *resultobj = 0;
33101 wxWindow *arg1 = (wxWindow *) 0 ;
33102 bool result;
33103 void *argp1 = 0 ;
33104 int res1 = 0 ;
33105 PyObject *swig_obj[1] ;
33106
33107 if (!args) SWIG_fail;
33108 swig_obj[0] = args;
33109 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33110 if (!SWIG_IsOK(res1)) {
33111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
33112 }
33113 arg1 = reinterpret_cast< wxWindow * >(argp1);
33114 {
33115 PyThreadState* __tstate = wxPyBeginAllowThreads();
33116 result = (bool)((wxWindow const *)arg1)->IsEnabled();
33117 wxPyEndAllowThreads(__tstate);
33118 if (PyErr_Occurred()) SWIG_fail;
33119 }
33120 {
33121 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33122 }
33123 return resultobj;
33124 fail:
33125 return NULL;
33126 }
33127
33128
33129 SWIGINTERN PyObject *_wrap_Window_IsShownOnScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33130 PyObject *resultobj = 0;
33131 wxWindow *arg1 = (wxWindow *) 0 ;
33132 bool result;
33133 void *argp1 = 0 ;
33134 int res1 = 0 ;
33135 PyObject *swig_obj[1] ;
33136
33137 if (!args) SWIG_fail;
33138 swig_obj[0] = args;
33139 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33140 if (!SWIG_IsOK(res1)) {
33141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShownOnScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
33142 }
33143 arg1 = reinterpret_cast< wxWindow * >(argp1);
33144 {
33145 PyThreadState* __tstate = wxPyBeginAllowThreads();
33146 result = (bool)((wxWindow const *)arg1)->IsShownOnScreen();
33147 wxPyEndAllowThreads(__tstate);
33148 if (PyErr_Occurred()) SWIG_fail;
33149 }
33150 {
33151 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33152 }
33153 return resultobj;
33154 fail:
33155 return NULL;
33156 }
33157
33158
33159 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33160 PyObject *resultobj = 0;
33161 wxWindow *arg1 = (wxWindow *) 0 ;
33162 long arg2 ;
33163 void *argp1 = 0 ;
33164 int res1 = 0 ;
33165 long val2 ;
33166 int ecode2 = 0 ;
33167 PyObject * obj0 = 0 ;
33168 PyObject * obj1 = 0 ;
33169 char * kwnames[] = {
33170 (char *) "self",(char *) "style", NULL
33171 };
33172
33173 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
33174 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33175 if (!SWIG_IsOK(res1)) {
33176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
33177 }
33178 arg1 = reinterpret_cast< wxWindow * >(argp1);
33179 ecode2 = SWIG_AsVal_long(obj1, &val2);
33180 if (!SWIG_IsOK(ecode2)) {
33181 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
33182 }
33183 arg2 = static_cast< long >(val2);
33184 {
33185 PyThreadState* __tstate = wxPyBeginAllowThreads();
33186 (arg1)->SetWindowStyleFlag(arg2);
33187 wxPyEndAllowThreads(__tstate);
33188 if (PyErr_Occurred()) SWIG_fail;
33189 }
33190 resultobj = SWIG_Py_Void();
33191 return resultobj;
33192 fail:
33193 return NULL;
33194 }
33195
33196
33197 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33198 PyObject *resultobj = 0;
33199 wxWindow *arg1 = (wxWindow *) 0 ;
33200 long result;
33201 void *argp1 = 0 ;
33202 int res1 = 0 ;
33203 PyObject *swig_obj[1] ;
33204
33205 if (!args) SWIG_fail;
33206 swig_obj[0] = args;
33207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33208 if (!SWIG_IsOK(res1)) {
33209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
33210 }
33211 arg1 = reinterpret_cast< wxWindow * >(argp1);
33212 {
33213 PyThreadState* __tstate = wxPyBeginAllowThreads();
33214 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
33215 wxPyEndAllowThreads(__tstate);
33216 if (PyErr_Occurred()) SWIG_fail;
33217 }
33218 resultobj = SWIG_From_long(static_cast< long >(result));
33219 return resultobj;
33220 fail:
33221 return NULL;
33222 }
33223
33224
33225 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33226 PyObject *resultobj = 0;
33227 wxWindow *arg1 = (wxWindow *) 0 ;
33228 int arg2 ;
33229 bool result;
33230 void *argp1 = 0 ;
33231 int res1 = 0 ;
33232 int val2 ;
33233 int ecode2 = 0 ;
33234 PyObject * obj0 = 0 ;
33235 PyObject * obj1 = 0 ;
33236 char * kwnames[] = {
33237 (char *) "self",(char *) "flag", NULL
33238 };
33239
33240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
33241 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33242 if (!SWIG_IsOK(res1)) {
33243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
33244 }
33245 arg1 = reinterpret_cast< wxWindow * >(argp1);
33246 ecode2 = SWIG_AsVal_int(obj1, &val2);
33247 if (!SWIG_IsOK(ecode2)) {
33248 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
33249 }
33250 arg2 = static_cast< int >(val2);
33251 {
33252 PyThreadState* __tstate = wxPyBeginAllowThreads();
33253 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
33254 wxPyEndAllowThreads(__tstate);
33255 if (PyErr_Occurred()) SWIG_fail;
33256 }
33257 {
33258 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33259 }
33260 return resultobj;
33261 fail:
33262 return NULL;
33263 }
33264
33265
33266 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33267 PyObject *resultobj = 0;
33268 wxWindow *arg1 = (wxWindow *) 0 ;
33269 bool result;
33270 void *argp1 = 0 ;
33271 int res1 = 0 ;
33272 PyObject *swig_obj[1] ;
33273
33274 if (!args) SWIG_fail;
33275 swig_obj[0] = args;
33276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33277 if (!SWIG_IsOK(res1)) {
33278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
33279 }
33280 arg1 = reinterpret_cast< wxWindow * >(argp1);
33281 {
33282 PyThreadState* __tstate = wxPyBeginAllowThreads();
33283 result = (bool)((wxWindow const *)arg1)->IsRetained();
33284 wxPyEndAllowThreads(__tstate);
33285 if (PyErr_Occurred()) SWIG_fail;
33286 }
33287 {
33288 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33289 }
33290 return resultobj;
33291 fail:
33292 return NULL;
33293 }
33294
33295
33296 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33297 PyObject *resultobj = 0;
33298 wxWindow *arg1 = (wxWindow *) 0 ;
33299 long arg2 ;
33300 void *argp1 = 0 ;
33301 int res1 = 0 ;
33302 long val2 ;
33303 int ecode2 = 0 ;
33304 PyObject * obj0 = 0 ;
33305 PyObject * obj1 = 0 ;
33306 char * kwnames[] = {
33307 (char *) "self",(char *) "exStyle", NULL
33308 };
33309
33310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
33311 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33312 if (!SWIG_IsOK(res1)) {
33313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
33314 }
33315 arg1 = reinterpret_cast< wxWindow * >(argp1);
33316 ecode2 = SWIG_AsVal_long(obj1, &val2);
33317 if (!SWIG_IsOK(ecode2)) {
33318 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
33319 }
33320 arg2 = static_cast< long >(val2);
33321 {
33322 PyThreadState* __tstate = wxPyBeginAllowThreads();
33323 (arg1)->SetExtraStyle(arg2);
33324 wxPyEndAllowThreads(__tstate);
33325 if (PyErr_Occurred()) SWIG_fail;
33326 }
33327 resultobj = SWIG_Py_Void();
33328 return resultobj;
33329 fail:
33330 return NULL;
33331 }
33332
33333
33334 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33335 PyObject *resultobj = 0;
33336 wxWindow *arg1 = (wxWindow *) 0 ;
33337 long result;
33338 void *argp1 = 0 ;
33339 int res1 = 0 ;
33340 PyObject *swig_obj[1] ;
33341
33342 if (!args) SWIG_fail;
33343 swig_obj[0] = args;
33344 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33345 if (!SWIG_IsOK(res1)) {
33346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
33347 }
33348 arg1 = reinterpret_cast< wxWindow * >(argp1);
33349 {
33350 PyThreadState* __tstate = wxPyBeginAllowThreads();
33351 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
33352 wxPyEndAllowThreads(__tstate);
33353 if (PyErr_Occurred()) SWIG_fail;
33354 }
33355 resultobj = SWIG_From_long(static_cast< long >(result));
33356 return resultobj;
33357 fail:
33358 return NULL;
33359 }
33360
33361
33362 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33363 PyObject *resultobj = 0;
33364 wxWindow *arg1 = (wxWindow *) 0 ;
33365 bool arg2 = (bool) true ;
33366 void *argp1 = 0 ;
33367 int res1 = 0 ;
33368 bool val2 ;
33369 int ecode2 = 0 ;
33370 PyObject * obj0 = 0 ;
33371 PyObject * obj1 = 0 ;
33372 char * kwnames[] = {
33373 (char *) "self",(char *) "modal", NULL
33374 };
33375
33376 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
33377 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33378 if (!SWIG_IsOK(res1)) {
33379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
33380 }
33381 arg1 = reinterpret_cast< wxWindow * >(argp1);
33382 if (obj1) {
33383 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33384 if (!SWIG_IsOK(ecode2)) {
33385 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
33386 }
33387 arg2 = static_cast< bool >(val2);
33388 }
33389 {
33390 PyThreadState* __tstate = wxPyBeginAllowThreads();
33391 (arg1)->MakeModal(arg2);
33392 wxPyEndAllowThreads(__tstate);
33393 if (PyErr_Occurred()) SWIG_fail;
33394 }
33395 resultobj = SWIG_Py_Void();
33396 return resultobj;
33397 fail:
33398 return NULL;
33399 }
33400
33401
33402 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33403 PyObject *resultobj = 0;
33404 wxWindow *arg1 = (wxWindow *) 0 ;
33405 bool arg2 ;
33406 void *argp1 = 0 ;
33407 int res1 = 0 ;
33408 bool val2 ;
33409 int ecode2 = 0 ;
33410 PyObject * obj0 = 0 ;
33411 PyObject * obj1 = 0 ;
33412 char * kwnames[] = {
33413 (char *) "self",(char *) "enableTheme", NULL
33414 };
33415
33416 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
33417 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33418 if (!SWIG_IsOK(res1)) {
33419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
33420 }
33421 arg1 = reinterpret_cast< wxWindow * >(argp1);
33422 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33423 if (!SWIG_IsOK(ecode2)) {
33424 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
33425 }
33426 arg2 = static_cast< bool >(val2);
33427 {
33428 PyThreadState* __tstate = wxPyBeginAllowThreads();
33429 (arg1)->SetThemeEnabled(arg2);
33430 wxPyEndAllowThreads(__tstate);
33431 if (PyErr_Occurred()) SWIG_fail;
33432 }
33433 resultobj = SWIG_Py_Void();
33434 return resultobj;
33435 fail:
33436 return NULL;
33437 }
33438
33439
33440 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33441 PyObject *resultobj = 0;
33442 wxWindow *arg1 = (wxWindow *) 0 ;
33443 bool result;
33444 void *argp1 = 0 ;
33445 int res1 = 0 ;
33446 PyObject *swig_obj[1] ;
33447
33448 if (!args) SWIG_fail;
33449 swig_obj[0] = args;
33450 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33451 if (!SWIG_IsOK(res1)) {
33452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
33453 }
33454 arg1 = reinterpret_cast< wxWindow * >(argp1);
33455 {
33456 PyThreadState* __tstate = wxPyBeginAllowThreads();
33457 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
33458 wxPyEndAllowThreads(__tstate);
33459 if (PyErr_Occurred()) SWIG_fail;
33460 }
33461 {
33462 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33463 }
33464 return resultobj;
33465 fail:
33466 return NULL;
33467 }
33468
33469
33470 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33471 PyObject *resultobj = 0;
33472 wxWindow *arg1 = (wxWindow *) 0 ;
33473 void *argp1 = 0 ;
33474 int res1 = 0 ;
33475 PyObject *swig_obj[1] ;
33476
33477 if (!args) SWIG_fail;
33478 swig_obj[0] = args;
33479 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33480 if (!SWIG_IsOK(res1)) {
33481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
33482 }
33483 arg1 = reinterpret_cast< wxWindow * >(argp1);
33484 {
33485 PyThreadState* __tstate = wxPyBeginAllowThreads();
33486 (arg1)->SetFocus();
33487 wxPyEndAllowThreads(__tstate);
33488 if (PyErr_Occurred()) SWIG_fail;
33489 }
33490 resultobj = SWIG_Py_Void();
33491 return resultobj;
33492 fail:
33493 return NULL;
33494 }
33495
33496
33497 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33498 PyObject *resultobj = 0;
33499 wxWindow *arg1 = (wxWindow *) 0 ;
33500 void *argp1 = 0 ;
33501 int res1 = 0 ;
33502 PyObject *swig_obj[1] ;
33503
33504 if (!args) SWIG_fail;
33505 swig_obj[0] = args;
33506 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33507 if (!SWIG_IsOK(res1)) {
33508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
33509 }
33510 arg1 = reinterpret_cast< wxWindow * >(argp1);
33511 {
33512 PyThreadState* __tstate = wxPyBeginAllowThreads();
33513 (arg1)->SetFocusFromKbd();
33514 wxPyEndAllowThreads(__tstate);
33515 if (PyErr_Occurred()) SWIG_fail;
33516 }
33517 resultobj = SWIG_Py_Void();
33518 return resultobj;
33519 fail:
33520 return NULL;
33521 }
33522
33523
33524 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33525 PyObject *resultobj = 0;
33526 wxWindow *result = 0 ;
33527
33528 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
33529 {
33530 if (!wxPyCheckForApp()) SWIG_fail;
33531 PyThreadState* __tstate = wxPyBeginAllowThreads();
33532 result = (wxWindow *)wxWindow::FindFocus();
33533 wxPyEndAllowThreads(__tstate);
33534 if (PyErr_Occurred()) SWIG_fail;
33535 }
33536 {
33537 resultobj = wxPyMake_wxObject(result, 0);
33538 }
33539 return resultobj;
33540 fail:
33541 return NULL;
33542 }
33543
33544
33545 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33546 PyObject *resultobj = 0;
33547 wxWindow *arg1 = (wxWindow *) 0 ;
33548 bool result;
33549 void *argp1 = 0 ;
33550 int res1 = 0 ;
33551 PyObject *swig_obj[1] ;
33552
33553 if (!args) SWIG_fail;
33554 swig_obj[0] = args;
33555 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33556 if (!SWIG_IsOK(res1)) {
33557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
33558 }
33559 arg1 = reinterpret_cast< wxWindow * >(argp1);
33560 {
33561 PyThreadState* __tstate = wxPyBeginAllowThreads();
33562 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
33563 wxPyEndAllowThreads(__tstate);
33564 if (PyErr_Occurred()) SWIG_fail;
33565 }
33566 {
33567 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33568 }
33569 return resultobj;
33570 fail:
33571 return NULL;
33572 }
33573
33574
33575 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33576 PyObject *resultobj = 0;
33577 wxWindow *arg1 = (wxWindow *) 0 ;
33578 bool result;
33579 void *argp1 = 0 ;
33580 int res1 = 0 ;
33581 PyObject *swig_obj[1] ;
33582
33583 if (!args) SWIG_fail;
33584 swig_obj[0] = args;
33585 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33586 if (!SWIG_IsOK(res1)) {
33587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
33588 }
33589 arg1 = reinterpret_cast< wxWindow * >(argp1);
33590 {
33591 PyThreadState* __tstate = wxPyBeginAllowThreads();
33592 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
33593 wxPyEndAllowThreads(__tstate);
33594 if (PyErr_Occurred()) SWIG_fail;
33595 }
33596 {
33597 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33598 }
33599 return resultobj;
33600 fail:
33601 return NULL;
33602 }
33603
33604
33605 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33606 PyObject *resultobj = 0;
33607 wxWindow *arg1 = (wxWindow *) 0 ;
33608 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
33609 bool result;
33610 void *argp1 = 0 ;
33611 int res1 = 0 ;
33612 int val2 ;
33613 int ecode2 = 0 ;
33614 PyObject * obj0 = 0 ;
33615 PyObject * obj1 = 0 ;
33616 char * kwnames[] = {
33617 (char *) "self",(char *) "flags", NULL
33618 };
33619
33620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
33621 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33622 if (!SWIG_IsOK(res1)) {
33623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
33624 }
33625 arg1 = reinterpret_cast< wxWindow * >(argp1);
33626 if (obj1) {
33627 ecode2 = SWIG_AsVal_int(obj1, &val2);
33628 if (!SWIG_IsOK(ecode2)) {
33629 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
33630 }
33631 arg2 = static_cast< int >(val2);
33632 }
33633 {
33634 PyThreadState* __tstate = wxPyBeginAllowThreads();
33635 result = (bool)(arg1)->Navigate(arg2);
33636 wxPyEndAllowThreads(__tstate);
33637 if (PyErr_Occurred()) SWIG_fail;
33638 }
33639 {
33640 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33641 }
33642 return resultobj;
33643 fail:
33644 return NULL;
33645 }
33646
33647
33648 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33649 PyObject *resultobj = 0;
33650 wxWindow *arg1 = (wxWindow *) 0 ;
33651 wxWindow *arg2 = (wxWindow *) 0 ;
33652 void *argp1 = 0 ;
33653 int res1 = 0 ;
33654 void *argp2 = 0 ;
33655 int res2 = 0 ;
33656 PyObject * obj0 = 0 ;
33657 PyObject * obj1 = 0 ;
33658 char * kwnames[] = {
33659 (char *) "self",(char *) "win", NULL
33660 };
33661
33662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
33663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33664 if (!SWIG_IsOK(res1)) {
33665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
33666 }
33667 arg1 = reinterpret_cast< wxWindow * >(argp1);
33668 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33669 if (!SWIG_IsOK(res2)) {
33670 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
33671 }
33672 arg2 = reinterpret_cast< wxWindow * >(argp2);
33673 {
33674 PyThreadState* __tstate = wxPyBeginAllowThreads();
33675 (arg1)->MoveAfterInTabOrder(arg2);
33676 wxPyEndAllowThreads(__tstate);
33677 if (PyErr_Occurred()) SWIG_fail;
33678 }
33679 resultobj = SWIG_Py_Void();
33680 return resultobj;
33681 fail:
33682 return NULL;
33683 }
33684
33685
33686 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33687 PyObject *resultobj = 0;
33688 wxWindow *arg1 = (wxWindow *) 0 ;
33689 wxWindow *arg2 = (wxWindow *) 0 ;
33690 void *argp1 = 0 ;
33691 int res1 = 0 ;
33692 void *argp2 = 0 ;
33693 int res2 = 0 ;
33694 PyObject * obj0 = 0 ;
33695 PyObject * obj1 = 0 ;
33696 char * kwnames[] = {
33697 (char *) "self",(char *) "win", NULL
33698 };
33699
33700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
33701 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33702 if (!SWIG_IsOK(res1)) {
33703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
33704 }
33705 arg1 = reinterpret_cast< wxWindow * >(argp1);
33706 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33707 if (!SWIG_IsOK(res2)) {
33708 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
33709 }
33710 arg2 = reinterpret_cast< wxWindow * >(argp2);
33711 {
33712 PyThreadState* __tstate = wxPyBeginAllowThreads();
33713 (arg1)->MoveBeforeInTabOrder(arg2);
33714 wxPyEndAllowThreads(__tstate);
33715 if (PyErr_Occurred()) SWIG_fail;
33716 }
33717 resultobj = SWIG_Py_Void();
33718 return resultobj;
33719 fail:
33720 return NULL;
33721 }
33722
33723
33724 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33725 PyObject *resultobj = 0;
33726 wxWindow *arg1 = (wxWindow *) 0 ;
33727 PyObject *result = 0 ;
33728 void *argp1 = 0 ;
33729 int res1 = 0 ;
33730 PyObject *swig_obj[1] ;
33731
33732 if (!args) SWIG_fail;
33733 swig_obj[0] = args;
33734 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33735 if (!SWIG_IsOK(res1)) {
33736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
33737 }
33738 arg1 = reinterpret_cast< wxWindow * >(argp1);
33739 {
33740 PyThreadState* __tstate = wxPyBeginAllowThreads();
33741 result = (PyObject *)wxWindow_GetChildren(arg1);
33742 wxPyEndAllowThreads(__tstate);
33743 if (PyErr_Occurred()) SWIG_fail;
33744 }
33745 resultobj = result;
33746 return resultobj;
33747 fail:
33748 return NULL;
33749 }
33750
33751
33752 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33753 PyObject *resultobj = 0;
33754 wxWindow *arg1 = (wxWindow *) 0 ;
33755 wxWindow *result = 0 ;
33756 void *argp1 = 0 ;
33757 int res1 = 0 ;
33758 PyObject *swig_obj[1] ;
33759
33760 if (!args) SWIG_fail;
33761 swig_obj[0] = args;
33762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33763 if (!SWIG_IsOK(res1)) {
33764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
33765 }
33766 arg1 = reinterpret_cast< wxWindow * >(argp1);
33767 {
33768 PyThreadState* __tstate = wxPyBeginAllowThreads();
33769 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
33770 wxPyEndAllowThreads(__tstate);
33771 if (PyErr_Occurred()) SWIG_fail;
33772 }
33773 {
33774 resultobj = wxPyMake_wxObject(result, 0);
33775 }
33776 return resultobj;
33777 fail:
33778 return NULL;
33779 }
33780
33781
33782 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33783 PyObject *resultobj = 0;
33784 wxWindow *arg1 = (wxWindow *) 0 ;
33785 wxWindow *result = 0 ;
33786 void *argp1 = 0 ;
33787 int res1 = 0 ;
33788 PyObject *swig_obj[1] ;
33789
33790 if (!args) SWIG_fail;
33791 swig_obj[0] = args;
33792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33793 if (!SWIG_IsOK(res1)) {
33794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
33795 }
33796 arg1 = reinterpret_cast< wxWindow * >(argp1);
33797 {
33798 PyThreadState* __tstate = wxPyBeginAllowThreads();
33799 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
33800 wxPyEndAllowThreads(__tstate);
33801 if (PyErr_Occurred()) SWIG_fail;
33802 }
33803 {
33804 resultobj = wxPyMake_wxObject(result, 0);
33805 }
33806 return resultobj;
33807 fail:
33808 return NULL;
33809 }
33810
33811
33812 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33813 PyObject *resultobj = 0;
33814 wxWindow *arg1 = (wxWindow *) 0 ;
33815 bool result;
33816 void *argp1 = 0 ;
33817 int res1 = 0 ;
33818 PyObject *swig_obj[1] ;
33819
33820 if (!args) SWIG_fail;
33821 swig_obj[0] = args;
33822 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33823 if (!SWIG_IsOK(res1)) {
33824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
33825 }
33826 arg1 = reinterpret_cast< wxWindow * >(argp1);
33827 {
33828 PyThreadState* __tstate = wxPyBeginAllowThreads();
33829 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
33830 wxPyEndAllowThreads(__tstate);
33831 if (PyErr_Occurred()) SWIG_fail;
33832 }
33833 {
33834 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33835 }
33836 return resultobj;
33837 fail:
33838 return NULL;
33839 }
33840
33841
33842 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33843 PyObject *resultobj = 0;
33844 wxWindow *arg1 = (wxWindow *) 0 ;
33845 wxWindow *arg2 = (wxWindow *) 0 ;
33846 bool result;
33847 void *argp1 = 0 ;
33848 int res1 = 0 ;
33849 void *argp2 = 0 ;
33850 int res2 = 0 ;
33851 PyObject * obj0 = 0 ;
33852 PyObject * obj1 = 0 ;
33853 char * kwnames[] = {
33854 (char *) "self",(char *) "newParent", NULL
33855 };
33856
33857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
33858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33859 if (!SWIG_IsOK(res1)) {
33860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
33861 }
33862 arg1 = reinterpret_cast< wxWindow * >(argp1);
33863 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33864 if (!SWIG_IsOK(res2)) {
33865 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
33866 }
33867 arg2 = reinterpret_cast< wxWindow * >(argp2);
33868 {
33869 PyThreadState* __tstate = wxPyBeginAllowThreads();
33870 result = (bool)(arg1)->Reparent(arg2);
33871 wxPyEndAllowThreads(__tstate);
33872 if (PyErr_Occurred()) SWIG_fail;
33873 }
33874 {
33875 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33876 }
33877 return resultobj;
33878 fail:
33879 return NULL;
33880 }
33881
33882
33883 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33884 PyObject *resultobj = 0;
33885 wxWindow *arg1 = (wxWindow *) 0 ;
33886 wxWindow *arg2 = (wxWindow *) 0 ;
33887 void *argp1 = 0 ;
33888 int res1 = 0 ;
33889 void *argp2 = 0 ;
33890 int res2 = 0 ;
33891 PyObject * obj0 = 0 ;
33892 PyObject * obj1 = 0 ;
33893 char * kwnames[] = {
33894 (char *) "self",(char *) "child", NULL
33895 };
33896
33897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
33898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33899 if (!SWIG_IsOK(res1)) {
33900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33901 }
33902 arg1 = reinterpret_cast< wxWindow * >(argp1);
33903 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33904 if (!SWIG_IsOK(res2)) {
33905 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33906 }
33907 arg2 = reinterpret_cast< wxWindow * >(argp2);
33908 {
33909 PyThreadState* __tstate = wxPyBeginAllowThreads();
33910 (arg1)->AddChild(arg2);
33911 wxPyEndAllowThreads(__tstate);
33912 if (PyErr_Occurred()) SWIG_fail;
33913 }
33914 resultobj = SWIG_Py_Void();
33915 return resultobj;
33916 fail:
33917 return NULL;
33918 }
33919
33920
33921 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33922 PyObject *resultobj = 0;
33923 wxWindow *arg1 = (wxWindow *) 0 ;
33924 wxWindow *arg2 = (wxWindow *) 0 ;
33925 void *argp1 = 0 ;
33926 int res1 = 0 ;
33927 void *argp2 = 0 ;
33928 int res2 = 0 ;
33929 PyObject * obj0 = 0 ;
33930 PyObject * obj1 = 0 ;
33931 char * kwnames[] = {
33932 (char *) "self",(char *) "child", NULL
33933 };
33934
33935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
33936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33937 if (!SWIG_IsOK(res1)) {
33938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33939 }
33940 arg1 = reinterpret_cast< wxWindow * >(argp1);
33941 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33942 if (!SWIG_IsOK(res2)) {
33943 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33944 }
33945 arg2 = reinterpret_cast< wxWindow * >(argp2);
33946 {
33947 PyThreadState* __tstate = wxPyBeginAllowThreads();
33948 (arg1)->RemoveChild(arg2);
33949 wxPyEndAllowThreads(__tstate);
33950 if (PyErr_Occurred()) SWIG_fail;
33951 }
33952 resultobj = SWIG_Py_Void();
33953 return resultobj;
33954 fail:
33955 return NULL;
33956 }
33957
33958
33959 SWIGINTERN PyObject *_wrap_Window_SetDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33960 PyObject *resultobj = 0;
33961 wxWindow *arg1 = (wxWindow *) 0 ;
33962 bool arg2 ;
33963 void *argp1 = 0 ;
33964 int res1 = 0 ;
33965 bool val2 ;
33966 int ecode2 = 0 ;
33967 PyObject * obj0 = 0 ;
33968 PyObject * obj1 = 0 ;
33969 char * kwnames[] = {
33970 (char *) "self",(char *) "on", NULL
33971 };
33972
33973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDoubleBuffered",kwnames,&obj0,&obj1)) SWIG_fail;
33974 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33975 if (!SWIG_IsOK(res1)) {
33976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow *""'");
33977 }
33978 arg1 = reinterpret_cast< wxWindow * >(argp1);
33979 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33980 if (!SWIG_IsOK(ecode2)) {
33981 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDoubleBuffered" "', expected argument " "2"" of type '" "bool""'");
33982 }
33983 arg2 = static_cast< bool >(val2);
33984 {
33985 PyThreadState* __tstate = wxPyBeginAllowThreads();
33986 (arg1)->SetDoubleBuffered(arg2);
33987 wxPyEndAllowThreads(__tstate);
33988 if (PyErr_Occurred()) SWIG_fail;
33989 }
33990 resultobj = SWIG_Py_Void();
33991 return resultobj;
33992 fail:
33993 return NULL;
33994 }
33995
33996
33997 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33998 PyObject *resultobj = 0;
33999 wxWindow *arg1 = (wxWindow *) 0 ;
34000 long arg2 ;
34001 wxWindow *result = 0 ;
34002 void *argp1 = 0 ;
34003 int res1 = 0 ;
34004 long val2 ;
34005 int ecode2 = 0 ;
34006 PyObject * obj0 = 0 ;
34007 PyObject * obj1 = 0 ;
34008 char * kwnames[] = {
34009 (char *) "self",(char *) "winid", NULL
34010 };
34011
34012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
34013 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34014 if (!SWIG_IsOK(res1)) {
34015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
34016 }
34017 arg1 = reinterpret_cast< wxWindow * >(argp1);
34018 ecode2 = SWIG_AsVal_long(obj1, &val2);
34019 if (!SWIG_IsOK(ecode2)) {
34020 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
34021 }
34022 arg2 = static_cast< long >(val2);
34023 {
34024 PyThreadState* __tstate = wxPyBeginAllowThreads();
34025 result = (wxWindow *)(arg1)->FindWindow(arg2);
34026 wxPyEndAllowThreads(__tstate);
34027 if (PyErr_Occurred()) SWIG_fail;
34028 }
34029 {
34030 resultobj = wxPyMake_wxObject(result, 0);
34031 }
34032 return resultobj;
34033 fail:
34034 return NULL;
34035 }
34036
34037
34038 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34039 PyObject *resultobj = 0;
34040 wxWindow *arg1 = (wxWindow *) 0 ;
34041 wxString *arg2 = 0 ;
34042 wxWindow *result = 0 ;
34043 void *argp1 = 0 ;
34044 int res1 = 0 ;
34045 bool temp2 = false ;
34046 PyObject * obj0 = 0 ;
34047 PyObject * obj1 = 0 ;
34048 char * kwnames[] = {
34049 (char *) "self",(char *) "name", NULL
34050 };
34051
34052 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
34053 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34054 if (!SWIG_IsOK(res1)) {
34055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
34056 }
34057 arg1 = reinterpret_cast< wxWindow * >(argp1);
34058 {
34059 arg2 = wxString_in_helper(obj1);
34060 if (arg2 == NULL) SWIG_fail;
34061 temp2 = true;
34062 }
34063 {
34064 PyThreadState* __tstate = wxPyBeginAllowThreads();
34065 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
34066 wxPyEndAllowThreads(__tstate);
34067 if (PyErr_Occurred()) SWIG_fail;
34068 }
34069 {
34070 resultobj = wxPyMake_wxObject(result, 0);
34071 }
34072 {
34073 if (temp2)
34074 delete arg2;
34075 }
34076 return resultobj;
34077 fail:
34078 {
34079 if (temp2)
34080 delete arg2;
34081 }
34082 return NULL;
34083 }
34084
34085
34086 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34087 PyObject *resultobj = 0;
34088 wxWindow *arg1 = (wxWindow *) 0 ;
34089 wxEvtHandler *result = 0 ;
34090 void *argp1 = 0 ;
34091 int res1 = 0 ;
34092 PyObject *swig_obj[1] ;
34093
34094 if (!args) SWIG_fail;
34095 swig_obj[0] = args;
34096 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34097 if (!SWIG_IsOK(res1)) {
34098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
34099 }
34100 arg1 = reinterpret_cast< wxWindow * >(argp1);
34101 {
34102 PyThreadState* __tstate = wxPyBeginAllowThreads();
34103 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
34104 wxPyEndAllowThreads(__tstate);
34105 if (PyErr_Occurred()) SWIG_fail;
34106 }
34107 {
34108 resultobj = wxPyMake_wxObject(result, 0);
34109 }
34110 return resultobj;
34111 fail:
34112 return NULL;
34113 }
34114
34115
34116 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34117 PyObject *resultobj = 0;
34118 wxWindow *arg1 = (wxWindow *) 0 ;
34119 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
34120 void *argp1 = 0 ;
34121 int res1 = 0 ;
34122 void *argp2 = 0 ;
34123 int res2 = 0 ;
34124 PyObject * obj0 = 0 ;
34125 PyObject * obj1 = 0 ;
34126 char * kwnames[] = {
34127 (char *) "self",(char *) "handler", NULL
34128 };
34129
34130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
34131 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34132 if (!SWIG_IsOK(res1)) {
34133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
34134 }
34135 arg1 = reinterpret_cast< wxWindow * >(argp1);
34136 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
34137 if (!SWIG_IsOK(res2)) {
34138 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
34139 }
34140 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
34141 {
34142 PyThreadState* __tstate = wxPyBeginAllowThreads();
34143 (arg1)->SetEventHandler(arg2);
34144 wxPyEndAllowThreads(__tstate);
34145 if (PyErr_Occurred()) SWIG_fail;
34146 }
34147 resultobj = SWIG_Py_Void();
34148 return resultobj;
34149 fail:
34150 return NULL;
34151 }
34152
34153
34154 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34155 PyObject *resultobj = 0;
34156 wxWindow *arg1 = (wxWindow *) 0 ;
34157 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
34158 void *argp1 = 0 ;
34159 int res1 = 0 ;
34160 void *argp2 = 0 ;
34161 int res2 = 0 ;
34162 PyObject * obj0 = 0 ;
34163 PyObject * obj1 = 0 ;
34164 char * kwnames[] = {
34165 (char *) "self",(char *) "handler", NULL
34166 };
34167
34168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
34169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34170 if (!SWIG_IsOK(res1)) {
34171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
34172 }
34173 arg1 = reinterpret_cast< wxWindow * >(argp1);
34174 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
34175 if (!SWIG_IsOK(res2)) {
34176 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
34177 }
34178 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
34179 {
34180 PyThreadState* __tstate = wxPyBeginAllowThreads();
34181 (arg1)->PushEventHandler(arg2);
34182 wxPyEndAllowThreads(__tstate);
34183 if (PyErr_Occurred()) SWIG_fail;
34184 }
34185 resultobj = SWIG_Py_Void();
34186 return resultobj;
34187 fail:
34188 return NULL;
34189 }
34190
34191
34192 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34193 PyObject *resultobj = 0;
34194 wxWindow *arg1 = (wxWindow *) 0 ;
34195 bool arg2 = (bool) false ;
34196 wxEvtHandler *result = 0 ;
34197 void *argp1 = 0 ;
34198 int res1 = 0 ;
34199 bool val2 ;
34200 int ecode2 = 0 ;
34201 PyObject * obj0 = 0 ;
34202 PyObject * obj1 = 0 ;
34203 char * kwnames[] = {
34204 (char *) "self",(char *) "deleteHandler", NULL
34205 };
34206
34207 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
34208 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34209 if (!SWIG_IsOK(res1)) {
34210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
34211 }
34212 arg1 = reinterpret_cast< wxWindow * >(argp1);
34213 if (obj1) {
34214 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34215 if (!SWIG_IsOK(ecode2)) {
34216 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
34217 }
34218 arg2 = static_cast< bool >(val2);
34219 }
34220 {
34221 PyThreadState* __tstate = wxPyBeginAllowThreads();
34222 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
34223 wxPyEndAllowThreads(__tstate);
34224 if (PyErr_Occurred()) SWIG_fail;
34225 }
34226 {
34227 resultobj = wxPyMake_wxObject(result, 0);
34228 }
34229 return resultobj;
34230 fail:
34231 return NULL;
34232 }
34233
34234
34235 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34236 PyObject *resultobj = 0;
34237 wxWindow *arg1 = (wxWindow *) 0 ;
34238 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
34239 bool result;
34240 void *argp1 = 0 ;
34241 int res1 = 0 ;
34242 void *argp2 = 0 ;
34243 int res2 = 0 ;
34244 PyObject * obj0 = 0 ;
34245 PyObject * obj1 = 0 ;
34246 char * kwnames[] = {
34247 (char *) "self",(char *) "handler", NULL
34248 };
34249
34250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
34251 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34252 if (!SWIG_IsOK(res1)) {
34253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
34254 }
34255 arg1 = reinterpret_cast< wxWindow * >(argp1);
34256 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
34257 if (!SWIG_IsOK(res2)) {
34258 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
34259 }
34260 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
34261 {
34262 PyThreadState* __tstate = wxPyBeginAllowThreads();
34263 result = (bool)(arg1)->RemoveEventHandler(arg2);
34264 wxPyEndAllowThreads(__tstate);
34265 if (PyErr_Occurred()) SWIG_fail;
34266 }
34267 {
34268 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34269 }
34270 return resultobj;
34271 fail:
34272 return NULL;
34273 }
34274
34275
34276 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34277 PyObject *resultobj = 0;
34278 wxWindow *arg1 = (wxWindow *) 0 ;
34279 wxValidator *arg2 = 0 ;
34280 void *argp1 = 0 ;
34281 int res1 = 0 ;
34282 void *argp2 = 0 ;
34283 int res2 = 0 ;
34284 PyObject * obj0 = 0 ;
34285 PyObject * obj1 = 0 ;
34286 char * kwnames[] = {
34287 (char *) "self",(char *) "validator", NULL
34288 };
34289
34290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
34291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34292 if (!SWIG_IsOK(res1)) {
34293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
34294 }
34295 arg1 = reinterpret_cast< wxWindow * >(argp1);
34296 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
34297 if (!SWIG_IsOK(res2)) {
34298 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
34299 }
34300 if (!argp2) {
34301 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
34302 }
34303 arg2 = reinterpret_cast< wxValidator * >(argp2);
34304 {
34305 PyThreadState* __tstate = wxPyBeginAllowThreads();
34306 (arg1)->SetValidator((wxValidator const &)*arg2);
34307 wxPyEndAllowThreads(__tstate);
34308 if (PyErr_Occurred()) SWIG_fail;
34309 }
34310 resultobj = SWIG_Py_Void();
34311 return resultobj;
34312 fail:
34313 return NULL;
34314 }
34315
34316
34317 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34318 PyObject *resultobj = 0;
34319 wxWindow *arg1 = (wxWindow *) 0 ;
34320 wxValidator *result = 0 ;
34321 void *argp1 = 0 ;
34322 int res1 = 0 ;
34323 PyObject *swig_obj[1] ;
34324
34325 if (!args) SWIG_fail;
34326 swig_obj[0] = args;
34327 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34328 if (!SWIG_IsOK(res1)) {
34329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
34330 }
34331 arg1 = reinterpret_cast< wxWindow * >(argp1);
34332 {
34333 PyThreadState* __tstate = wxPyBeginAllowThreads();
34334 result = (wxValidator *)(arg1)->GetValidator();
34335 wxPyEndAllowThreads(__tstate);
34336 if (PyErr_Occurred()) SWIG_fail;
34337 }
34338 {
34339 resultobj = wxPyMake_wxObject(result, (bool)0);
34340 }
34341 return resultobj;
34342 fail:
34343 return NULL;
34344 }
34345
34346
34347 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34348 PyObject *resultobj = 0;
34349 wxWindow *arg1 = (wxWindow *) 0 ;
34350 bool result;
34351 void *argp1 = 0 ;
34352 int res1 = 0 ;
34353 PyObject *swig_obj[1] ;
34354
34355 if (!args) SWIG_fail;
34356 swig_obj[0] = args;
34357 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34358 if (!SWIG_IsOK(res1)) {
34359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
34360 }
34361 arg1 = reinterpret_cast< wxWindow * >(argp1);
34362 {
34363 PyThreadState* __tstate = wxPyBeginAllowThreads();
34364 result = (bool)(arg1)->Validate();
34365 wxPyEndAllowThreads(__tstate);
34366 if (PyErr_Occurred()) SWIG_fail;
34367 }
34368 {
34369 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34370 }
34371 return resultobj;
34372 fail:
34373 return NULL;
34374 }
34375
34376
34377 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34378 PyObject *resultobj = 0;
34379 wxWindow *arg1 = (wxWindow *) 0 ;
34380 bool result;
34381 void *argp1 = 0 ;
34382 int res1 = 0 ;
34383 PyObject *swig_obj[1] ;
34384
34385 if (!args) SWIG_fail;
34386 swig_obj[0] = args;
34387 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34388 if (!SWIG_IsOK(res1)) {
34389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
34390 }
34391 arg1 = reinterpret_cast< wxWindow * >(argp1);
34392 {
34393 PyThreadState* __tstate = wxPyBeginAllowThreads();
34394 result = (bool)(arg1)->TransferDataToWindow();
34395 wxPyEndAllowThreads(__tstate);
34396 if (PyErr_Occurred()) SWIG_fail;
34397 }
34398 {
34399 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34400 }
34401 return resultobj;
34402 fail:
34403 return NULL;
34404 }
34405
34406
34407 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34408 PyObject *resultobj = 0;
34409 wxWindow *arg1 = (wxWindow *) 0 ;
34410 bool result;
34411 void *argp1 = 0 ;
34412 int res1 = 0 ;
34413 PyObject *swig_obj[1] ;
34414
34415 if (!args) SWIG_fail;
34416 swig_obj[0] = args;
34417 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34418 if (!SWIG_IsOK(res1)) {
34419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
34420 }
34421 arg1 = reinterpret_cast< wxWindow * >(argp1);
34422 {
34423 PyThreadState* __tstate = wxPyBeginAllowThreads();
34424 result = (bool)(arg1)->TransferDataFromWindow();
34425 wxPyEndAllowThreads(__tstate);
34426 if (PyErr_Occurred()) SWIG_fail;
34427 }
34428 {
34429 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34430 }
34431 return resultobj;
34432 fail:
34433 return NULL;
34434 }
34435
34436
34437 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34438 PyObject *resultobj = 0;
34439 wxWindow *arg1 = (wxWindow *) 0 ;
34440 void *argp1 = 0 ;
34441 int res1 = 0 ;
34442 PyObject *swig_obj[1] ;
34443
34444 if (!args) SWIG_fail;
34445 swig_obj[0] = args;
34446 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34447 if (!SWIG_IsOK(res1)) {
34448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34449 }
34450 arg1 = reinterpret_cast< wxWindow * >(argp1);
34451 {
34452 PyThreadState* __tstate = wxPyBeginAllowThreads();
34453 (arg1)->InitDialog();
34454 wxPyEndAllowThreads(__tstate);
34455 if (PyErr_Occurred()) SWIG_fail;
34456 }
34457 resultobj = SWIG_Py_Void();
34458 return resultobj;
34459 fail:
34460 return NULL;
34461 }
34462
34463
34464 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34465 PyObject *resultobj = 0;
34466 wxWindow *arg1 = (wxWindow *) 0 ;
34467 wxAcceleratorTable *arg2 = 0 ;
34468 void *argp1 = 0 ;
34469 int res1 = 0 ;
34470 void *argp2 = 0 ;
34471 int res2 = 0 ;
34472 PyObject * obj0 = 0 ;
34473 PyObject * obj1 = 0 ;
34474 char * kwnames[] = {
34475 (char *) "self",(char *) "accel", NULL
34476 };
34477
34478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
34479 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34480 if (!SWIG_IsOK(res1)) {
34481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
34482 }
34483 arg1 = reinterpret_cast< wxWindow * >(argp1);
34484 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
34485 if (!SWIG_IsOK(res2)) {
34486 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
34487 }
34488 if (!argp2) {
34489 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
34490 }
34491 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
34492 {
34493 PyThreadState* __tstate = wxPyBeginAllowThreads();
34494 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
34495 wxPyEndAllowThreads(__tstate);
34496 if (PyErr_Occurred()) SWIG_fail;
34497 }
34498 resultobj = SWIG_Py_Void();
34499 return resultobj;
34500 fail:
34501 return NULL;
34502 }
34503
34504
34505 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34506 PyObject *resultobj = 0;
34507 wxWindow *arg1 = (wxWindow *) 0 ;
34508 wxAcceleratorTable *result = 0 ;
34509 void *argp1 = 0 ;
34510 int res1 = 0 ;
34511 PyObject *swig_obj[1] ;
34512
34513 if (!args) SWIG_fail;
34514 swig_obj[0] = args;
34515 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34516 if (!SWIG_IsOK(res1)) {
34517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
34518 }
34519 arg1 = reinterpret_cast< wxWindow * >(argp1);
34520 {
34521 PyThreadState* __tstate = wxPyBeginAllowThreads();
34522 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
34523 wxPyEndAllowThreads(__tstate);
34524 if (PyErr_Occurred()) SWIG_fail;
34525 }
34526 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
34527 return resultobj;
34528 fail:
34529 return NULL;
34530 }
34531
34532
34533 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34534 PyObject *resultobj = 0;
34535 wxWindow *arg1 = (wxWindow *) 0 ;
34536 int arg2 ;
34537 int arg3 ;
34538 int arg4 ;
34539 bool result;
34540 void *argp1 = 0 ;
34541 int res1 = 0 ;
34542 int val2 ;
34543 int ecode2 = 0 ;
34544 int val3 ;
34545 int ecode3 = 0 ;
34546 int val4 ;
34547 int ecode4 = 0 ;
34548 PyObject * obj0 = 0 ;
34549 PyObject * obj1 = 0 ;
34550 PyObject * obj2 = 0 ;
34551 PyObject * obj3 = 0 ;
34552 char * kwnames[] = {
34553 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
34554 };
34555
34556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34557 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34558 if (!SWIG_IsOK(res1)) {
34559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
34560 }
34561 arg1 = reinterpret_cast< wxWindow * >(argp1);
34562 ecode2 = SWIG_AsVal_int(obj1, &val2);
34563 if (!SWIG_IsOK(ecode2)) {
34564 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
34565 }
34566 arg2 = static_cast< int >(val2);
34567 ecode3 = SWIG_AsVal_int(obj2, &val3);
34568 if (!SWIG_IsOK(ecode3)) {
34569 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
34570 }
34571 arg3 = static_cast< int >(val3);
34572 ecode4 = SWIG_AsVal_int(obj3, &val4);
34573 if (!SWIG_IsOK(ecode4)) {
34574 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
34575 }
34576 arg4 = static_cast< int >(val4);
34577 {
34578 PyThreadState* __tstate = wxPyBeginAllowThreads();
34579 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
34580 wxPyEndAllowThreads(__tstate);
34581 if (PyErr_Occurred()) SWIG_fail;
34582 }
34583 {
34584 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34585 }
34586 return resultobj;
34587 fail:
34588 return NULL;
34589 }
34590
34591
34592 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34593 PyObject *resultobj = 0;
34594 wxWindow *arg1 = (wxWindow *) 0 ;
34595 int arg2 ;
34596 bool result;
34597 void *argp1 = 0 ;
34598 int res1 = 0 ;
34599 int val2 ;
34600 int ecode2 = 0 ;
34601 PyObject * obj0 = 0 ;
34602 PyObject * obj1 = 0 ;
34603 char * kwnames[] = {
34604 (char *) "self",(char *) "hotkeyId", NULL
34605 };
34606
34607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
34608 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34609 if (!SWIG_IsOK(res1)) {
34610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
34611 }
34612 arg1 = reinterpret_cast< wxWindow * >(argp1);
34613 ecode2 = SWIG_AsVal_int(obj1, &val2);
34614 if (!SWIG_IsOK(ecode2)) {
34615 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
34616 }
34617 arg2 = static_cast< int >(val2);
34618 {
34619 PyThreadState* __tstate = wxPyBeginAllowThreads();
34620 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
34621 wxPyEndAllowThreads(__tstate);
34622 if (PyErr_Occurred()) SWIG_fail;
34623 }
34624 {
34625 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34626 }
34627 return resultobj;
34628 fail:
34629 return NULL;
34630 }
34631
34632
34633 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34634 PyObject *resultobj = 0;
34635 wxWindow *arg1 = (wxWindow *) 0 ;
34636 wxPoint *arg2 = 0 ;
34637 wxPoint result;
34638 void *argp1 = 0 ;
34639 int res1 = 0 ;
34640 wxPoint temp2 ;
34641 PyObject * obj0 = 0 ;
34642 PyObject * obj1 = 0 ;
34643 char * kwnames[] = {
34644 (char *) "self",(char *) "pt", NULL
34645 };
34646
34647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
34648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34649 if (!SWIG_IsOK(res1)) {
34650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
34651 }
34652 arg1 = reinterpret_cast< wxWindow * >(argp1);
34653 {
34654 arg2 = &temp2;
34655 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34656 }
34657 {
34658 PyThreadState* __tstate = wxPyBeginAllowThreads();
34659 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
34660 wxPyEndAllowThreads(__tstate);
34661 if (PyErr_Occurred()) SWIG_fail;
34662 }
34663 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34664 return resultobj;
34665 fail:
34666 return NULL;
34667 }
34668
34669
34670 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34671 PyObject *resultobj = 0;
34672 wxWindow *arg1 = (wxWindow *) 0 ;
34673 wxSize *arg2 = 0 ;
34674 wxSize result;
34675 void *argp1 = 0 ;
34676 int res1 = 0 ;
34677 wxSize temp2 ;
34678 PyObject * obj0 = 0 ;
34679 PyObject * obj1 = 0 ;
34680 char * kwnames[] = {
34681 (char *) "self",(char *) "sz", NULL
34682 };
34683
34684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",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_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
34688 }
34689 arg1 = reinterpret_cast< wxWindow * >(argp1);
34690 {
34691 arg2 = &temp2;
34692 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34693 }
34694 {
34695 PyThreadState* __tstate = wxPyBeginAllowThreads();
34696 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
34697 wxPyEndAllowThreads(__tstate);
34698 if (PyErr_Occurred()) SWIG_fail;
34699 }
34700 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34701 return resultobj;
34702 fail:
34703 return NULL;
34704 }
34705
34706
34707 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34708 PyObject *resultobj = 0;
34709 wxWindow *arg1 = (wxWindow *) 0 ;
34710 wxPoint *arg2 = 0 ;
34711 wxPoint result;
34712 void *argp1 = 0 ;
34713 int res1 = 0 ;
34714 wxPoint temp2 ;
34715 PyObject * obj0 = 0 ;
34716 PyObject * obj1 = 0 ;
34717 char * kwnames[] = {
34718 (char *) "self",(char *) "pt", NULL
34719 };
34720
34721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
34722 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34723 if (!SWIG_IsOK(res1)) {
34724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
34725 }
34726 arg1 = reinterpret_cast< wxWindow * >(argp1);
34727 {
34728 arg2 = &temp2;
34729 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34730 }
34731 {
34732 PyThreadState* __tstate = wxPyBeginAllowThreads();
34733 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
34734 wxPyEndAllowThreads(__tstate);
34735 if (PyErr_Occurred()) SWIG_fail;
34736 }
34737 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34738 return resultobj;
34739 fail:
34740 return NULL;
34741 }
34742
34743
34744 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34745 PyObject *resultobj = 0;
34746 wxWindow *arg1 = (wxWindow *) 0 ;
34747 wxSize *arg2 = 0 ;
34748 wxSize result;
34749 void *argp1 = 0 ;
34750 int res1 = 0 ;
34751 wxSize temp2 ;
34752 PyObject * obj0 = 0 ;
34753 PyObject * obj1 = 0 ;
34754 char * kwnames[] = {
34755 (char *) "self",(char *) "sz", NULL
34756 };
34757
34758 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
34759 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34760 if (!SWIG_IsOK(res1)) {
34761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
34762 }
34763 arg1 = reinterpret_cast< wxWindow * >(argp1);
34764 {
34765 arg2 = &temp2;
34766 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34767 }
34768 {
34769 PyThreadState* __tstate = wxPyBeginAllowThreads();
34770 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
34771 wxPyEndAllowThreads(__tstate);
34772 if (PyErr_Occurred()) SWIG_fail;
34773 }
34774 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34775 return resultobj;
34776 fail:
34777 return NULL;
34778 }
34779
34780
34781 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34782 PyObject *resultobj = 0;
34783 wxWindow *arg1 = (wxWindow *) 0 ;
34784 wxPoint *arg2 = 0 ;
34785 wxPoint result;
34786 void *argp1 = 0 ;
34787 int res1 = 0 ;
34788 wxPoint temp2 ;
34789 PyObject * obj0 = 0 ;
34790 PyObject * obj1 = 0 ;
34791 char * kwnames[] = {
34792 (char *) "self",(char *) "pt", NULL
34793 };
34794
34795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
34796 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34797 if (!SWIG_IsOK(res1)) {
34798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34799 }
34800 arg1 = reinterpret_cast< wxWindow * >(argp1);
34801 {
34802 arg2 = &temp2;
34803 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34804 }
34805 {
34806 PyThreadState* __tstate = wxPyBeginAllowThreads();
34807 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
34808 wxPyEndAllowThreads(__tstate);
34809 if (PyErr_Occurred()) SWIG_fail;
34810 }
34811 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34812 return resultobj;
34813 fail:
34814 return NULL;
34815 }
34816
34817
34818 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34819 PyObject *resultobj = 0;
34820 wxWindow *arg1 = (wxWindow *) 0 ;
34821 wxSize *arg2 = 0 ;
34822 wxSize result;
34823 void *argp1 = 0 ;
34824 int res1 = 0 ;
34825 wxSize temp2 ;
34826 PyObject * obj0 = 0 ;
34827 PyObject * obj1 = 0 ;
34828 char * kwnames[] = {
34829 (char *) "self",(char *) "sz", NULL
34830 };
34831
34832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
34833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34834 if (!SWIG_IsOK(res1)) {
34835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34836 }
34837 arg1 = reinterpret_cast< wxWindow * >(argp1);
34838 {
34839 arg2 = &temp2;
34840 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34841 }
34842 {
34843 PyThreadState* __tstate = wxPyBeginAllowThreads();
34844 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
34845 wxPyEndAllowThreads(__tstate);
34846 if (PyErr_Occurred()) SWIG_fail;
34847 }
34848 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34849 return resultobj;
34850 fail:
34851 return NULL;
34852 }
34853
34854
34855 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34856 PyObject *resultobj = 0;
34857 wxWindow *arg1 = (wxWindow *) 0 ;
34858 int arg2 ;
34859 int arg3 ;
34860 void *argp1 = 0 ;
34861 int res1 = 0 ;
34862 int val2 ;
34863 int ecode2 = 0 ;
34864 int val3 ;
34865 int ecode3 = 0 ;
34866 PyObject * obj0 = 0 ;
34867 PyObject * obj1 = 0 ;
34868 PyObject * obj2 = 0 ;
34869 char * kwnames[] = {
34870 (char *) "self",(char *) "x",(char *) "y", NULL
34871 };
34872
34873 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34874 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34875 if (!SWIG_IsOK(res1)) {
34876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
34877 }
34878 arg1 = reinterpret_cast< wxWindow * >(argp1);
34879 ecode2 = SWIG_AsVal_int(obj1, &val2);
34880 if (!SWIG_IsOK(ecode2)) {
34881 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
34882 }
34883 arg2 = static_cast< int >(val2);
34884 ecode3 = SWIG_AsVal_int(obj2, &val3);
34885 if (!SWIG_IsOK(ecode3)) {
34886 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
34887 }
34888 arg3 = static_cast< int >(val3);
34889 {
34890 PyThreadState* __tstate = wxPyBeginAllowThreads();
34891 (arg1)->WarpPointer(arg2,arg3);
34892 wxPyEndAllowThreads(__tstate);
34893 if (PyErr_Occurred()) SWIG_fail;
34894 }
34895 resultobj = SWIG_Py_Void();
34896 return resultobj;
34897 fail:
34898 return NULL;
34899 }
34900
34901
34902 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34903 PyObject *resultobj = 0;
34904 wxWindow *arg1 = (wxWindow *) 0 ;
34905 void *argp1 = 0 ;
34906 int res1 = 0 ;
34907 PyObject *swig_obj[1] ;
34908
34909 if (!args) SWIG_fail;
34910 swig_obj[0] = args;
34911 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34912 if (!SWIG_IsOK(res1)) {
34913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34914 }
34915 arg1 = reinterpret_cast< wxWindow * >(argp1);
34916 {
34917 PyThreadState* __tstate = wxPyBeginAllowThreads();
34918 (arg1)->CaptureMouse();
34919 wxPyEndAllowThreads(__tstate);
34920 if (PyErr_Occurred()) SWIG_fail;
34921 }
34922 resultobj = SWIG_Py_Void();
34923 return resultobj;
34924 fail:
34925 return NULL;
34926 }
34927
34928
34929 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34930 PyObject *resultobj = 0;
34931 wxWindow *arg1 = (wxWindow *) 0 ;
34932 void *argp1 = 0 ;
34933 int res1 = 0 ;
34934 PyObject *swig_obj[1] ;
34935
34936 if (!args) SWIG_fail;
34937 swig_obj[0] = args;
34938 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34939 if (!SWIG_IsOK(res1)) {
34940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34941 }
34942 arg1 = reinterpret_cast< wxWindow * >(argp1);
34943 {
34944 PyThreadState* __tstate = wxPyBeginAllowThreads();
34945 (arg1)->ReleaseMouse();
34946 wxPyEndAllowThreads(__tstate);
34947 if (PyErr_Occurred()) SWIG_fail;
34948 }
34949 resultobj = SWIG_Py_Void();
34950 return resultobj;
34951 fail:
34952 return NULL;
34953 }
34954
34955
34956 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34957 PyObject *resultobj = 0;
34958 wxWindow *result = 0 ;
34959
34960 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
34961 {
34962 if (!wxPyCheckForApp()) SWIG_fail;
34963 PyThreadState* __tstate = wxPyBeginAllowThreads();
34964 result = (wxWindow *)wxWindow::GetCapture();
34965 wxPyEndAllowThreads(__tstate);
34966 if (PyErr_Occurred()) SWIG_fail;
34967 }
34968 {
34969 resultobj = wxPyMake_wxObject(result, 0);
34970 }
34971 return resultobj;
34972 fail:
34973 return NULL;
34974 }
34975
34976
34977 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34978 PyObject *resultobj = 0;
34979 wxWindow *arg1 = (wxWindow *) 0 ;
34980 bool 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_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
34990 }
34991 arg1 = reinterpret_cast< wxWindow * >(argp1);
34992 {
34993 PyThreadState* __tstate = wxPyBeginAllowThreads();
34994 result = (bool)((wxWindow const *)arg1)->HasCapture();
34995 wxPyEndAllowThreads(__tstate);
34996 if (PyErr_Occurred()) SWIG_fail;
34997 }
34998 {
34999 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35000 }
35001 return resultobj;
35002 fail:
35003 return NULL;
35004 }
35005
35006
35007 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35008 PyObject *resultobj = 0;
35009 wxWindow *arg1 = (wxWindow *) 0 ;
35010 bool arg2 = (bool) true ;
35011 wxRect *arg3 = (wxRect *) NULL ;
35012 void *argp1 = 0 ;
35013 int res1 = 0 ;
35014 bool val2 ;
35015 int ecode2 = 0 ;
35016 void *argp3 = 0 ;
35017 int res3 = 0 ;
35018 PyObject * obj0 = 0 ;
35019 PyObject * obj1 = 0 ;
35020 PyObject * obj2 = 0 ;
35021 char * kwnames[] = {
35022 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
35023 };
35024
35025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35026 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35027 if (!SWIG_IsOK(res1)) {
35028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
35029 }
35030 arg1 = reinterpret_cast< wxWindow * >(argp1);
35031 if (obj1) {
35032 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35033 if (!SWIG_IsOK(ecode2)) {
35034 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
35035 }
35036 arg2 = static_cast< bool >(val2);
35037 }
35038 if (obj2) {
35039 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
35040 if (!SWIG_IsOK(res3)) {
35041 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
35042 }
35043 arg3 = reinterpret_cast< wxRect * >(argp3);
35044 }
35045 {
35046 PyThreadState* __tstate = wxPyBeginAllowThreads();
35047 (arg1)->Refresh(arg2,(wxRect const *)arg3);
35048 wxPyEndAllowThreads(__tstate);
35049 if (PyErr_Occurred()) SWIG_fail;
35050 }
35051 resultobj = SWIG_Py_Void();
35052 return resultobj;
35053 fail:
35054 return NULL;
35055 }
35056
35057
35058 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35059 PyObject *resultobj = 0;
35060 wxWindow *arg1 = (wxWindow *) 0 ;
35061 wxRect *arg2 = 0 ;
35062 bool arg3 = (bool) true ;
35063 void *argp1 = 0 ;
35064 int res1 = 0 ;
35065 wxRect temp2 ;
35066 bool val3 ;
35067 int ecode3 = 0 ;
35068 PyObject * obj0 = 0 ;
35069 PyObject * obj1 = 0 ;
35070 PyObject * obj2 = 0 ;
35071 char * kwnames[] = {
35072 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
35073 };
35074
35075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35077 if (!SWIG_IsOK(res1)) {
35078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
35079 }
35080 arg1 = reinterpret_cast< wxWindow * >(argp1);
35081 {
35082 arg2 = &temp2;
35083 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
35084 }
35085 if (obj2) {
35086 ecode3 = SWIG_AsVal_bool(obj2, &val3);
35087 if (!SWIG_IsOK(ecode3)) {
35088 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
35089 }
35090 arg3 = static_cast< bool >(val3);
35091 }
35092 {
35093 PyThreadState* __tstate = wxPyBeginAllowThreads();
35094 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
35095 wxPyEndAllowThreads(__tstate);
35096 if (PyErr_Occurred()) SWIG_fail;
35097 }
35098 resultobj = SWIG_Py_Void();
35099 return resultobj;
35100 fail:
35101 return NULL;
35102 }
35103
35104
35105 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35106 PyObject *resultobj = 0;
35107 wxWindow *arg1 = (wxWindow *) 0 ;
35108 void *argp1 = 0 ;
35109 int res1 = 0 ;
35110 PyObject *swig_obj[1] ;
35111
35112 if (!args) SWIG_fail;
35113 swig_obj[0] = args;
35114 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35115 if (!SWIG_IsOK(res1)) {
35116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
35117 }
35118 arg1 = reinterpret_cast< wxWindow * >(argp1);
35119 {
35120 PyThreadState* __tstate = wxPyBeginAllowThreads();
35121 (arg1)->Update();
35122 wxPyEndAllowThreads(__tstate);
35123 if (PyErr_Occurred()) SWIG_fail;
35124 }
35125 resultobj = SWIG_Py_Void();
35126 return resultobj;
35127 fail:
35128 return NULL;
35129 }
35130
35131
35132 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35133 PyObject *resultobj = 0;
35134 wxWindow *arg1 = (wxWindow *) 0 ;
35135 void *argp1 = 0 ;
35136 int res1 = 0 ;
35137 PyObject *swig_obj[1] ;
35138
35139 if (!args) SWIG_fail;
35140 swig_obj[0] = args;
35141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35142 if (!SWIG_IsOK(res1)) {
35143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
35144 }
35145 arg1 = reinterpret_cast< wxWindow * >(argp1);
35146 {
35147 PyThreadState* __tstate = wxPyBeginAllowThreads();
35148 (arg1)->ClearBackground();
35149 wxPyEndAllowThreads(__tstate);
35150 if (PyErr_Occurred()) SWIG_fail;
35151 }
35152 resultobj = SWIG_Py_Void();
35153 return resultobj;
35154 fail:
35155 return NULL;
35156 }
35157
35158
35159 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35160 PyObject *resultobj = 0;
35161 wxWindow *arg1 = (wxWindow *) 0 ;
35162 void *argp1 = 0 ;
35163 int res1 = 0 ;
35164 PyObject *swig_obj[1] ;
35165
35166 if (!args) SWIG_fail;
35167 swig_obj[0] = args;
35168 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35169 if (!SWIG_IsOK(res1)) {
35170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
35171 }
35172 arg1 = reinterpret_cast< wxWindow * >(argp1);
35173 {
35174 PyThreadState* __tstate = wxPyBeginAllowThreads();
35175 (arg1)->Freeze();
35176 wxPyEndAllowThreads(__tstate);
35177 if (PyErr_Occurred()) SWIG_fail;
35178 }
35179 resultobj = SWIG_Py_Void();
35180 return resultobj;
35181 fail:
35182 return NULL;
35183 }
35184
35185
35186 SWIGINTERN PyObject *_wrap_Window_IsFrozen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35187 PyObject *resultobj = 0;
35188 wxWindow *arg1 = (wxWindow *) 0 ;
35189 bool result;
35190 void *argp1 = 0 ;
35191 int res1 = 0 ;
35192 PyObject *swig_obj[1] ;
35193
35194 if (!args) SWIG_fail;
35195 swig_obj[0] = args;
35196 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35197 if (!SWIG_IsOK(res1)) {
35198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsFrozen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35199 }
35200 arg1 = reinterpret_cast< wxWindow * >(argp1);
35201 {
35202 PyThreadState* __tstate = wxPyBeginAllowThreads();
35203 result = (bool)((wxWindow const *)arg1)->IsFrozen();
35204 wxPyEndAllowThreads(__tstate);
35205 if (PyErr_Occurred()) SWIG_fail;
35206 }
35207 {
35208 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35209 }
35210 return resultobj;
35211 fail:
35212 return NULL;
35213 }
35214
35215
35216 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35217 PyObject *resultobj = 0;
35218 wxWindow *arg1 = (wxWindow *) 0 ;
35219 void *argp1 = 0 ;
35220 int res1 = 0 ;
35221 PyObject *swig_obj[1] ;
35222
35223 if (!args) SWIG_fail;
35224 swig_obj[0] = args;
35225 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35226 if (!SWIG_IsOK(res1)) {
35227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
35228 }
35229 arg1 = reinterpret_cast< wxWindow * >(argp1);
35230 {
35231 PyThreadState* __tstate = wxPyBeginAllowThreads();
35232 (arg1)->Thaw();
35233 wxPyEndAllowThreads(__tstate);
35234 if (PyErr_Occurred()) SWIG_fail;
35235 }
35236 resultobj = SWIG_Py_Void();
35237 return resultobj;
35238 fail:
35239 return NULL;
35240 }
35241
35242
35243 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35244 PyObject *resultobj = 0;
35245 wxWindow *arg1 = (wxWindow *) 0 ;
35246 wxDC *arg2 = 0 ;
35247 void *argp1 = 0 ;
35248 int res1 = 0 ;
35249 void *argp2 = 0 ;
35250 int res2 = 0 ;
35251 PyObject * obj0 = 0 ;
35252 PyObject * obj1 = 0 ;
35253 char * kwnames[] = {
35254 (char *) "self",(char *) "dc", NULL
35255 };
35256
35257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
35258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35259 if (!SWIG_IsOK(res1)) {
35260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
35261 }
35262 arg1 = reinterpret_cast< wxWindow * >(argp1);
35263 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
35264 if (!SWIG_IsOK(res2)) {
35265 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
35266 }
35267 if (!argp2) {
35268 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
35269 }
35270 arg2 = reinterpret_cast< wxDC * >(argp2);
35271 {
35272 PyThreadState* __tstate = wxPyBeginAllowThreads();
35273 (arg1)->PrepareDC(*arg2);
35274 wxPyEndAllowThreads(__tstate);
35275 if (PyErr_Occurred()) SWIG_fail;
35276 }
35277 resultobj = SWIG_Py_Void();
35278 return resultobj;
35279 fail:
35280 return NULL;
35281 }
35282
35283
35284 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35285 PyObject *resultobj = 0;
35286 wxWindow *arg1 = (wxWindow *) 0 ;
35287 wxRegion *result = 0 ;
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_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
35297 }
35298 arg1 = reinterpret_cast< wxWindow * >(argp1);
35299 {
35300 PyThreadState* __tstate = wxPyBeginAllowThreads();
35301 {
35302 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
35303 result = (wxRegion *) &_result_ref;
35304 }
35305 wxPyEndAllowThreads(__tstate);
35306 if (PyErr_Occurred()) SWIG_fail;
35307 }
35308 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
35309 return resultobj;
35310 fail:
35311 return NULL;
35312 }
35313
35314
35315 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35316 PyObject *resultobj = 0;
35317 wxWindow *arg1 = (wxWindow *) 0 ;
35318 wxRect result;
35319 void *argp1 = 0 ;
35320 int res1 = 0 ;
35321 PyObject *swig_obj[1] ;
35322
35323 if (!args) SWIG_fail;
35324 swig_obj[0] = args;
35325 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35326 if (!SWIG_IsOK(res1)) {
35327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
35328 }
35329 arg1 = reinterpret_cast< wxWindow * >(argp1);
35330 {
35331 PyThreadState* __tstate = wxPyBeginAllowThreads();
35332 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
35333 wxPyEndAllowThreads(__tstate);
35334 if (PyErr_Occurred()) SWIG_fail;
35335 }
35336 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
35337 return resultobj;
35338 fail:
35339 return NULL;
35340 }
35341
35342
35343 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35344 PyObject *resultobj = 0;
35345 wxWindow *arg1 = (wxWindow *) 0 ;
35346 int arg2 ;
35347 int arg3 ;
35348 int arg4 = (int) 1 ;
35349 int arg5 = (int) 1 ;
35350 bool result;
35351 void *argp1 = 0 ;
35352 int res1 = 0 ;
35353 int val2 ;
35354 int ecode2 = 0 ;
35355 int val3 ;
35356 int ecode3 = 0 ;
35357 int val4 ;
35358 int ecode4 = 0 ;
35359 int val5 ;
35360 int ecode5 = 0 ;
35361 PyObject * obj0 = 0 ;
35362 PyObject * obj1 = 0 ;
35363 PyObject * obj2 = 0 ;
35364 PyObject * obj3 = 0 ;
35365 PyObject * obj4 = 0 ;
35366 char * kwnames[] = {
35367 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
35368 };
35369
35370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
35371 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35372 if (!SWIG_IsOK(res1)) {
35373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
35374 }
35375 arg1 = reinterpret_cast< wxWindow * >(argp1);
35376 ecode2 = SWIG_AsVal_int(obj1, &val2);
35377 if (!SWIG_IsOK(ecode2)) {
35378 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
35379 }
35380 arg2 = static_cast< int >(val2);
35381 ecode3 = SWIG_AsVal_int(obj2, &val3);
35382 if (!SWIG_IsOK(ecode3)) {
35383 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
35384 }
35385 arg3 = static_cast< int >(val3);
35386 if (obj3) {
35387 ecode4 = SWIG_AsVal_int(obj3, &val4);
35388 if (!SWIG_IsOK(ecode4)) {
35389 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
35390 }
35391 arg4 = static_cast< int >(val4);
35392 }
35393 if (obj4) {
35394 ecode5 = SWIG_AsVal_int(obj4, &val5);
35395 if (!SWIG_IsOK(ecode5)) {
35396 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
35397 }
35398 arg5 = static_cast< int >(val5);
35399 }
35400 {
35401 PyThreadState* __tstate = wxPyBeginAllowThreads();
35402 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
35403 wxPyEndAllowThreads(__tstate);
35404 if (PyErr_Occurred()) SWIG_fail;
35405 }
35406 {
35407 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35408 }
35409 return resultobj;
35410 fail:
35411 return NULL;
35412 }
35413
35414
35415 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35416 PyObject *resultobj = 0;
35417 wxWindow *arg1 = (wxWindow *) 0 ;
35418 wxPoint *arg2 = 0 ;
35419 bool result;
35420 void *argp1 = 0 ;
35421 int res1 = 0 ;
35422 wxPoint temp2 ;
35423 PyObject * obj0 = 0 ;
35424 PyObject * obj1 = 0 ;
35425 char * kwnames[] = {
35426 (char *) "self",(char *) "pt", NULL
35427 };
35428
35429 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
35430 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35431 if (!SWIG_IsOK(res1)) {
35432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
35433 }
35434 arg1 = reinterpret_cast< wxWindow * >(argp1);
35435 {
35436 arg2 = &temp2;
35437 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35438 }
35439 {
35440 PyThreadState* __tstate = wxPyBeginAllowThreads();
35441 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
35442 wxPyEndAllowThreads(__tstate);
35443 if (PyErr_Occurred()) SWIG_fail;
35444 }
35445 {
35446 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35447 }
35448 return resultobj;
35449 fail:
35450 return NULL;
35451 }
35452
35453
35454 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35455 PyObject *resultobj = 0;
35456 wxWindow *arg1 = (wxWindow *) 0 ;
35457 wxRect *arg2 = 0 ;
35458 bool result;
35459 void *argp1 = 0 ;
35460 int res1 = 0 ;
35461 wxRect temp2 ;
35462 PyObject * obj0 = 0 ;
35463 PyObject * obj1 = 0 ;
35464 char * kwnames[] = {
35465 (char *) "self",(char *) "rect", NULL
35466 };
35467
35468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
35469 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35470 if (!SWIG_IsOK(res1)) {
35471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
35472 }
35473 arg1 = reinterpret_cast< wxWindow * >(argp1);
35474 {
35475 arg2 = &temp2;
35476 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
35477 }
35478 {
35479 PyThreadState* __tstate = wxPyBeginAllowThreads();
35480 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
35481 wxPyEndAllowThreads(__tstate);
35482 if (PyErr_Occurred()) SWIG_fail;
35483 }
35484 {
35485 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35486 }
35487 return resultobj;
35488 fail:
35489 return NULL;
35490 }
35491
35492
35493 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35494 PyObject *resultobj = 0;
35495 wxWindow *arg1 = (wxWindow *) 0 ;
35496 SwigValueWrapper<wxVisualAttributes > result;
35497 void *argp1 = 0 ;
35498 int res1 = 0 ;
35499 PyObject *swig_obj[1] ;
35500
35501 if (!args) SWIG_fail;
35502 swig_obj[0] = args;
35503 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35504 if (!SWIG_IsOK(res1)) {
35505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
35506 }
35507 arg1 = reinterpret_cast< wxWindow * >(argp1);
35508 {
35509 PyThreadState* __tstate = wxPyBeginAllowThreads();
35510 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
35511 wxPyEndAllowThreads(__tstate);
35512 if (PyErr_Occurred()) SWIG_fail;
35513 }
35514 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
35515 return resultobj;
35516 fail:
35517 return NULL;
35518 }
35519
35520
35521 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35522 PyObject *resultobj = 0;
35523 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
35524 SwigValueWrapper<wxVisualAttributes > result;
35525 int val1 ;
35526 int ecode1 = 0 ;
35527 PyObject * obj0 = 0 ;
35528 char * kwnames[] = {
35529 (char *) "variant", NULL
35530 };
35531
35532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
35533 if (obj0) {
35534 ecode1 = SWIG_AsVal_int(obj0, &val1);
35535 if (!SWIG_IsOK(ecode1)) {
35536 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
35537 }
35538 arg1 = static_cast< wxWindowVariant >(val1);
35539 }
35540 {
35541 if (!wxPyCheckForApp()) SWIG_fail;
35542 PyThreadState* __tstate = wxPyBeginAllowThreads();
35543 result = wxWindow::GetClassDefaultAttributes(arg1);
35544 wxPyEndAllowThreads(__tstate);
35545 if (PyErr_Occurred()) SWIG_fail;
35546 }
35547 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
35548 return resultobj;
35549 fail:
35550 return NULL;
35551 }
35552
35553
35554 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35555 PyObject *resultobj = 0;
35556 wxWindow *arg1 = (wxWindow *) 0 ;
35557 wxColour *arg2 = 0 ;
35558 bool result;
35559 void *argp1 = 0 ;
35560 int res1 = 0 ;
35561 wxColour temp2 ;
35562 PyObject * obj0 = 0 ;
35563 PyObject * obj1 = 0 ;
35564 char * kwnames[] = {
35565 (char *) "self",(char *) "colour", NULL
35566 };
35567
35568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35569 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35570 if (!SWIG_IsOK(res1)) {
35571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35572 }
35573 arg1 = reinterpret_cast< wxWindow * >(argp1);
35574 {
35575 arg2 = &temp2;
35576 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35577 }
35578 {
35579 PyThreadState* __tstate = wxPyBeginAllowThreads();
35580 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
35581 wxPyEndAllowThreads(__tstate);
35582 if (PyErr_Occurred()) SWIG_fail;
35583 }
35584 {
35585 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35586 }
35587 return resultobj;
35588 fail:
35589 return NULL;
35590 }
35591
35592
35593 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35594 PyObject *resultobj = 0;
35595 wxWindow *arg1 = (wxWindow *) 0 ;
35596 wxColour *arg2 = 0 ;
35597 void *argp1 = 0 ;
35598 int res1 = 0 ;
35599 wxColour temp2 ;
35600 PyObject * obj0 = 0 ;
35601 PyObject * obj1 = 0 ;
35602 char * kwnames[] = {
35603 (char *) "self",(char *) "colour", NULL
35604 };
35605
35606 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35607 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35608 if (!SWIG_IsOK(res1)) {
35609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35610 }
35611 arg1 = reinterpret_cast< wxWindow * >(argp1);
35612 {
35613 arg2 = &temp2;
35614 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35615 }
35616 {
35617 PyThreadState* __tstate = wxPyBeginAllowThreads();
35618 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
35619 wxPyEndAllowThreads(__tstate);
35620 if (PyErr_Occurred()) SWIG_fail;
35621 }
35622 resultobj = SWIG_Py_Void();
35623 return resultobj;
35624 fail:
35625 return NULL;
35626 }
35627
35628
35629 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35630 PyObject *resultobj = 0;
35631 wxWindow *arg1 = (wxWindow *) 0 ;
35632 wxColour *arg2 = 0 ;
35633 bool result;
35634 void *argp1 = 0 ;
35635 int res1 = 0 ;
35636 wxColour temp2 ;
35637 PyObject * obj0 = 0 ;
35638 PyObject * obj1 = 0 ;
35639 char * kwnames[] = {
35640 (char *) "self",(char *) "colour", NULL
35641 };
35642
35643 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35644 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35645 if (!SWIG_IsOK(res1)) {
35646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35647 }
35648 arg1 = reinterpret_cast< wxWindow * >(argp1);
35649 {
35650 arg2 = &temp2;
35651 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35652 }
35653 {
35654 PyThreadState* __tstate = wxPyBeginAllowThreads();
35655 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
35656 wxPyEndAllowThreads(__tstate);
35657 if (PyErr_Occurred()) SWIG_fail;
35658 }
35659 {
35660 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35661 }
35662 return resultobj;
35663 fail:
35664 return NULL;
35665 }
35666
35667
35668 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35669 PyObject *resultobj = 0;
35670 wxWindow *arg1 = (wxWindow *) 0 ;
35671 wxColour *arg2 = 0 ;
35672 void *argp1 = 0 ;
35673 int res1 = 0 ;
35674 wxColour temp2 ;
35675 PyObject * obj0 = 0 ;
35676 PyObject * obj1 = 0 ;
35677 char * kwnames[] = {
35678 (char *) "self",(char *) "colour", NULL
35679 };
35680
35681 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35682 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35683 if (!SWIG_IsOK(res1)) {
35684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35685 }
35686 arg1 = reinterpret_cast< wxWindow * >(argp1);
35687 {
35688 arg2 = &temp2;
35689 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35690 }
35691 {
35692 PyThreadState* __tstate = wxPyBeginAllowThreads();
35693 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
35694 wxPyEndAllowThreads(__tstate);
35695 if (PyErr_Occurred()) SWIG_fail;
35696 }
35697 resultobj = SWIG_Py_Void();
35698 return resultobj;
35699 fail:
35700 return NULL;
35701 }
35702
35703
35704 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35705 PyObject *resultobj = 0;
35706 wxWindow *arg1 = (wxWindow *) 0 ;
35707 wxColour result;
35708 void *argp1 = 0 ;
35709 int res1 = 0 ;
35710 PyObject *swig_obj[1] ;
35711
35712 if (!args) SWIG_fail;
35713 swig_obj[0] = args;
35714 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35715 if (!SWIG_IsOK(res1)) {
35716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35717 }
35718 arg1 = reinterpret_cast< wxWindow * >(argp1);
35719 {
35720 PyThreadState* __tstate = wxPyBeginAllowThreads();
35721 result = ((wxWindow const *)arg1)->GetBackgroundColour();
35722 wxPyEndAllowThreads(__tstate);
35723 if (PyErr_Occurred()) SWIG_fail;
35724 }
35725 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
35726 return resultobj;
35727 fail:
35728 return NULL;
35729 }
35730
35731
35732 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35733 PyObject *resultobj = 0;
35734 wxWindow *arg1 = (wxWindow *) 0 ;
35735 wxColour result;
35736 void *argp1 = 0 ;
35737 int res1 = 0 ;
35738 PyObject *swig_obj[1] ;
35739
35740 if (!args) SWIG_fail;
35741 swig_obj[0] = args;
35742 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35743 if (!SWIG_IsOK(res1)) {
35744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35745 }
35746 arg1 = reinterpret_cast< wxWindow * >(argp1);
35747 {
35748 PyThreadState* __tstate = wxPyBeginAllowThreads();
35749 result = ((wxWindow const *)arg1)->GetForegroundColour();
35750 wxPyEndAllowThreads(__tstate);
35751 if (PyErr_Occurred()) SWIG_fail;
35752 }
35753 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
35754 return resultobj;
35755 fail:
35756 return NULL;
35757 }
35758
35759
35760 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35761 PyObject *resultobj = 0;
35762 wxWindow *arg1 = (wxWindow *) 0 ;
35763 bool result;
35764 void *argp1 = 0 ;
35765 int res1 = 0 ;
35766 PyObject *swig_obj[1] ;
35767
35768 if (!args) SWIG_fail;
35769 swig_obj[0] = args;
35770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35771 if (!SWIG_IsOK(res1)) {
35772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35773 }
35774 arg1 = reinterpret_cast< wxWindow * >(argp1);
35775 {
35776 PyThreadState* __tstate = wxPyBeginAllowThreads();
35777 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
35778 wxPyEndAllowThreads(__tstate);
35779 if (PyErr_Occurred()) SWIG_fail;
35780 }
35781 {
35782 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35783 }
35784 return resultobj;
35785 fail:
35786 return NULL;
35787 }
35788
35789
35790 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35791 PyObject *resultobj = 0;
35792 wxWindow *arg1 = (wxWindow *) 0 ;
35793 bool result;
35794 void *argp1 = 0 ;
35795 int res1 = 0 ;
35796 PyObject *swig_obj[1] ;
35797
35798 if (!args) SWIG_fail;
35799 swig_obj[0] = args;
35800 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35801 if (!SWIG_IsOK(res1)) {
35802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
35803 }
35804 arg1 = reinterpret_cast< wxWindow * >(argp1);
35805 {
35806 PyThreadState* __tstate = wxPyBeginAllowThreads();
35807 result = (bool)((wxWindow const *)arg1)->UseBgCol();
35808 wxPyEndAllowThreads(__tstate);
35809 if (PyErr_Occurred()) SWIG_fail;
35810 }
35811 {
35812 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35813 }
35814 return resultobj;
35815 fail:
35816 return NULL;
35817 }
35818
35819
35820 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35821 PyObject *resultobj = 0;
35822 wxWindow *arg1 = (wxWindow *) 0 ;
35823 wxBackgroundStyle arg2 ;
35824 bool result;
35825 void *argp1 = 0 ;
35826 int res1 = 0 ;
35827 int val2 ;
35828 int ecode2 = 0 ;
35829 PyObject * obj0 = 0 ;
35830 PyObject * obj1 = 0 ;
35831 char * kwnames[] = {
35832 (char *) "self",(char *) "style", NULL
35833 };
35834
35835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
35836 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35837 if (!SWIG_IsOK(res1)) {
35838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
35839 }
35840 arg1 = reinterpret_cast< wxWindow * >(argp1);
35841 ecode2 = SWIG_AsVal_int(obj1, &val2);
35842 if (!SWIG_IsOK(ecode2)) {
35843 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
35844 }
35845 arg2 = static_cast< wxBackgroundStyle >(val2);
35846 {
35847 PyThreadState* __tstate = wxPyBeginAllowThreads();
35848 result = (bool)(arg1)->SetBackgroundStyle(arg2);
35849 wxPyEndAllowThreads(__tstate);
35850 if (PyErr_Occurred()) SWIG_fail;
35851 }
35852 {
35853 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35854 }
35855 return resultobj;
35856 fail:
35857 return NULL;
35858 }
35859
35860
35861 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35862 PyObject *resultobj = 0;
35863 wxWindow *arg1 = (wxWindow *) 0 ;
35864 wxBackgroundStyle result;
35865 void *argp1 = 0 ;
35866 int res1 = 0 ;
35867 PyObject *swig_obj[1] ;
35868
35869 if (!args) SWIG_fail;
35870 swig_obj[0] = args;
35871 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35872 if (!SWIG_IsOK(res1)) {
35873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
35874 }
35875 arg1 = reinterpret_cast< wxWindow * >(argp1);
35876 {
35877 PyThreadState* __tstate = wxPyBeginAllowThreads();
35878 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
35879 wxPyEndAllowThreads(__tstate);
35880 if (PyErr_Occurred()) SWIG_fail;
35881 }
35882 resultobj = SWIG_From_int(static_cast< int >(result));
35883 return resultobj;
35884 fail:
35885 return NULL;
35886 }
35887
35888
35889 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35890 PyObject *resultobj = 0;
35891 wxWindow *arg1 = (wxWindow *) 0 ;
35892 bool result;
35893 void *argp1 = 0 ;
35894 int res1 = 0 ;
35895 PyObject *swig_obj[1] ;
35896
35897 if (!args) SWIG_fail;
35898 swig_obj[0] = args;
35899 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35900 if (!SWIG_IsOK(res1)) {
35901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
35902 }
35903 arg1 = reinterpret_cast< wxWindow * >(argp1);
35904 {
35905 PyThreadState* __tstate = wxPyBeginAllowThreads();
35906 result = (bool)(arg1)->HasTransparentBackground();
35907 wxPyEndAllowThreads(__tstate);
35908 if (PyErr_Occurred()) SWIG_fail;
35909 }
35910 {
35911 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35912 }
35913 return resultobj;
35914 fail:
35915 return NULL;
35916 }
35917
35918
35919 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35920 PyObject *resultobj = 0;
35921 wxWindow *arg1 = (wxWindow *) 0 ;
35922 wxCursor *arg2 = 0 ;
35923 bool result;
35924 void *argp1 = 0 ;
35925 int res1 = 0 ;
35926 void *argp2 = 0 ;
35927 int res2 = 0 ;
35928 PyObject * obj0 = 0 ;
35929 PyObject * obj1 = 0 ;
35930 char * kwnames[] = {
35931 (char *) "self",(char *) "cursor", NULL
35932 };
35933
35934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
35935 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35936 if (!SWIG_IsOK(res1)) {
35937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35938 }
35939 arg1 = reinterpret_cast< wxWindow * >(argp1);
35940 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
35941 if (!SWIG_IsOK(res2)) {
35942 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35943 }
35944 if (!argp2) {
35945 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35946 }
35947 arg2 = reinterpret_cast< wxCursor * >(argp2);
35948 {
35949 PyThreadState* __tstate = wxPyBeginAllowThreads();
35950 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
35951 wxPyEndAllowThreads(__tstate);
35952 if (PyErr_Occurred()) SWIG_fail;
35953 }
35954 {
35955 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35956 }
35957 return resultobj;
35958 fail:
35959 return NULL;
35960 }
35961
35962
35963 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35964 PyObject *resultobj = 0;
35965 wxWindow *arg1 = (wxWindow *) 0 ;
35966 wxCursor result;
35967 void *argp1 = 0 ;
35968 int res1 = 0 ;
35969 PyObject *swig_obj[1] ;
35970
35971 if (!args) SWIG_fail;
35972 swig_obj[0] = args;
35973 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35974 if (!SWIG_IsOK(res1)) {
35975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35976 }
35977 arg1 = reinterpret_cast< wxWindow * >(argp1);
35978 {
35979 PyThreadState* __tstate = wxPyBeginAllowThreads();
35980 result = (arg1)->GetCursor();
35981 wxPyEndAllowThreads(__tstate);
35982 if (PyErr_Occurred()) SWIG_fail;
35983 }
35984 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
35985 return resultobj;
35986 fail:
35987 return NULL;
35988 }
35989
35990
35991 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35992 PyObject *resultobj = 0;
35993 wxWindow *arg1 = (wxWindow *) 0 ;
35994 wxFont *arg2 = 0 ;
35995 bool result;
35996 void *argp1 = 0 ;
35997 int res1 = 0 ;
35998 void *argp2 = 0 ;
35999 int res2 = 0 ;
36000 PyObject * obj0 = 0 ;
36001 PyObject * obj1 = 0 ;
36002 char * kwnames[] = {
36003 (char *) "self",(char *) "font", NULL
36004 };
36005
36006 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
36007 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36008 if (!SWIG_IsOK(res1)) {
36009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
36010 }
36011 arg1 = reinterpret_cast< wxWindow * >(argp1);
36012 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
36013 if (!SWIG_IsOK(res2)) {
36014 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
36015 }
36016 if (!argp2) {
36017 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
36018 }
36019 arg2 = reinterpret_cast< wxFont * >(argp2);
36020 {
36021 PyThreadState* __tstate = wxPyBeginAllowThreads();
36022 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
36023 wxPyEndAllowThreads(__tstate);
36024 if (PyErr_Occurred()) SWIG_fail;
36025 }
36026 {
36027 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36028 }
36029 return resultobj;
36030 fail:
36031 return NULL;
36032 }
36033
36034
36035 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36036 PyObject *resultobj = 0;
36037 wxWindow *arg1 = (wxWindow *) 0 ;
36038 wxFont *arg2 = 0 ;
36039 void *argp1 = 0 ;
36040 int res1 = 0 ;
36041 void *argp2 = 0 ;
36042 int res2 = 0 ;
36043 PyObject * obj0 = 0 ;
36044 PyObject * obj1 = 0 ;
36045 char * kwnames[] = {
36046 (char *) "self",(char *) "font", NULL
36047 };
36048
36049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
36050 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36051 if (!SWIG_IsOK(res1)) {
36052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
36053 }
36054 arg1 = reinterpret_cast< wxWindow * >(argp1);
36055 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
36056 if (!SWIG_IsOK(res2)) {
36057 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
36058 }
36059 if (!argp2) {
36060 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
36061 }
36062 arg2 = reinterpret_cast< wxFont * >(argp2);
36063 {
36064 PyThreadState* __tstate = wxPyBeginAllowThreads();
36065 (arg1)->SetOwnFont((wxFont const &)*arg2);
36066 wxPyEndAllowThreads(__tstate);
36067 if (PyErr_Occurred()) SWIG_fail;
36068 }
36069 resultobj = SWIG_Py_Void();
36070 return resultobj;
36071 fail:
36072 return NULL;
36073 }
36074
36075
36076 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36077 PyObject *resultobj = 0;
36078 wxWindow *arg1 = (wxWindow *) 0 ;
36079 wxFont result;
36080 void *argp1 = 0 ;
36081 int res1 = 0 ;
36082 PyObject *swig_obj[1] ;
36083
36084 if (!args) SWIG_fail;
36085 swig_obj[0] = args;
36086 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36087 if (!SWIG_IsOK(res1)) {
36088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
36089 }
36090 arg1 = reinterpret_cast< wxWindow * >(argp1);
36091 {
36092 PyThreadState* __tstate = wxPyBeginAllowThreads();
36093 result = (arg1)->GetFont();
36094 wxPyEndAllowThreads(__tstate);
36095 if (PyErr_Occurred()) SWIG_fail;
36096 }
36097 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
36098 return resultobj;
36099 fail:
36100 return NULL;
36101 }
36102
36103
36104 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36105 PyObject *resultobj = 0;
36106 wxWindow *arg1 = (wxWindow *) 0 ;
36107 wxCaret *arg2 = (wxCaret *) 0 ;
36108 void *argp1 = 0 ;
36109 int res1 = 0 ;
36110 int res2 = 0 ;
36111 PyObject * obj0 = 0 ;
36112 PyObject * obj1 = 0 ;
36113 char * kwnames[] = {
36114 (char *) "self",(char *) "caret", NULL
36115 };
36116
36117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
36118 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36119 if (!SWIG_IsOK(res1)) {
36120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
36121 }
36122 arg1 = reinterpret_cast< wxWindow * >(argp1);
36123 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
36124 if (!SWIG_IsOK(res2)) {
36125 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
36126 }
36127 {
36128 PyThreadState* __tstate = wxPyBeginAllowThreads();
36129 (arg1)->SetCaret(arg2);
36130 wxPyEndAllowThreads(__tstate);
36131 if (PyErr_Occurred()) SWIG_fail;
36132 }
36133 resultobj = SWIG_Py_Void();
36134 return resultobj;
36135 fail:
36136 return NULL;
36137 }
36138
36139
36140 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36141 PyObject *resultobj = 0;
36142 wxWindow *arg1 = (wxWindow *) 0 ;
36143 wxCaret *result = 0 ;
36144 void *argp1 = 0 ;
36145 int res1 = 0 ;
36146 PyObject *swig_obj[1] ;
36147
36148 if (!args) SWIG_fail;
36149 swig_obj[0] = args;
36150 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36151 if (!SWIG_IsOK(res1)) {
36152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
36153 }
36154 arg1 = reinterpret_cast< wxWindow * >(argp1);
36155 {
36156 PyThreadState* __tstate = wxPyBeginAllowThreads();
36157 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
36158 wxPyEndAllowThreads(__tstate);
36159 if (PyErr_Occurred()) SWIG_fail;
36160 }
36161 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
36162 return resultobj;
36163 fail:
36164 return NULL;
36165 }
36166
36167
36168 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36169 PyObject *resultobj = 0;
36170 wxWindow *arg1 = (wxWindow *) 0 ;
36171 int result;
36172 void *argp1 = 0 ;
36173 int res1 = 0 ;
36174 PyObject *swig_obj[1] ;
36175
36176 if (!args) SWIG_fail;
36177 swig_obj[0] = args;
36178 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36179 if (!SWIG_IsOK(res1)) {
36180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
36181 }
36182 arg1 = reinterpret_cast< wxWindow * >(argp1);
36183 {
36184 PyThreadState* __tstate = wxPyBeginAllowThreads();
36185 result = (int)((wxWindow const *)arg1)->GetCharHeight();
36186 wxPyEndAllowThreads(__tstate);
36187 if (PyErr_Occurred()) SWIG_fail;
36188 }
36189 resultobj = SWIG_From_int(static_cast< int >(result));
36190 return resultobj;
36191 fail:
36192 return NULL;
36193 }
36194
36195
36196 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36197 PyObject *resultobj = 0;
36198 wxWindow *arg1 = (wxWindow *) 0 ;
36199 int result;
36200 void *argp1 = 0 ;
36201 int res1 = 0 ;
36202 PyObject *swig_obj[1] ;
36203
36204 if (!args) SWIG_fail;
36205 swig_obj[0] = args;
36206 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36207 if (!SWIG_IsOK(res1)) {
36208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
36209 }
36210 arg1 = reinterpret_cast< wxWindow * >(argp1);
36211 {
36212 PyThreadState* __tstate = wxPyBeginAllowThreads();
36213 result = (int)((wxWindow const *)arg1)->GetCharWidth();
36214 wxPyEndAllowThreads(__tstate);
36215 if (PyErr_Occurred()) SWIG_fail;
36216 }
36217 resultobj = SWIG_From_int(static_cast< int >(result));
36218 return resultobj;
36219 fail:
36220 return NULL;
36221 }
36222
36223
36224 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36225 PyObject *resultobj = 0;
36226 wxWindow *arg1 = (wxWindow *) 0 ;
36227 wxString *arg2 = 0 ;
36228 int *arg3 = (int *) 0 ;
36229 int *arg4 = (int *) 0 ;
36230 void *argp1 = 0 ;
36231 int res1 = 0 ;
36232 bool temp2 = false ;
36233 int temp3 ;
36234 int res3 = SWIG_TMPOBJ ;
36235 int temp4 ;
36236 int res4 = SWIG_TMPOBJ ;
36237 PyObject * obj0 = 0 ;
36238 PyObject * obj1 = 0 ;
36239 char * kwnames[] = {
36240 (char *) "self",(char *) "string", NULL
36241 };
36242
36243 arg3 = &temp3;
36244 arg4 = &temp4;
36245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
36246 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36247 if (!SWIG_IsOK(res1)) {
36248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
36249 }
36250 arg1 = reinterpret_cast< wxWindow * >(argp1);
36251 {
36252 arg2 = wxString_in_helper(obj1);
36253 if (arg2 == NULL) SWIG_fail;
36254 temp2 = true;
36255 }
36256 {
36257 PyThreadState* __tstate = wxPyBeginAllowThreads();
36258 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
36259 wxPyEndAllowThreads(__tstate);
36260 if (PyErr_Occurred()) SWIG_fail;
36261 }
36262 resultobj = SWIG_Py_Void();
36263 if (SWIG_IsTmpObj(res3)) {
36264 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36265 } else {
36266 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36267 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36268 }
36269 if (SWIG_IsTmpObj(res4)) {
36270 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
36271 } else {
36272 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36273 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
36274 }
36275 {
36276 if (temp2)
36277 delete arg2;
36278 }
36279 return resultobj;
36280 fail:
36281 {
36282 if (temp2)
36283 delete arg2;
36284 }
36285 return NULL;
36286 }
36287
36288
36289 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36290 PyObject *resultobj = 0;
36291 wxWindow *arg1 = (wxWindow *) 0 ;
36292 wxString *arg2 = 0 ;
36293 int *arg3 = (int *) 0 ;
36294 int *arg4 = (int *) 0 ;
36295 int *arg5 = (int *) 0 ;
36296 int *arg6 = (int *) 0 ;
36297 wxFont *arg7 = (wxFont *) NULL ;
36298 void *argp1 = 0 ;
36299 int res1 = 0 ;
36300 bool temp2 = false ;
36301 int temp3 ;
36302 int res3 = SWIG_TMPOBJ ;
36303 int temp4 ;
36304 int res4 = SWIG_TMPOBJ ;
36305 int temp5 ;
36306 int res5 = SWIG_TMPOBJ ;
36307 int temp6 ;
36308 int res6 = SWIG_TMPOBJ ;
36309 void *argp7 = 0 ;
36310 int res7 = 0 ;
36311 PyObject * obj0 = 0 ;
36312 PyObject * obj1 = 0 ;
36313 PyObject * obj2 = 0 ;
36314 char * kwnames[] = {
36315 (char *) "self",(char *) "string",(char *) "font", NULL
36316 };
36317
36318 arg3 = &temp3;
36319 arg4 = &temp4;
36320 arg5 = &temp5;
36321 arg6 = &temp6;
36322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36323 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36324 if (!SWIG_IsOK(res1)) {
36325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
36326 }
36327 arg1 = reinterpret_cast< wxWindow * >(argp1);
36328 {
36329 arg2 = wxString_in_helper(obj1);
36330 if (arg2 == NULL) SWIG_fail;
36331 temp2 = true;
36332 }
36333 if (obj2) {
36334 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
36335 if (!SWIG_IsOK(res7)) {
36336 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
36337 }
36338 arg7 = reinterpret_cast< wxFont * >(argp7);
36339 }
36340 {
36341 PyThreadState* __tstate = wxPyBeginAllowThreads();
36342 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
36343 wxPyEndAllowThreads(__tstate);
36344 if (PyErr_Occurred()) SWIG_fail;
36345 }
36346 resultobj = SWIG_Py_Void();
36347 if (SWIG_IsTmpObj(res3)) {
36348 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36349 } else {
36350 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36351 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36352 }
36353 if (SWIG_IsTmpObj(res4)) {
36354 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
36355 } else {
36356 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36357 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
36358 }
36359 if (SWIG_IsTmpObj(res5)) {
36360 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
36361 } else {
36362 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36363 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
36364 }
36365 if (SWIG_IsTmpObj(res6)) {
36366 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
36367 } else {
36368 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36369 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
36370 }
36371 {
36372 if (temp2)
36373 delete arg2;
36374 }
36375 return resultobj;
36376 fail:
36377 {
36378 if (temp2)
36379 delete arg2;
36380 }
36381 return NULL;
36382 }
36383
36384
36385 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36386 PyObject *resultobj = 0;
36387 wxWindow *arg1 = (wxWindow *) 0 ;
36388 int *arg2 = (int *) 0 ;
36389 int *arg3 = (int *) 0 ;
36390 void *argp1 = 0 ;
36391 int res1 = 0 ;
36392 int temp2 ;
36393 int res2 = 0 ;
36394 int temp3 ;
36395 int res3 = 0 ;
36396 PyObject * obj0 = 0 ;
36397 PyObject * obj1 = 0 ;
36398 PyObject * obj2 = 0 ;
36399 char * kwnames[] = {
36400 (char *) "self",(char *) "x",(char *) "y", NULL
36401 };
36402
36403 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36404 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36405 if (!SWIG_IsOK(res1)) {
36406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
36407 }
36408 arg1 = reinterpret_cast< wxWindow * >(argp1);
36409 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
36410 int val;
36411 int ecode = SWIG_AsVal_int(obj1, &val);
36412 if (!SWIG_IsOK(ecode)) {
36413 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
36414 }
36415 temp2 = static_cast< int >(val);
36416 arg2 = &temp2;
36417 res2 = SWIG_AddTmpMask(ecode);
36418 }
36419 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
36420 int val;
36421 int ecode = SWIG_AsVal_int(obj2, &val);
36422 if (!SWIG_IsOK(ecode)) {
36423 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
36424 }
36425 temp3 = static_cast< int >(val);
36426 arg3 = &temp3;
36427 res3 = SWIG_AddTmpMask(ecode);
36428 }
36429 {
36430 PyThreadState* __tstate = wxPyBeginAllowThreads();
36431 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
36432 wxPyEndAllowThreads(__tstate);
36433 if (PyErr_Occurred()) SWIG_fail;
36434 }
36435 resultobj = SWIG_Py_Void();
36436 if (SWIG_IsTmpObj(res2)) {
36437 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
36438 } else {
36439 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36440 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
36441 }
36442 if (SWIG_IsTmpObj(res3)) {
36443 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36444 } else {
36445 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36446 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36447 }
36448 return resultobj;
36449 fail:
36450 return NULL;
36451 }
36452
36453
36454 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36455 PyObject *resultobj = 0;
36456 wxWindow *arg1 = (wxWindow *) 0 ;
36457 int *arg2 = (int *) 0 ;
36458 int *arg3 = (int *) 0 ;
36459 void *argp1 = 0 ;
36460 int res1 = 0 ;
36461 int temp2 ;
36462 int res2 = 0 ;
36463 int temp3 ;
36464 int res3 = 0 ;
36465 PyObject * obj0 = 0 ;
36466 PyObject * obj1 = 0 ;
36467 PyObject * obj2 = 0 ;
36468 char * kwnames[] = {
36469 (char *) "self",(char *) "x",(char *) "y", NULL
36470 };
36471
36472 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36473 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36474 if (!SWIG_IsOK(res1)) {
36475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
36476 }
36477 arg1 = reinterpret_cast< wxWindow * >(argp1);
36478 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
36479 int val;
36480 int ecode = SWIG_AsVal_int(obj1, &val);
36481 if (!SWIG_IsOK(ecode)) {
36482 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
36483 }
36484 temp2 = static_cast< int >(val);
36485 arg2 = &temp2;
36486 res2 = SWIG_AddTmpMask(ecode);
36487 }
36488 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
36489 int val;
36490 int ecode = SWIG_AsVal_int(obj2, &val);
36491 if (!SWIG_IsOK(ecode)) {
36492 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
36493 }
36494 temp3 = static_cast< int >(val);
36495 arg3 = &temp3;
36496 res3 = SWIG_AddTmpMask(ecode);
36497 }
36498 {
36499 PyThreadState* __tstate = wxPyBeginAllowThreads();
36500 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
36501 wxPyEndAllowThreads(__tstate);
36502 if (PyErr_Occurred()) SWIG_fail;
36503 }
36504 resultobj = SWIG_Py_Void();
36505 if (SWIG_IsTmpObj(res2)) {
36506 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
36507 } else {
36508 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36509 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
36510 }
36511 if (SWIG_IsTmpObj(res3)) {
36512 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36513 } else {
36514 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36515 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36516 }
36517 return resultobj;
36518 fail:
36519 return NULL;
36520 }
36521
36522
36523 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36524 PyObject *resultobj = 0;
36525 wxWindow *arg1 = (wxWindow *) 0 ;
36526 wxPoint *arg2 = 0 ;
36527 wxPoint result;
36528 void *argp1 = 0 ;
36529 int res1 = 0 ;
36530 wxPoint temp2 ;
36531 PyObject * obj0 = 0 ;
36532 PyObject * obj1 = 0 ;
36533 char * kwnames[] = {
36534 (char *) "self",(char *) "pt", NULL
36535 };
36536
36537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
36538 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36539 if (!SWIG_IsOK(res1)) {
36540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
36541 }
36542 arg1 = reinterpret_cast< wxWindow * >(argp1);
36543 {
36544 arg2 = &temp2;
36545 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
36546 }
36547 {
36548 PyThreadState* __tstate = wxPyBeginAllowThreads();
36549 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
36550 wxPyEndAllowThreads(__tstate);
36551 if (PyErr_Occurred()) SWIG_fail;
36552 }
36553 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
36554 return resultobj;
36555 fail:
36556 return NULL;
36557 }
36558
36559
36560 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36561 PyObject *resultobj = 0;
36562 wxWindow *arg1 = (wxWindow *) 0 ;
36563 wxPoint *arg2 = 0 ;
36564 wxPoint result;
36565 void *argp1 = 0 ;
36566 int res1 = 0 ;
36567 wxPoint temp2 ;
36568 PyObject * obj0 = 0 ;
36569 PyObject * obj1 = 0 ;
36570 char * kwnames[] = {
36571 (char *) "self",(char *) "pt", NULL
36572 };
36573
36574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
36575 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36576 if (!SWIG_IsOK(res1)) {
36577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
36578 }
36579 arg1 = reinterpret_cast< wxWindow * >(argp1);
36580 {
36581 arg2 = &temp2;
36582 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
36583 }
36584 {
36585 PyThreadState* __tstate = wxPyBeginAllowThreads();
36586 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
36587 wxPyEndAllowThreads(__tstate);
36588 if (PyErr_Occurred()) SWIG_fail;
36589 }
36590 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
36591 return resultobj;
36592 fail:
36593 return NULL;
36594 }
36595
36596
36597 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36598 PyObject *resultobj = 0;
36599 wxWindow *arg1 = (wxWindow *) 0 ;
36600 int arg2 ;
36601 int arg3 ;
36602 wxHitTest result;
36603 void *argp1 = 0 ;
36604 int res1 = 0 ;
36605 int val2 ;
36606 int ecode2 = 0 ;
36607 int val3 ;
36608 int ecode3 = 0 ;
36609 PyObject * obj0 = 0 ;
36610 PyObject * obj1 = 0 ;
36611 PyObject * obj2 = 0 ;
36612 char * kwnames[] = {
36613 (char *) "self",(char *) "x",(char *) "y", NULL
36614 };
36615
36616 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36617 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36618 if (!SWIG_IsOK(res1)) {
36619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
36620 }
36621 arg1 = reinterpret_cast< wxWindow * >(argp1);
36622 ecode2 = SWIG_AsVal_int(obj1, &val2);
36623 if (!SWIG_IsOK(ecode2)) {
36624 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
36625 }
36626 arg2 = static_cast< int >(val2);
36627 ecode3 = SWIG_AsVal_int(obj2, &val3);
36628 if (!SWIG_IsOK(ecode3)) {
36629 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
36630 }
36631 arg3 = static_cast< int >(val3);
36632 {
36633 PyThreadState* __tstate = wxPyBeginAllowThreads();
36634 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
36635 wxPyEndAllowThreads(__tstate);
36636 if (PyErr_Occurred()) SWIG_fail;
36637 }
36638 resultobj = SWIG_From_int(static_cast< int >(result));
36639 return resultobj;
36640 fail:
36641 return NULL;
36642 }
36643
36644
36645 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36646 PyObject *resultobj = 0;
36647 wxWindow *arg1 = (wxWindow *) 0 ;
36648 wxPoint *arg2 = 0 ;
36649 wxHitTest result;
36650 void *argp1 = 0 ;
36651 int res1 = 0 ;
36652 wxPoint temp2 ;
36653 PyObject * obj0 = 0 ;
36654 PyObject * obj1 = 0 ;
36655 char * kwnames[] = {
36656 (char *) "self",(char *) "pt", NULL
36657 };
36658
36659 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
36660 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36661 if (!SWIG_IsOK(res1)) {
36662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
36663 }
36664 arg1 = reinterpret_cast< wxWindow * >(argp1);
36665 {
36666 arg2 = &temp2;
36667 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
36668 }
36669 {
36670 PyThreadState* __tstate = wxPyBeginAllowThreads();
36671 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
36672 wxPyEndAllowThreads(__tstate);
36673 if (PyErr_Occurred()) SWIG_fail;
36674 }
36675 resultobj = SWIG_From_int(static_cast< int >(result));
36676 return resultobj;
36677 fail:
36678 return NULL;
36679 }
36680
36681
36682 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
36683 PyObject *resultobj = 0;
36684 wxWindow *arg1 = (wxWindow *) 0 ;
36685 long arg2 ;
36686 wxBorder result;
36687 void *argp1 = 0 ;
36688 int res1 = 0 ;
36689 long val2 ;
36690 int ecode2 = 0 ;
36691
36692 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
36693 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36694 if (!SWIG_IsOK(res1)) {
36695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
36696 }
36697 arg1 = reinterpret_cast< wxWindow * >(argp1);
36698 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
36699 if (!SWIG_IsOK(ecode2)) {
36700 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
36701 }
36702 arg2 = static_cast< long >(val2);
36703 {
36704 PyThreadState* __tstate = wxPyBeginAllowThreads();
36705 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
36706 wxPyEndAllowThreads(__tstate);
36707 if (PyErr_Occurred()) SWIG_fail;
36708 }
36709 resultobj = SWIG_From_int(static_cast< int >(result));
36710 return resultobj;
36711 fail:
36712 return NULL;
36713 }
36714
36715
36716 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
36717 PyObject *resultobj = 0;
36718 wxWindow *arg1 = (wxWindow *) 0 ;
36719 wxBorder result;
36720 void *argp1 = 0 ;
36721 int res1 = 0 ;
36722
36723 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
36724 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36725 if (!SWIG_IsOK(res1)) {
36726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
36727 }
36728 arg1 = reinterpret_cast< wxWindow * >(argp1);
36729 {
36730 PyThreadState* __tstate = wxPyBeginAllowThreads();
36731 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
36732 wxPyEndAllowThreads(__tstate);
36733 if (PyErr_Occurred()) SWIG_fail;
36734 }
36735 resultobj = SWIG_From_int(static_cast< int >(result));
36736 return resultobj;
36737 fail:
36738 return NULL;
36739 }
36740
36741
36742 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
36743 int argc;
36744 PyObject *argv[3];
36745
36746 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
36747 --argc;
36748 if (argc == 1) {
36749 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
36750 }
36751 if (argc == 2) {
36752 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
36753 }
36754
36755 fail:
36756 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
36757 return NULL;
36758 }
36759
36760
36761 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36762 PyObject *resultobj = 0;
36763 wxWindow *arg1 = (wxWindow *) 0 ;
36764 long arg2 = (long) wxUPDATE_UI_NONE ;
36765 void *argp1 = 0 ;
36766 int res1 = 0 ;
36767 long val2 ;
36768 int ecode2 = 0 ;
36769 PyObject * obj0 = 0 ;
36770 PyObject * obj1 = 0 ;
36771 char * kwnames[] = {
36772 (char *) "self",(char *) "flags", NULL
36773 };
36774
36775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
36776 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36777 if (!SWIG_IsOK(res1)) {
36778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
36779 }
36780 arg1 = reinterpret_cast< wxWindow * >(argp1);
36781 if (obj1) {
36782 ecode2 = SWIG_AsVal_long(obj1, &val2);
36783 if (!SWIG_IsOK(ecode2)) {
36784 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
36785 }
36786 arg2 = static_cast< long >(val2);
36787 }
36788 {
36789 PyThreadState* __tstate = wxPyBeginAllowThreads();
36790 (arg1)->UpdateWindowUI(arg2);
36791 wxPyEndAllowThreads(__tstate);
36792 if (PyErr_Occurred()) SWIG_fail;
36793 }
36794 resultobj = SWIG_Py_Void();
36795 return resultobj;
36796 fail:
36797 return NULL;
36798 }
36799
36800
36801 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36802 PyObject *resultobj = 0;
36803 wxWindow *arg1 = (wxWindow *) 0 ;
36804 wxMenu *arg2 = (wxMenu *) 0 ;
36805 int arg3 = (int) -1 ;
36806 int arg4 = (int) -1 ;
36807 bool result;
36808 void *argp1 = 0 ;
36809 int res1 = 0 ;
36810 void *argp2 = 0 ;
36811 int res2 = 0 ;
36812 int val3 ;
36813 int ecode3 = 0 ;
36814 int val4 ;
36815 int ecode4 = 0 ;
36816 PyObject * obj0 = 0 ;
36817 PyObject * obj1 = 0 ;
36818 PyObject * obj2 = 0 ;
36819 PyObject * obj3 = 0 ;
36820 char * kwnames[] = {
36821 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
36822 };
36823
36824 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36825 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36826 if (!SWIG_IsOK(res1)) {
36827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
36828 }
36829 arg1 = reinterpret_cast< wxWindow * >(argp1);
36830 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36831 if (!SWIG_IsOK(res2)) {
36832 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
36833 }
36834 arg2 = reinterpret_cast< wxMenu * >(argp2);
36835 if (obj2) {
36836 ecode3 = SWIG_AsVal_int(obj2, &val3);
36837 if (!SWIG_IsOK(ecode3)) {
36838 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
36839 }
36840 arg3 = static_cast< int >(val3);
36841 }
36842 if (obj3) {
36843 ecode4 = SWIG_AsVal_int(obj3, &val4);
36844 if (!SWIG_IsOK(ecode4)) {
36845 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
36846 }
36847 arg4 = static_cast< int >(val4);
36848 }
36849 {
36850 PyThreadState* __tstate = wxPyBeginAllowThreads();
36851 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
36852 wxPyEndAllowThreads(__tstate);
36853 if (PyErr_Occurred()) SWIG_fail;
36854 }
36855 {
36856 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36857 }
36858 return resultobj;
36859 fail:
36860 return NULL;
36861 }
36862
36863
36864 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36865 PyObject *resultobj = 0;
36866 wxWindow *arg1 = (wxWindow *) 0 ;
36867 wxMenu *arg2 = (wxMenu *) 0 ;
36868 wxPoint const &arg3_defvalue = wxDefaultPosition ;
36869 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
36870 bool result;
36871 void *argp1 = 0 ;
36872 int res1 = 0 ;
36873 void *argp2 = 0 ;
36874 int res2 = 0 ;
36875 wxPoint temp3 ;
36876 PyObject * obj0 = 0 ;
36877 PyObject * obj1 = 0 ;
36878 PyObject * obj2 = 0 ;
36879 char * kwnames[] = {
36880 (char *) "self",(char *) "menu",(char *) "pos", NULL
36881 };
36882
36883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36885 if (!SWIG_IsOK(res1)) {
36886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
36887 }
36888 arg1 = reinterpret_cast< wxWindow * >(argp1);
36889 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36890 if (!SWIG_IsOK(res2)) {
36891 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
36892 }
36893 arg2 = reinterpret_cast< wxMenu * >(argp2);
36894 if (obj2) {
36895 {
36896 arg3 = &temp3;
36897 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
36898 }
36899 }
36900 {
36901 PyThreadState* __tstate = wxPyBeginAllowThreads();
36902 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
36903 wxPyEndAllowThreads(__tstate);
36904 if (PyErr_Occurred()) SWIG_fail;
36905 }
36906 {
36907 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36908 }
36909 return resultobj;
36910 fail:
36911 return NULL;
36912 }
36913
36914
36915 SWIGINTERN PyObject *_wrap_Window_HasMultiplePages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36916 PyObject *resultobj = 0;
36917 wxWindow *arg1 = (wxWindow *) 0 ;
36918 bool result;
36919 void *argp1 = 0 ;
36920 int res1 = 0 ;
36921 PyObject *swig_obj[1] ;
36922
36923 if (!args) SWIG_fail;
36924 swig_obj[0] = args;
36925 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36926 if (!SWIG_IsOK(res1)) {
36927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasMultiplePages" "', expected argument " "1"" of type '" "wxWindow const *""'");
36928 }
36929 arg1 = reinterpret_cast< wxWindow * >(argp1);
36930 {
36931 PyThreadState* __tstate = wxPyBeginAllowThreads();
36932 result = (bool)((wxWindow const *)arg1)->HasMultiplePages();
36933 wxPyEndAllowThreads(__tstate);
36934 if (PyErr_Occurred()) SWIG_fail;
36935 }
36936 {
36937 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36938 }
36939 return resultobj;
36940 fail:
36941 return NULL;
36942 }
36943
36944
36945 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36946 PyObject *resultobj = 0;
36947 wxWindow *arg1 = (wxWindow *) 0 ;
36948 long result;
36949 void *argp1 = 0 ;
36950 int res1 = 0 ;
36951 PyObject *swig_obj[1] ;
36952
36953 if (!args) SWIG_fail;
36954 swig_obj[0] = args;
36955 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36956 if (!SWIG_IsOK(res1)) {
36957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36958 }
36959 arg1 = reinterpret_cast< wxWindow * >(argp1);
36960 {
36961 PyThreadState* __tstate = wxPyBeginAllowThreads();
36962 result = (long)wxWindow_GetHandle(arg1);
36963 wxPyEndAllowThreads(__tstate);
36964 if (PyErr_Occurred()) SWIG_fail;
36965 }
36966 resultobj = SWIG_From_long(static_cast< long >(result));
36967 return resultobj;
36968 fail:
36969 return NULL;
36970 }
36971
36972
36973 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36974 PyObject *resultobj = 0;
36975 wxWindow *arg1 = (wxWindow *) 0 ;
36976 long arg2 ;
36977 void *argp1 = 0 ;
36978 int res1 = 0 ;
36979 long val2 ;
36980 int ecode2 = 0 ;
36981 PyObject * obj0 = 0 ;
36982 PyObject * obj1 = 0 ;
36983 char * kwnames[] = {
36984 (char *) "self",(char *) "handle", NULL
36985 };
36986
36987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
36988 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36989 if (!SWIG_IsOK(res1)) {
36990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36991 }
36992 arg1 = reinterpret_cast< wxWindow * >(argp1);
36993 ecode2 = SWIG_AsVal_long(obj1, &val2);
36994 if (!SWIG_IsOK(ecode2)) {
36995 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
36996 }
36997 arg2 = static_cast< long >(val2);
36998 {
36999 PyThreadState* __tstate = wxPyBeginAllowThreads();
37000 wxWindow_AssociateHandle(arg1,arg2);
37001 wxPyEndAllowThreads(__tstate);
37002 if (PyErr_Occurred()) SWIG_fail;
37003 }
37004 resultobj = SWIG_Py_Void();
37005 return resultobj;
37006 fail:
37007 return NULL;
37008 }
37009
37010
37011 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37012 PyObject *resultobj = 0;
37013 wxWindow *arg1 = (wxWindow *) 0 ;
37014 void *argp1 = 0 ;
37015 int res1 = 0 ;
37016 PyObject *swig_obj[1] ;
37017
37018 if (!args) SWIG_fail;
37019 swig_obj[0] = args;
37020 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37021 if (!SWIG_IsOK(res1)) {
37022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
37023 }
37024 arg1 = reinterpret_cast< wxWindow * >(argp1);
37025 {
37026 PyThreadState* __tstate = wxPyBeginAllowThreads();
37027 (arg1)->DissociateHandle();
37028 wxPyEndAllowThreads(__tstate);
37029 if (PyErr_Occurred()) SWIG_fail;
37030 }
37031 resultobj = SWIG_Py_Void();
37032 return resultobj;
37033 fail:
37034 return NULL;
37035 }
37036
37037
37038 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37039 PyObject *resultobj = 0;
37040 wxWindow *arg1 = (wxWindow *) 0 ;
37041 int arg2 ;
37042 bool result;
37043 void *argp1 = 0 ;
37044 int res1 = 0 ;
37045 int val2 ;
37046 int ecode2 = 0 ;
37047 PyObject * obj0 = 0 ;
37048 PyObject * obj1 = 0 ;
37049 char * kwnames[] = {
37050 (char *) "self",(char *) "orient", NULL
37051 };
37052
37053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
37054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37055 if (!SWIG_IsOK(res1)) {
37056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
37057 }
37058 arg1 = reinterpret_cast< wxWindow * >(argp1);
37059 ecode2 = SWIG_AsVal_int(obj1, &val2);
37060 if (!SWIG_IsOK(ecode2)) {
37061 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
37062 }
37063 arg2 = static_cast< int >(val2);
37064 {
37065 PyThreadState* __tstate = wxPyBeginAllowThreads();
37066 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
37067 wxPyEndAllowThreads(__tstate);
37068 if (PyErr_Occurred()) SWIG_fail;
37069 }
37070 {
37071 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37072 }
37073 return resultobj;
37074 fail:
37075 return NULL;
37076 }
37077
37078
37079 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37080 PyObject *resultobj = 0;
37081 wxWindow *arg1 = (wxWindow *) 0 ;
37082 int arg2 ;
37083 int arg3 ;
37084 int arg4 ;
37085 int arg5 ;
37086 bool arg6 = (bool) true ;
37087 void *argp1 = 0 ;
37088 int res1 = 0 ;
37089 int val2 ;
37090 int ecode2 = 0 ;
37091 int val3 ;
37092 int ecode3 = 0 ;
37093 int val4 ;
37094 int ecode4 = 0 ;
37095 int val5 ;
37096 int ecode5 = 0 ;
37097 bool val6 ;
37098 int ecode6 = 0 ;
37099 PyObject * obj0 = 0 ;
37100 PyObject * obj1 = 0 ;
37101 PyObject * obj2 = 0 ;
37102 PyObject * obj3 = 0 ;
37103 PyObject * obj4 = 0 ;
37104 PyObject * obj5 = 0 ;
37105 char * kwnames[] = {
37106 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
37107 };
37108
37109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
37110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37111 if (!SWIG_IsOK(res1)) {
37112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
37113 }
37114 arg1 = reinterpret_cast< wxWindow * >(argp1);
37115 ecode2 = SWIG_AsVal_int(obj1, &val2);
37116 if (!SWIG_IsOK(ecode2)) {
37117 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
37118 }
37119 arg2 = static_cast< int >(val2);
37120 ecode3 = SWIG_AsVal_int(obj2, &val3);
37121 if (!SWIG_IsOK(ecode3)) {
37122 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
37123 }
37124 arg3 = static_cast< int >(val3);
37125 ecode4 = SWIG_AsVal_int(obj3, &val4);
37126 if (!SWIG_IsOK(ecode4)) {
37127 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
37128 }
37129 arg4 = static_cast< int >(val4);
37130 ecode5 = SWIG_AsVal_int(obj4, &val5);
37131 if (!SWIG_IsOK(ecode5)) {
37132 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
37133 }
37134 arg5 = static_cast< int >(val5);
37135 if (obj5) {
37136 ecode6 = SWIG_AsVal_bool(obj5, &val6);
37137 if (!SWIG_IsOK(ecode6)) {
37138 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
37139 }
37140 arg6 = static_cast< bool >(val6);
37141 }
37142 {
37143 PyThreadState* __tstate = wxPyBeginAllowThreads();
37144 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
37145 wxPyEndAllowThreads(__tstate);
37146 if (PyErr_Occurred()) SWIG_fail;
37147 }
37148 resultobj = SWIG_Py_Void();
37149 return resultobj;
37150 fail:
37151 return NULL;
37152 }
37153
37154
37155 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37156 PyObject *resultobj = 0;
37157 wxWindow *arg1 = (wxWindow *) 0 ;
37158 int arg2 ;
37159 int arg3 ;
37160 bool arg4 = (bool) true ;
37161 void *argp1 = 0 ;
37162 int res1 = 0 ;
37163 int val2 ;
37164 int ecode2 = 0 ;
37165 int val3 ;
37166 int ecode3 = 0 ;
37167 bool val4 ;
37168 int ecode4 = 0 ;
37169 PyObject * obj0 = 0 ;
37170 PyObject * obj1 = 0 ;
37171 PyObject * obj2 = 0 ;
37172 PyObject * obj3 = 0 ;
37173 char * kwnames[] = {
37174 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
37175 };
37176
37177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37178 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37179 if (!SWIG_IsOK(res1)) {
37180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
37181 }
37182 arg1 = reinterpret_cast< wxWindow * >(argp1);
37183 ecode2 = SWIG_AsVal_int(obj1, &val2);
37184 if (!SWIG_IsOK(ecode2)) {
37185 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
37186 }
37187 arg2 = static_cast< int >(val2);
37188 ecode3 = SWIG_AsVal_int(obj2, &val3);
37189 if (!SWIG_IsOK(ecode3)) {
37190 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
37191 }
37192 arg3 = static_cast< int >(val3);
37193 if (obj3) {
37194 ecode4 = SWIG_AsVal_bool(obj3, &val4);
37195 if (!SWIG_IsOK(ecode4)) {
37196 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
37197 }
37198 arg4 = static_cast< bool >(val4);
37199 }
37200 {
37201 PyThreadState* __tstate = wxPyBeginAllowThreads();
37202 (arg1)->SetScrollPos(arg2,arg3,arg4);
37203 wxPyEndAllowThreads(__tstate);
37204 if (PyErr_Occurred()) SWIG_fail;
37205 }
37206 resultobj = SWIG_Py_Void();
37207 return resultobj;
37208 fail:
37209 return NULL;
37210 }
37211
37212
37213 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37214 PyObject *resultobj = 0;
37215 wxWindow *arg1 = (wxWindow *) 0 ;
37216 int arg2 ;
37217 int result;
37218 void *argp1 = 0 ;
37219 int res1 = 0 ;
37220 int val2 ;
37221 int ecode2 = 0 ;
37222 PyObject * obj0 = 0 ;
37223 PyObject * obj1 = 0 ;
37224 char * kwnames[] = {
37225 (char *) "self",(char *) "orientation", NULL
37226 };
37227
37228 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
37229 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37230 if (!SWIG_IsOK(res1)) {
37231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
37232 }
37233 arg1 = reinterpret_cast< wxWindow * >(argp1);
37234 ecode2 = SWIG_AsVal_int(obj1, &val2);
37235 if (!SWIG_IsOK(ecode2)) {
37236 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
37237 }
37238 arg2 = static_cast< int >(val2);
37239 {
37240 PyThreadState* __tstate = wxPyBeginAllowThreads();
37241 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
37242 wxPyEndAllowThreads(__tstate);
37243 if (PyErr_Occurred()) SWIG_fail;
37244 }
37245 resultobj = SWIG_From_int(static_cast< int >(result));
37246 return resultobj;
37247 fail:
37248 return NULL;
37249 }
37250
37251
37252 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37253 PyObject *resultobj = 0;
37254 wxWindow *arg1 = (wxWindow *) 0 ;
37255 int arg2 ;
37256 int result;
37257 void *argp1 = 0 ;
37258 int res1 = 0 ;
37259 int val2 ;
37260 int ecode2 = 0 ;
37261 PyObject * obj0 = 0 ;
37262 PyObject * obj1 = 0 ;
37263 char * kwnames[] = {
37264 (char *) "self",(char *) "orientation", NULL
37265 };
37266
37267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
37268 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37269 if (!SWIG_IsOK(res1)) {
37270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
37271 }
37272 arg1 = reinterpret_cast< wxWindow * >(argp1);
37273 ecode2 = SWIG_AsVal_int(obj1, &val2);
37274 if (!SWIG_IsOK(ecode2)) {
37275 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
37276 }
37277 arg2 = static_cast< int >(val2);
37278 {
37279 PyThreadState* __tstate = wxPyBeginAllowThreads();
37280 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
37281 wxPyEndAllowThreads(__tstate);
37282 if (PyErr_Occurred()) SWIG_fail;
37283 }
37284 resultobj = SWIG_From_int(static_cast< int >(result));
37285 return resultobj;
37286 fail:
37287 return NULL;
37288 }
37289
37290
37291 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37292 PyObject *resultobj = 0;
37293 wxWindow *arg1 = (wxWindow *) 0 ;
37294 int arg2 ;
37295 int result;
37296 void *argp1 = 0 ;
37297 int res1 = 0 ;
37298 int val2 ;
37299 int ecode2 = 0 ;
37300 PyObject * obj0 = 0 ;
37301 PyObject * obj1 = 0 ;
37302 char * kwnames[] = {
37303 (char *) "self",(char *) "orientation", NULL
37304 };
37305
37306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
37307 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37308 if (!SWIG_IsOK(res1)) {
37309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
37310 }
37311 arg1 = reinterpret_cast< wxWindow * >(argp1);
37312 ecode2 = SWIG_AsVal_int(obj1, &val2);
37313 if (!SWIG_IsOK(ecode2)) {
37314 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
37315 }
37316 arg2 = static_cast< int >(val2);
37317 {
37318 PyThreadState* __tstate = wxPyBeginAllowThreads();
37319 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
37320 wxPyEndAllowThreads(__tstate);
37321 if (PyErr_Occurred()) SWIG_fail;
37322 }
37323 resultobj = SWIG_From_int(static_cast< int >(result));
37324 return resultobj;
37325 fail:
37326 return NULL;
37327 }
37328
37329
37330 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37331 PyObject *resultobj = 0;
37332 wxWindow *arg1 = (wxWindow *) 0 ;
37333 int arg2 ;
37334 int arg3 ;
37335 wxRect *arg4 = (wxRect *) NULL ;
37336 void *argp1 = 0 ;
37337 int res1 = 0 ;
37338 int val2 ;
37339 int ecode2 = 0 ;
37340 int val3 ;
37341 int ecode3 = 0 ;
37342 void *argp4 = 0 ;
37343 int res4 = 0 ;
37344 PyObject * obj0 = 0 ;
37345 PyObject * obj1 = 0 ;
37346 PyObject * obj2 = 0 ;
37347 PyObject * obj3 = 0 ;
37348 char * kwnames[] = {
37349 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
37350 };
37351
37352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37353 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37354 if (!SWIG_IsOK(res1)) {
37355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
37356 }
37357 arg1 = reinterpret_cast< wxWindow * >(argp1);
37358 ecode2 = SWIG_AsVal_int(obj1, &val2);
37359 if (!SWIG_IsOK(ecode2)) {
37360 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
37361 }
37362 arg2 = static_cast< int >(val2);
37363 ecode3 = SWIG_AsVal_int(obj2, &val3);
37364 if (!SWIG_IsOK(ecode3)) {
37365 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
37366 }
37367 arg3 = static_cast< int >(val3);
37368 if (obj3) {
37369 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
37370 if (!SWIG_IsOK(res4)) {
37371 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
37372 }
37373 arg4 = reinterpret_cast< wxRect * >(argp4);
37374 }
37375 {
37376 PyThreadState* __tstate = wxPyBeginAllowThreads();
37377 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
37378 wxPyEndAllowThreads(__tstate);
37379 if (PyErr_Occurred()) SWIG_fail;
37380 }
37381 resultobj = SWIG_Py_Void();
37382 return resultobj;
37383 fail:
37384 return NULL;
37385 }
37386
37387
37388 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37389 PyObject *resultobj = 0;
37390 wxWindow *arg1 = (wxWindow *) 0 ;
37391 int arg2 ;
37392 bool result;
37393 void *argp1 = 0 ;
37394 int res1 = 0 ;
37395 int val2 ;
37396 int ecode2 = 0 ;
37397 PyObject * obj0 = 0 ;
37398 PyObject * obj1 = 0 ;
37399 char * kwnames[] = {
37400 (char *) "self",(char *) "lines", NULL
37401 };
37402
37403 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
37404 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37405 if (!SWIG_IsOK(res1)) {
37406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
37407 }
37408 arg1 = reinterpret_cast< wxWindow * >(argp1);
37409 ecode2 = SWIG_AsVal_int(obj1, &val2);
37410 if (!SWIG_IsOK(ecode2)) {
37411 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
37412 }
37413 arg2 = static_cast< int >(val2);
37414 {
37415 PyThreadState* __tstate = wxPyBeginAllowThreads();
37416 result = (bool)(arg1)->ScrollLines(arg2);
37417 wxPyEndAllowThreads(__tstate);
37418 if (PyErr_Occurred()) SWIG_fail;
37419 }
37420 {
37421 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37422 }
37423 return resultobj;
37424 fail:
37425 return NULL;
37426 }
37427
37428
37429 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37430 PyObject *resultobj = 0;
37431 wxWindow *arg1 = (wxWindow *) 0 ;
37432 int arg2 ;
37433 bool result;
37434 void *argp1 = 0 ;
37435 int res1 = 0 ;
37436 int val2 ;
37437 int ecode2 = 0 ;
37438 PyObject * obj0 = 0 ;
37439 PyObject * obj1 = 0 ;
37440 char * kwnames[] = {
37441 (char *) "self",(char *) "pages", NULL
37442 };
37443
37444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
37445 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37446 if (!SWIG_IsOK(res1)) {
37447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
37448 }
37449 arg1 = reinterpret_cast< wxWindow * >(argp1);
37450 ecode2 = SWIG_AsVal_int(obj1, &val2);
37451 if (!SWIG_IsOK(ecode2)) {
37452 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
37453 }
37454 arg2 = static_cast< int >(val2);
37455 {
37456 PyThreadState* __tstate = wxPyBeginAllowThreads();
37457 result = (bool)(arg1)->ScrollPages(arg2);
37458 wxPyEndAllowThreads(__tstate);
37459 if (PyErr_Occurred()) SWIG_fail;
37460 }
37461 {
37462 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37463 }
37464 return resultobj;
37465 fail:
37466 return NULL;
37467 }
37468
37469
37470 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37471 PyObject *resultobj = 0;
37472 wxWindow *arg1 = (wxWindow *) 0 ;
37473 bool result;
37474 void *argp1 = 0 ;
37475 int res1 = 0 ;
37476 PyObject *swig_obj[1] ;
37477
37478 if (!args) SWIG_fail;
37479 swig_obj[0] = args;
37480 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37481 if (!SWIG_IsOK(res1)) {
37482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
37483 }
37484 arg1 = reinterpret_cast< wxWindow * >(argp1);
37485 {
37486 PyThreadState* __tstate = wxPyBeginAllowThreads();
37487 result = (bool)(arg1)->LineUp();
37488 wxPyEndAllowThreads(__tstate);
37489 if (PyErr_Occurred()) SWIG_fail;
37490 }
37491 {
37492 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37493 }
37494 return resultobj;
37495 fail:
37496 return NULL;
37497 }
37498
37499
37500 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37501 PyObject *resultobj = 0;
37502 wxWindow *arg1 = (wxWindow *) 0 ;
37503 bool result;
37504 void *argp1 = 0 ;
37505 int res1 = 0 ;
37506 PyObject *swig_obj[1] ;
37507
37508 if (!args) SWIG_fail;
37509 swig_obj[0] = args;
37510 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37511 if (!SWIG_IsOK(res1)) {
37512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
37513 }
37514 arg1 = reinterpret_cast< wxWindow * >(argp1);
37515 {
37516 PyThreadState* __tstate = wxPyBeginAllowThreads();
37517 result = (bool)(arg1)->LineDown();
37518 wxPyEndAllowThreads(__tstate);
37519 if (PyErr_Occurred()) SWIG_fail;
37520 }
37521 {
37522 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37523 }
37524 return resultobj;
37525 fail:
37526 return NULL;
37527 }
37528
37529
37530 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37531 PyObject *resultobj = 0;
37532 wxWindow *arg1 = (wxWindow *) 0 ;
37533 bool result;
37534 void *argp1 = 0 ;
37535 int res1 = 0 ;
37536 PyObject *swig_obj[1] ;
37537
37538 if (!args) SWIG_fail;
37539 swig_obj[0] = args;
37540 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37541 if (!SWIG_IsOK(res1)) {
37542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
37543 }
37544 arg1 = reinterpret_cast< wxWindow * >(argp1);
37545 {
37546 PyThreadState* __tstate = wxPyBeginAllowThreads();
37547 result = (bool)(arg1)->PageUp();
37548 wxPyEndAllowThreads(__tstate);
37549 if (PyErr_Occurred()) SWIG_fail;
37550 }
37551 {
37552 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37553 }
37554 return resultobj;
37555 fail:
37556 return NULL;
37557 }
37558
37559
37560 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37561 PyObject *resultobj = 0;
37562 wxWindow *arg1 = (wxWindow *) 0 ;
37563 bool result;
37564 void *argp1 = 0 ;
37565 int res1 = 0 ;
37566 PyObject *swig_obj[1] ;
37567
37568 if (!args) SWIG_fail;
37569 swig_obj[0] = args;
37570 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37571 if (!SWIG_IsOK(res1)) {
37572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
37573 }
37574 arg1 = reinterpret_cast< wxWindow * >(argp1);
37575 {
37576 PyThreadState* __tstate = wxPyBeginAllowThreads();
37577 result = (bool)(arg1)->PageDown();
37578 wxPyEndAllowThreads(__tstate);
37579 if (PyErr_Occurred()) SWIG_fail;
37580 }
37581 {
37582 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37583 }
37584 return resultobj;
37585 fail:
37586 return NULL;
37587 }
37588
37589
37590 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37591 PyObject *resultobj = 0;
37592 wxWindow *arg1 = (wxWindow *) 0 ;
37593 wxString *arg2 = 0 ;
37594 void *argp1 = 0 ;
37595 int res1 = 0 ;
37596 bool temp2 = false ;
37597 PyObject * obj0 = 0 ;
37598 PyObject * obj1 = 0 ;
37599 char * kwnames[] = {
37600 (char *) "self",(char *) "text", NULL
37601 };
37602
37603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
37604 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37605 if (!SWIG_IsOK(res1)) {
37606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
37607 }
37608 arg1 = reinterpret_cast< wxWindow * >(argp1);
37609 {
37610 arg2 = wxString_in_helper(obj1);
37611 if (arg2 == NULL) SWIG_fail;
37612 temp2 = true;
37613 }
37614 {
37615 PyThreadState* __tstate = wxPyBeginAllowThreads();
37616 (arg1)->SetHelpText((wxString const &)*arg2);
37617 wxPyEndAllowThreads(__tstate);
37618 if (PyErr_Occurred()) SWIG_fail;
37619 }
37620 resultobj = SWIG_Py_Void();
37621 {
37622 if (temp2)
37623 delete arg2;
37624 }
37625 return resultobj;
37626 fail:
37627 {
37628 if (temp2)
37629 delete arg2;
37630 }
37631 return NULL;
37632 }
37633
37634
37635 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37636 PyObject *resultobj = 0;
37637 wxWindow *arg1 = (wxWindow *) 0 ;
37638 wxString *arg2 = 0 ;
37639 void *argp1 = 0 ;
37640 int res1 = 0 ;
37641 bool temp2 = false ;
37642 PyObject * obj0 = 0 ;
37643 PyObject * obj1 = 0 ;
37644 char * kwnames[] = {
37645 (char *) "self",(char *) "text", NULL
37646 };
37647
37648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
37649 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37650 if (!SWIG_IsOK(res1)) {
37651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
37652 }
37653 arg1 = reinterpret_cast< wxWindow * >(argp1);
37654 {
37655 arg2 = wxString_in_helper(obj1);
37656 if (arg2 == NULL) SWIG_fail;
37657 temp2 = true;
37658 }
37659 {
37660 PyThreadState* __tstate = wxPyBeginAllowThreads();
37661 (arg1)->SetHelpTextForId((wxString const &)*arg2);
37662 wxPyEndAllowThreads(__tstate);
37663 if (PyErr_Occurred()) SWIG_fail;
37664 }
37665 resultobj = SWIG_Py_Void();
37666 {
37667 if (temp2)
37668 delete arg2;
37669 }
37670 return resultobj;
37671 fail:
37672 {
37673 if (temp2)
37674 delete arg2;
37675 }
37676 return NULL;
37677 }
37678
37679
37680 SWIGINTERN PyObject *_wrap_Window_GetHelpTextAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37681 PyObject *resultobj = 0;
37682 wxWindow *arg1 = (wxWindow *) 0 ;
37683 wxPoint *arg2 = 0 ;
37684 wxHelpEvent::Origin arg3 ;
37685 wxString result;
37686 void *argp1 = 0 ;
37687 int res1 = 0 ;
37688 wxPoint temp2 ;
37689 void *argp3 ;
37690 int res3 = 0 ;
37691 PyObject * obj0 = 0 ;
37692 PyObject * obj1 = 0 ;
37693 PyObject * obj2 = 0 ;
37694 char * kwnames[] = {
37695 (char *) "self",(char *) "pt",(char *) "origin", NULL
37696 };
37697
37698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_GetHelpTextAtPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37699 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37700 if (!SWIG_IsOK(res1)) {
37701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
37702 }
37703 arg1 = reinterpret_cast< wxWindow * >(argp1);
37704 {
37705 arg2 = &temp2;
37706 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37707 }
37708 {
37709 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxHelpEvent__Origin, 0 | 0);
37710 if (!SWIG_IsOK(res3)) {
37711 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
37712 }
37713 if (!argp3) {
37714 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
37715 } else {
37716 wxHelpEvent::Origin * temp = reinterpret_cast< wxHelpEvent::Origin * >(argp3);
37717 arg3 = *temp;
37718 if (SWIG_IsNewObj(res3)) delete temp;
37719 }
37720 }
37721 {
37722 PyThreadState* __tstate = wxPyBeginAllowThreads();
37723 result = ((wxWindow const *)arg1)->GetHelpTextAtPoint((wxPoint const &)*arg2,arg3);
37724 wxPyEndAllowThreads(__tstate);
37725 if (PyErr_Occurred()) SWIG_fail;
37726 }
37727 {
37728 #if wxUSE_UNICODE
37729 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37730 #else
37731 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37732 #endif
37733 }
37734 return resultobj;
37735 fail:
37736 return NULL;
37737 }
37738
37739
37740 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37741 PyObject *resultobj = 0;
37742 wxWindow *arg1 = (wxWindow *) 0 ;
37743 wxString result;
37744 void *argp1 = 0 ;
37745 int res1 = 0 ;
37746 PyObject *swig_obj[1] ;
37747
37748 if (!args) SWIG_fail;
37749 swig_obj[0] = args;
37750 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37751 if (!SWIG_IsOK(res1)) {
37752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
37753 }
37754 arg1 = reinterpret_cast< wxWindow * >(argp1);
37755 {
37756 PyThreadState* __tstate = wxPyBeginAllowThreads();
37757 result = ((wxWindow const *)arg1)->GetHelpText();
37758 wxPyEndAllowThreads(__tstate);
37759 if (PyErr_Occurred()) SWIG_fail;
37760 }
37761 {
37762 #if wxUSE_UNICODE
37763 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37764 #else
37765 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37766 #endif
37767 }
37768 return resultobj;
37769 fail:
37770 return NULL;
37771 }
37772
37773
37774 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37775 PyObject *resultobj = 0;
37776 wxWindow *arg1 = (wxWindow *) 0 ;
37777 wxString *arg2 = 0 ;
37778 void *argp1 = 0 ;
37779 int res1 = 0 ;
37780 bool temp2 = false ;
37781 PyObject * obj0 = 0 ;
37782 PyObject * obj1 = 0 ;
37783 char * kwnames[] = {
37784 (char *) "self",(char *) "tip", NULL
37785 };
37786
37787 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
37788 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37789 if (!SWIG_IsOK(res1)) {
37790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
37791 }
37792 arg1 = reinterpret_cast< wxWindow * >(argp1);
37793 {
37794 arg2 = wxString_in_helper(obj1);
37795 if (arg2 == NULL) SWIG_fail;
37796 temp2 = true;
37797 }
37798 {
37799 PyThreadState* __tstate = wxPyBeginAllowThreads();
37800 (arg1)->SetToolTip((wxString const &)*arg2);
37801 wxPyEndAllowThreads(__tstate);
37802 if (PyErr_Occurred()) SWIG_fail;
37803 }
37804 resultobj = SWIG_Py_Void();
37805 {
37806 if (temp2)
37807 delete arg2;
37808 }
37809 return resultobj;
37810 fail:
37811 {
37812 if (temp2)
37813 delete arg2;
37814 }
37815 return NULL;
37816 }
37817
37818
37819 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37820 PyObject *resultobj = 0;
37821 wxWindow *arg1 = (wxWindow *) 0 ;
37822 wxToolTip *arg2 = (wxToolTip *) 0 ;
37823 void *argp1 = 0 ;
37824 int res1 = 0 ;
37825 int res2 = 0 ;
37826 PyObject * obj0 = 0 ;
37827 PyObject * obj1 = 0 ;
37828 char * kwnames[] = {
37829 (char *) "self",(char *) "tip", NULL
37830 };
37831
37832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
37833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37834 if (!SWIG_IsOK(res1)) {
37835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
37836 }
37837 arg1 = reinterpret_cast< wxWindow * >(argp1);
37838 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
37839 if (!SWIG_IsOK(res2)) {
37840 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
37841 }
37842 {
37843 PyThreadState* __tstate = wxPyBeginAllowThreads();
37844 (arg1)->SetToolTip(arg2);
37845 wxPyEndAllowThreads(__tstate);
37846 if (PyErr_Occurred()) SWIG_fail;
37847 }
37848 resultobj = SWIG_Py_Void();
37849 return resultobj;
37850 fail:
37851 return NULL;
37852 }
37853
37854
37855 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37856 PyObject *resultobj = 0;
37857 wxWindow *arg1 = (wxWindow *) 0 ;
37858 wxToolTip *result = 0 ;
37859 void *argp1 = 0 ;
37860 int res1 = 0 ;
37861 PyObject *swig_obj[1] ;
37862
37863 if (!args) SWIG_fail;
37864 swig_obj[0] = args;
37865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37866 if (!SWIG_IsOK(res1)) {
37867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
37868 }
37869 arg1 = reinterpret_cast< wxWindow * >(argp1);
37870 {
37871 PyThreadState* __tstate = wxPyBeginAllowThreads();
37872 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
37873 wxPyEndAllowThreads(__tstate);
37874 if (PyErr_Occurred()) SWIG_fail;
37875 }
37876 {
37877 resultobj = wxPyMake_wxObject(result, (bool)0);
37878 }
37879 return resultobj;
37880 fail:
37881 return NULL;
37882 }
37883
37884
37885 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37886 PyObject *resultobj = 0;
37887 wxWindow *arg1 = (wxWindow *) 0 ;
37888 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
37889 void *argp1 = 0 ;
37890 int res1 = 0 ;
37891 int res2 = 0 ;
37892 PyObject * obj0 = 0 ;
37893 PyObject * obj1 = 0 ;
37894 char * kwnames[] = {
37895 (char *) "self",(char *) "dropTarget", NULL
37896 };
37897
37898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
37899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37900 if (!SWIG_IsOK(res1)) {
37901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
37902 }
37903 arg1 = reinterpret_cast< wxWindow * >(argp1);
37904 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
37905 if (!SWIG_IsOK(res2)) {
37906 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
37907 }
37908 {
37909 PyThreadState* __tstate = wxPyBeginAllowThreads();
37910 (arg1)->SetDropTarget(arg2);
37911 wxPyEndAllowThreads(__tstate);
37912 if (PyErr_Occurred()) SWIG_fail;
37913 }
37914 resultobj = SWIG_Py_Void();
37915 return resultobj;
37916 fail:
37917 return NULL;
37918 }
37919
37920
37921 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37922 PyObject *resultobj = 0;
37923 wxWindow *arg1 = (wxWindow *) 0 ;
37924 wxPyDropTarget *result = 0 ;
37925 void *argp1 = 0 ;
37926 int res1 = 0 ;
37927 PyObject *swig_obj[1] ;
37928
37929 if (!args) SWIG_fail;
37930 swig_obj[0] = args;
37931 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37932 if (!SWIG_IsOK(res1)) {
37933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
37934 }
37935 arg1 = reinterpret_cast< wxWindow * >(argp1);
37936 {
37937 PyThreadState* __tstate = wxPyBeginAllowThreads();
37938 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
37939 wxPyEndAllowThreads(__tstate);
37940 if (PyErr_Occurred()) SWIG_fail;
37941 }
37942 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
37943 return resultobj;
37944 fail:
37945 return NULL;
37946 }
37947
37948
37949 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37950 PyObject *resultobj = 0;
37951 wxWindow *arg1 = (wxWindow *) 0 ;
37952 bool arg2 ;
37953 void *argp1 = 0 ;
37954 int res1 = 0 ;
37955 bool val2 ;
37956 int ecode2 = 0 ;
37957 PyObject * obj0 = 0 ;
37958 PyObject * obj1 = 0 ;
37959 char * kwnames[] = {
37960 (char *) "self",(char *) "accept", NULL
37961 };
37962
37963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
37964 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37965 if (!SWIG_IsOK(res1)) {
37966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
37967 }
37968 arg1 = reinterpret_cast< wxWindow * >(argp1);
37969 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37970 if (!SWIG_IsOK(ecode2)) {
37971 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
37972 }
37973 arg2 = static_cast< bool >(val2);
37974 {
37975 PyThreadState* __tstate = wxPyBeginAllowThreads();
37976 wxWindow_DragAcceptFiles(arg1,arg2);
37977 wxPyEndAllowThreads(__tstate);
37978 if (PyErr_Occurred()) SWIG_fail;
37979 }
37980 resultobj = SWIG_Py_Void();
37981 return resultobj;
37982 fail:
37983 return NULL;
37984 }
37985
37986
37987 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37988 PyObject *resultobj = 0;
37989 wxWindow *arg1 = (wxWindow *) 0 ;
37990 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
37991 void *argp1 = 0 ;
37992 int res1 = 0 ;
37993 int res2 = 0 ;
37994 PyObject * obj0 = 0 ;
37995 PyObject * obj1 = 0 ;
37996 char * kwnames[] = {
37997 (char *) "self",(char *) "constraints", NULL
37998 };
37999
38000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
38001 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38002 if (!SWIG_IsOK(res1)) {
38003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
38004 }
38005 arg1 = reinterpret_cast< wxWindow * >(argp1);
38006 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
38007 if (!SWIG_IsOK(res2)) {
38008 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
38009 }
38010 {
38011 PyThreadState* __tstate = wxPyBeginAllowThreads();
38012 (arg1)->SetConstraints(arg2);
38013 wxPyEndAllowThreads(__tstate);
38014 if (PyErr_Occurred()) SWIG_fail;
38015 }
38016 resultobj = SWIG_Py_Void();
38017 return resultobj;
38018 fail:
38019 return NULL;
38020 }
38021
38022
38023 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38024 PyObject *resultobj = 0;
38025 wxWindow *arg1 = (wxWindow *) 0 ;
38026 wxLayoutConstraints *result = 0 ;
38027 void *argp1 = 0 ;
38028 int res1 = 0 ;
38029 PyObject *swig_obj[1] ;
38030
38031 if (!args) SWIG_fail;
38032 swig_obj[0] = args;
38033 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38034 if (!SWIG_IsOK(res1)) {
38035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
38036 }
38037 arg1 = reinterpret_cast< wxWindow * >(argp1);
38038 {
38039 PyThreadState* __tstate = wxPyBeginAllowThreads();
38040 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
38041 wxPyEndAllowThreads(__tstate);
38042 if (PyErr_Occurred()) SWIG_fail;
38043 }
38044 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
38045 return resultobj;
38046 fail:
38047 return NULL;
38048 }
38049
38050
38051 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38052 PyObject *resultobj = 0;
38053 wxWindow *arg1 = (wxWindow *) 0 ;
38054 bool arg2 ;
38055 void *argp1 = 0 ;
38056 int res1 = 0 ;
38057 bool val2 ;
38058 int ecode2 = 0 ;
38059 PyObject * obj0 = 0 ;
38060 PyObject * obj1 = 0 ;
38061 char * kwnames[] = {
38062 (char *) "self",(char *) "autoLayout", NULL
38063 };
38064
38065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
38066 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38067 if (!SWIG_IsOK(res1)) {
38068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
38069 }
38070 arg1 = reinterpret_cast< wxWindow * >(argp1);
38071 ecode2 = SWIG_AsVal_bool(obj1, &val2);
38072 if (!SWIG_IsOK(ecode2)) {
38073 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
38074 }
38075 arg2 = static_cast< bool >(val2);
38076 {
38077 PyThreadState* __tstate = wxPyBeginAllowThreads();
38078 (arg1)->SetAutoLayout(arg2);
38079 wxPyEndAllowThreads(__tstate);
38080 if (PyErr_Occurred()) SWIG_fail;
38081 }
38082 resultobj = SWIG_Py_Void();
38083 return resultobj;
38084 fail:
38085 return NULL;
38086 }
38087
38088
38089 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38090 PyObject *resultobj = 0;
38091 wxWindow *arg1 = (wxWindow *) 0 ;
38092 bool result;
38093 void *argp1 = 0 ;
38094 int res1 = 0 ;
38095 PyObject *swig_obj[1] ;
38096
38097 if (!args) SWIG_fail;
38098 swig_obj[0] = args;
38099 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38100 if (!SWIG_IsOK(res1)) {
38101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
38102 }
38103 arg1 = reinterpret_cast< wxWindow * >(argp1);
38104 {
38105 PyThreadState* __tstate = wxPyBeginAllowThreads();
38106 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
38107 wxPyEndAllowThreads(__tstate);
38108 if (PyErr_Occurred()) SWIG_fail;
38109 }
38110 {
38111 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38112 }
38113 return resultobj;
38114 fail:
38115 return NULL;
38116 }
38117
38118
38119 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38120 PyObject *resultobj = 0;
38121 wxWindow *arg1 = (wxWindow *) 0 ;
38122 bool result;
38123 void *argp1 = 0 ;
38124 int res1 = 0 ;
38125 PyObject *swig_obj[1] ;
38126
38127 if (!args) SWIG_fail;
38128 swig_obj[0] = args;
38129 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38130 if (!SWIG_IsOK(res1)) {
38131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
38132 }
38133 arg1 = reinterpret_cast< wxWindow * >(argp1);
38134 {
38135 PyThreadState* __tstate = wxPyBeginAllowThreads();
38136 result = (bool)(arg1)->Layout();
38137 wxPyEndAllowThreads(__tstate);
38138 if (PyErr_Occurred()) SWIG_fail;
38139 }
38140 {
38141 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38142 }
38143 return resultobj;
38144 fail:
38145 return NULL;
38146 }
38147
38148
38149 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38150 PyObject *resultobj = 0;
38151 wxWindow *arg1 = (wxWindow *) 0 ;
38152 wxSizer *arg2 = (wxSizer *) 0 ;
38153 bool arg3 = (bool) true ;
38154 void *argp1 = 0 ;
38155 int res1 = 0 ;
38156 int res2 = 0 ;
38157 bool val3 ;
38158 int ecode3 = 0 ;
38159 PyObject * obj0 = 0 ;
38160 PyObject * obj1 = 0 ;
38161 PyObject * obj2 = 0 ;
38162 char * kwnames[] = {
38163 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
38164 };
38165
38166 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38167 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38168 if (!SWIG_IsOK(res1)) {
38169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
38170 }
38171 arg1 = reinterpret_cast< wxWindow * >(argp1);
38172 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
38173 if (!SWIG_IsOK(res2)) {
38174 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
38175 }
38176 if (obj2) {
38177 ecode3 = SWIG_AsVal_bool(obj2, &val3);
38178 if (!SWIG_IsOK(ecode3)) {
38179 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
38180 }
38181 arg3 = static_cast< bool >(val3);
38182 }
38183 {
38184 PyThreadState* __tstate = wxPyBeginAllowThreads();
38185 (arg1)->SetSizer(arg2,arg3);
38186 wxPyEndAllowThreads(__tstate);
38187 if (PyErr_Occurred()) SWIG_fail;
38188 }
38189 resultobj = SWIG_Py_Void();
38190 return resultobj;
38191 fail:
38192 return NULL;
38193 }
38194
38195
38196 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38197 PyObject *resultobj = 0;
38198 wxWindow *arg1 = (wxWindow *) 0 ;
38199 wxSizer *arg2 = (wxSizer *) 0 ;
38200 bool arg3 = (bool) true ;
38201 void *argp1 = 0 ;
38202 int res1 = 0 ;
38203 int res2 = 0 ;
38204 bool val3 ;
38205 int ecode3 = 0 ;
38206 PyObject * obj0 = 0 ;
38207 PyObject * obj1 = 0 ;
38208 PyObject * obj2 = 0 ;
38209 char * kwnames[] = {
38210 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
38211 };
38212
38213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38214 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38215 if (!SWIG_IsOK(res1)) {
38216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
38217 }
38218 arg1 = reinterpret_cast< wxWindow * >(argp1);
38219 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
38220 if (!SWIG_IsOK(res2)) {
38221 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
38222 }
38223 if (obj2) {
38224 ecode3 = SWIG_AsVal_bool(obj2, &val3);
38225 if (!SWIG_IsOK(ecode3)) {
38226 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
38227 }
38228 arg3 = static_cast< bool >(val3);
38229 }
38230 {
38231 PyThreadState* __tstate = wxPyBeginAllowThreads();
38232 (arg1)->SetSizerAndFit(arg2,arg3);
38233 wxPyEndAllowThreads(__tstate);
38234 if (PyErr_Occurred()) SWIG_fail;
38235 }
38236 resultobj = SWIG_Py_Void();
38237 return resultobj;
38238 fail:
38239 return NULL;
38240 }
38241
38242
38243 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38244 PyObject *resultobj = 0;
38245 wxWindow *arg1 = (wxWindow *) 0 ;
38246 wxSizer *result = 0 ;
38247 void *argp1 = 0 ;
38248 int res1 = 0 ;
38249 PyObject *swig_obj[1] ;
38250
38251 if (!args) SWIG_fail;
38252 swig_obj[0] = args;
38253 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38254 if (!SWIG_IsOK(res1)) {
38255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
38256 }
38257 arg1 = reinterpret_cast< wxWindow * >(argp1);
38258 {
38259 PyThreadState* __tstate = wxPyBeginAllowThreads();
38260 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
38261 wxPyEndAllowThreads(__tstate);
38262 if (PyErr_Occurred()) SWIG_fail;
38263 }
38264 {
38265 resultobj = wxPyMake_wxObject(result, (bool)0);
38266 }
38267 return resultobj;
38268 fail:
38269 return NULL;
38270 }
38271
38272
38273 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38274 PyObject *resultobj = 0;
38275 wxWindow *arg1 = (wxWindow *) 0 ;
38276 wxSizer *arg2 = (wxSizer *) 0 ;
38277 void *argp1 = 0 ;
38278 int res1 = 0 ;
38279 void *argp2 = 0 ;
38280 int res2 = 0 ;
38281 PyObject * obj0 = 0 ;
38282 PyObject * obj1 = 0 ;
38283 char * kwnames[] = {
38284 (char *) "self",(char *) "sizer", NULL
38285 };
38286
38287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
38288 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38289 if (!SWIG_IsOK(res1)) {
38290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
38291 }
38292 arg1 = reinterpret_cast< wxWindow * >(argp1);
38293 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
38294 if (!SWIG_IsOK(res2)) {
38295 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
38296 }
38297 arg2 = reinterpret_cast< wxSizer * >(argp2);
38298 {
38299 PyThreadState* __tstate = wxPyBeginAllowThreads();
38300 (arg1)->SetContainingSizer(arg2);
38301 wxPyEndAllowThreads(__tstate);
38302 if (PyErr_Occurred()) SWIG_fail;
38303 }
38304 resultobj = SWIG_Py_Void();
38305 return resultobj;
38306 fail:
38307 return NULL;
38308 }
38309
38310
38311 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38312 PyObject *resultobj = 0;
38313 wxWindow *arg1 = (wxWindow *) 0 ;
38314 wxSizer *result = 0 ;
38315 void *argp1 = 0 ;
38316 int res1 = 0 ;
38317 PyObject *swig_obj[1] ;
38318
38319 if (!args) SWIG_fail;
38320 swig_obj[0] = args;
38321 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38322 if (!SWIG_IsOK(res1)) {
38323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
38324 }
38325 arg1 = reinterpret_cast< wxWindow * >(argp1);
38326 {
38327 PyThreadState* __tstate = wxPyBeginAllowThreads();
38328 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
38329 wxPyEndAllowThreads(__tstate);
38330 if (PyErr_Occurred()) SWIG_fail;
38331 }
38332 {
38333 resultobj = wxPyMake_wxObject(result, (bool)0);
38334 }
38335 return resultobj;
38336 fail:
38337 return NULL;
38338 }
38339
38340
38341 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38342 PyObject *resultobj = 0;
38343 wxWindow *arg1 = (wxWindow *) 0 ;
38344 void *argp1 = 0 ;
38345 int res1 = 0 ;
38346 PyObject *swig_obj[1] ;
38347
38348 if (!args) SWIG_fail;
38349 swig_obj[0] = args;
38350 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38351 if (!SWIG_IsOK(res1)) {
38352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
38353 }
38354 arg1 = reinterpret_cast< wxWindow * >(argp1);
38355 {
38356 PyThreadState* __tstate = wxPyBeginAllowThreads();
38357 (arg1)->InheritAttributes();
38358 wxPyEndAllowThreads(__tstate);
38359 if (PyErr_Occurred()) SWIG_fail;
38360 }
38361 resultobj = SWIG_Py_Void();
38362 return resultobj;
38363 fail:
38364 return NULL;
38365 }
38366
38367
38368 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38369 PyObject *resultobj = 0;
38370 wxWindow *arg1 = (wxWindow *) 0 ;
38371 bool result;
38372 void *argp1 = 0 ;
38373 int res1 = 0 ;
38374 PyObject *swig_obj[1] ;
38375
38376 if (!args) SWIG_fail;
38377 swig_obj[0] = args;
38378 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38379 if (!SWIG_IsOK(res1)) {
38380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
38381 }
38382 arg1 = reinterpret_cast< wxWindow * >(argp1);
38383 {
38384 PyThreadState* __tstate = wxPyBeginAllowThreads();
38385 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
38386 wxPyEndAllowThreads(__tstate);
38387 if (PyErr_Occurred()) SWIG_fail;
38388 }
38389 {
38390 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38391 }
38392 return resultobj;
38393 fail:
38394 return NULL;
38395 }
38396
38397
38398 SWIGINTERN PyObject *_wrap_Window_CanSetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38399 PyObject *resultobj = 0;
38400 wxWindow *arg1 = (wxWindow *) 0 ;
38401 bool result;
38402 void *argp1 = 0 ;
38403 int res1 = 0 ;
38404 PyObject *swig_obj[1] ;
38405
38406 if (!args) SWIG_fail;
38407 swig_obj[0] = args;
38408 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38409 if (!SWIG_IsOK(res1)) {
38410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CanSetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
38411 }
38412 arg1 = reinterpret_cast< wxWindow * >(argp1);
38413 {
38414 PyThreadState* __tstate = wxPyBeginAllowThreads();
38415 result = (bool)(arg1)->CanSetTransparent();
38416 wxPyEndAllowThreads(__tstate);
38417 if (PyErr_Occurred()) SWIG_fail;
38418 }
38419 {
38420 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38421 }
38422 return resultobj;
38423 fail:
38424 return NULL;
38425 }
38426
38427
38428 SWIGINTERN PyObject *_wrap_Window_SetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38429 PyObject *resultobj = 0;
38430 wxWindow *arg1 = (wxWindow *) 0 ;
38431 byte arg2 ;
38432 bool result;
38433 void *argp1 = 0 ;
38434 int res1 = 0 ;
38435 unsigned char val2 ;
38436 int ecode2 = 0 ;
38437 PyObject * obj0 = 0 ;
38438 PyObject * obj1 = 0 ;
38439 char * kwnames[] = {
38440 (char *) "self",(char *) "alpha", NULL
38441 };
38442
38443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTransparent",kwnames,&obj0,&obj1)) SWIG_fail;
38444 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38445 if (!SWIG_IsOK(res1)) {
38446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
38447 }
38448 arg1 = reinterpret_cast< wxWindow * >(argp1);
38449 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
38450 if (!SWIG_IsOK(ecode2)) {
38451 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetTransparent" "', expected argument " "2"" of type '" "byte""'");
38452 }
38453 arg2 = static_cast< byte >(val2);
38454 {
38455 PyThreadState* __tstate = wxPyBeginAllowThreads();
38456 result = (bool)(arg1)->SetTransparent(arg2);
38457 wxPyEndAllowThreads(__tstate);
38458 if (PyErr_Occurred()) SWIG_fail;
38459 }
38460 {
38461 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38462 }
38463 return resultobj;
38464 fail:
38465 return NULL;
38466 }
38467
38468
38469 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38470 PyObject *obj;
38471 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38472 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
38473 return SWIG_Py_Void();
38474 }
38475
38476 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38477 return SWIG_Python_InitShadowInstance(args);
38478 }
38479
38480 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38481 PyObject *resultobj = 0;
38482 long arg1 ;
38483 wxWindow *arg2 = (wxWindow *) NULL ;
38484 wxWindow *result = 0 ;
38485 long val1 ;
38486 int ecode1 = 0 ;
38487 void *argp2 = 0 ;
38488 int res2 = 0 ;
38489 PyObject * obj0 = 0 ;
38490 PyObject * obj1 = 0 ;
38491 char * kwnames[] = {
38492 (char *) "id",(char *) "parent", NULL
38493 };
38494
38495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
38496 ecode1 = SWIG_AsVal_long(obj0, &val1);
38497 if (!SWIG_IsOK(ecode1)) {
38498 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
38499 }
38500 arg1 = static_cast< long >(val1);
38501 if (obj1) {
38502 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38503 if (!SWIG_IsOK(res2)) {
38504 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
38505 }
38506 arg2 = reinterpret_cast< wxWindow * >(argp2);
38507 }
38508 {
38509 if (!wxPyCheckForApp()) SWIG_fail;
38510 PyThreadState* __tstate = wxPyBeginAllowThreads();
38511 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
38512 wxPyEndAllowThreads(__tstate);
38513 if (PyErr_Occurred()) SWIG_fail;
38514 }
38515 {
38516 resultobj = wxPyMake_wxObject(result, 0);
38517 }
38518 return resultobj;
38519 fail:
38520 return NULL;
38521 }
38522
38523
38524 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38525 PyObject *resultobj = 0;
38526 wxString *arg1 = 0 ;
38527 wxWindow *arg2 = (wxWindow *) NULL ;
38528 wxWindow *result = 0 ;
38529 bool temp1 = false ;
38530 void *argp2 = 0 ;
38531 int res2 = 0 ;
38532 PyObject * obj0 = 0 ;
38533 PyObject * obj1 = 0 ;
38534 char * kwnames[] = {
38535 (char *) "name",(char *) "parent", NULL
38536 };
38537
38538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
38539 {
38540 arg1 = wxString_in_helper(obj0);
38541 if (arg1 == NULL) SWIG_fail;
38542 temp1 = true;
38543 }
38544 if (obj1) {
38545 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38546 if (!SWIG_IsOK(res2)) {
38547 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
38548 }
38549 arg2 = reinterpret_cast< wxWindow * >(argp2);
38550 }
38551 {
38552 if (!wxPyCheckForApp()) SWIG_fail;
38553 PyThreadState* __tstate = wxPyBeginAllowThreads();
38554 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
38555 wxPyEndAllowThreads(__tstate);
38556 if (PyErr_Occurred()) SWIG_fail;
38557 }
38558 {
38559 resultobj = wxPyMake_wxObject(result, 0);
38560 }
38561 {
38562 if (temp1)
38563 delete arg1;
38564 }
38565 return resultobj;
38566 fail:
38567 {
38568 if (temp1)
38569 delete arg1;
38570 }
38571 return NULL;
38572 }
38573
38574
38575 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38576 PyObject *resultobj = 0;
38577 wxString *arg1 = 0 ;
38578 wxWindow *arg2 = (wxWindow *) NULL ;
38579 wxWindow *result = 0 ;
38580 bool temp1 = false ;
38581 void *argp2 = 0 ;
38582 int res2 = 0 ;
38583 PyObject * obj0 = 0 ;
38584 PyObject * obj1 = 0 ;
38585 char * kwnames[] = {
38586 (char *) "label",(char *) "parent", NULL
38587 };
38588
38589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
38590 {
38591 arg1 = wxString_in_helper(obj0);
38592 if (arg1 == NULL) SWIG_fail;
38593 temp1 = true;
38594 }
38595 if (obj1) {
38596 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38597 if (!SWIG_IsOK(res2)) {
38598 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
38599 }
38600 arg2 = reinterpret_cast< wxWindow * >(argp2);
38601 }
38602 {
38603 if (!wxPyCheckForApp()) SWIG_fail;
38604 PyThreadState* __tstate = wxPyBeginAllowThreads();
38605 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
38606 wxPyEndAllowThreads(__tstate);
38607 if (PyErr_Occurred()) SWIG_fail;
38608 }
38609 {
38610 resultobj = wxPyMake_wxObject(result, 0);
38611 }
38612 {
38613 if (temp1)
38614 delete arg1;
38615 }
38616 return resultobj;
38617 fail:
38618 {
38619 if (temp1)
38620 delete arg1;
38621 }
38622 return NULL;
38623 }
38624
38625
38626 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38627 PyObject *resultobj = 0;
38628 wxWindow *arg1 = (wxWindow *) 0 ;
38629 unsigned long arg2 ;
38630 wxWindow *result = 0 ;
38631 void *argp1 = 0 ;
38632 int res1 = 0 ;
38633 unsigned long val2 ;
38634 int ecode2 = 0 ;
38635 PyObject * obj0 = 0 ;
38636 PyObject * obj1 = 0 ;
38637 char * kwnames[] = {
38638 (char *) "parent",(char *) "_hWnd", NULL
38639 };
38640
38641 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
38642 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38643 if (!SWIG_IsOK(res1)) {
38644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
38645 }
38646 arg1 = reinterpret_cast< wxWindow * >(argp1);
38647 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
38648 if (!SWIG_IsOK(ecode2)) {
38649 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
38650 }
38651 arg2 = static_cast< unsigned long >(val2);
38652 {
38653 PyThreadState* __tstate = wxPyBeginAllowThreads();
38654 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
38655 wxPyEndAllowThreads(__tstate);
38656 if (PyErr_Occurred()) SWIG_fail;
38657 }
38658 {
38659 resultobj = wxPyMake_wxObject(result, 0);
38660 }
38661 return resultobj;
38662 fail:
38663 return NULL;
38664 }
38665
38666
38667 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38668 PyObject *resultobj = 0;
38669 PyObject *result = 0 ;
38670
38671 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
38672 {
38673 PyThreadState* __tstate = wxPyBeginAllowThreads();
38674 result = (PyObject *)GetTopLevelWindows();
38675 wxPyEndAllowThreads(__tstate);
38676 if (PyErr_Occurred()) SWIG_fail;
38677 }
38678 resultobj = result;
38679 return resultobj;
38680 fail:
38681 return NULL;
38682 }
38683
38684
38685 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38686 PyObject *resultobj = 0;
38687 wxValidator *result = 0 ;
38688
38689 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
38690 {
38691 PyThreadState* __tstate = wxPyBeginAllowThreads();
38692 result = (wxValidator *)new wxValidator();
38693 wxPyEndAllowThreads(__tstate);
38694 if (PyErr_Occurred()) SWIG_fail;
38695 }
38696 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
38697 return resultobj;
38698 fail:
38699 return NULL;
38700 }
38701
38702
38703 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38704 PyObject *resultobj = 0;
38705 wxValidator *arg1 = (wxValidator *) 0 ;
38706 wxValidator *result = 0 ;
38707 void *argp1 = 0 ;
38708 int res1 = 0 ;
38709 PyObject *swig_obj[1] ;
38710
38711 if (!args) SWIG_fail;
38712 swig_obj[0] = args;
38713 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38714 if (!SWIG_IsOK(res1)) {
38715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
38716 }
38717 arg1 = reinterpret_cast< wxValidator * >(argp1);
38718 {
38719 PyThreadState* __tstate = wxPyBeginAllowThreads();
38720 result = (wxValidator *)(arg1)->Clone();
38721 wxPyEndAllowThreads(__tstate);
38722 if (PyErr_Occurred()) SWIG_fail;
38723 }
38724 {
38725 resultobj = wxPyMake_wxObject(result, 0);
38726 }
38727 return resultobj;
38728 fail:
38729 return NULL;
38730 }
38731
38732
38733 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38734 PyObject *resultobj = 0;
38735 wxValidator *arg1 = (wxValidator *) 0 ;
38736 wxWindow *arg2 = (wxWindow *) 0 ;
38737 bool result;
38738 void *argp1 = 0 ;
38739 int res1 = 0 ;
38740 void *argp2 = 0 ;
38741 int res2 = 0 ;
38742 PyObject * obj0 = 0 ;
38743 PyObject * obj1 = 0 ;
38744 char * kwnames[] = {
38745 (char *) "self",(char *) "parent", NULL
38746 };
38747
38748 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
38749 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38750 if (!SWIG_IsOK(res1)) {
38751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
38752 }
38753 arg1 = reinterpret_cast< wxValidator * >(argp1);
38754 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38755 if (!SWIG_IsOK(res2)) {
38756 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
38757 }
38758 arg2 = reinterpret_cast< wxWindow * >(argp2);
38759 {
38760 PyThreadState* __tstate = wxPyBeginAllowThreads();
38761 result = (bool)(arg1)->Validate(arg2);
38762 wxPyEndAllowThreads(__tstate);
38763 if (PyErr_Occurred()) SWIG_fail;
38764 }
38765 {
38766 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38767 }
38768 return resultobj;
38769 fail:
38770 return NULL;
38771 }
38772
38773
38774 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38775 PyObject *resultobj = 0;
38776 wxValidator *arg1 = (wxValidator *) 0 ;
38777 bool result;
38778 void *argp1 = 0 ;
38779 int res1 = 0 ;
38780 PyObject *swig_obj[1] ;
38781
38782 if (!args) SWIG_fail;
38783 swig_obj[0] = args;
38784 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38785 if (!SWIG_IsOK(res1)) {
38786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38787 }
38788 arg1 = reinterpret_cast< wxValidator * >(argp1);
38789 {
38790 PyThreadState* __tstate = wxPyBeginAllowThreads();
38791 result = (bool)(arg1)->TransferToWindow();
38792 wxPyEndAllowThreads(__tstate);
38793 if (PyErr_Occurred()) SWIG_fail;
38794 }
38795 {
38796 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38797 }
38798 return resultobj;
38799 fail:
38800 return NULL;
38801 }
38802
38803
38804 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38805 PyObject *resultobj = 0;
38806 wxValidator *arg1 = (wxValidator *) 0 ;
38807 bool result;
38808 void *argp1 = 0 ;
38809 int res1 = 0 ;
38810 PyObject *swig_obj[1] ;
38811
38812 if (!args) SWIG_fail;
38813 swig_obj[0] = args;
38814 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38815 if (!SWIG_IsOK(res1)) {
38816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38817 }
38818 arg1 = reinterpret_cast< wxValidator * >(argp1);
38819 {
38820 PyThreadState* __tstate = wxPyBeginAllowThreads();
38821 result = (bool)(arg1)->TransferFromWindow();
38822 wxPyEndAllowThreads(__tstate);
38823 if (PyErr_Occurred()) SWIG_fail;
38824 }
38825 {
38826 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38827 }
38828 return resultobj;
38829 fail:
38830 return NULL;
38831 }
38832
38833
38834 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38835 PyObject *resultobj = 0;
38836 wxValidator *arg1 = (wxValidator *) 0 ;
38837 wxWindow *result = 0 ;
38838 void *argp1 = 0 ;
38839 int res1 = 0 ;
38840 PyObject *swig_obj[1] ;
38841
38842 if (!args) SWIG_fail;
38843 swig_obj[0] = args;
38844 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38845 if (!SWIG_IsOK(res1)) {
38846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38847 }
38848 arg1 = reinterpret_cast< wxValidator * >(argp1);
38849 {
38850 PyThreadState* __tstate = wxPyBeginAllowThreads();
38851 result = (wxWindow *)(arg1)->GetWindow();
38852 wxPyEndAllowThreads(__tstate);
38853 if (PyErr_Occurred()) SWIG_fail;
38854 }
38855 {
38856 resultobj = wxPyMake_wxObject(result, 0);
38857 }
38858 return resultobj;
38859 fail:
38860 return NULL;
38861 }
38862
38863
38864 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38865 PyObject *resultobj = 0;
38866 wxValidator *arg1 = (wxValidator *) 0 ;
38867 wxWindow *arg2 = (wxWindow *) 0 ;
38868 void *argp1 = 0 ;
38869 int res1 = 0 ;
38870 void *argp2 = 0 ;
38871 int res2 = 0 ;
38872 PyObject * obj0 = 0 ;
38873 PyObject * obj1 = 0 ;
38874 char * kwnames[] = {
38875 (char *) "self",(char *) "window", NULL
38876 };
38877
38878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
38879 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38880 if (!SWIG_IsOK(res1)) {
38881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38882 }
38883 arg1 = reinterpret_cast< wxValidator * >(argp1);
38884 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38885 if (!SWIG_IsOK(res2)) {
38886 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
38887 }
38888 arg2 = reinterpret_cast< wxWindow * >(argp2);
38889 {
38890 PyThreadState* __tstate = wxPyBeginAllowThreads();
38891 (arg1)->SetWindow(arg2);
38892 wxPyEndAllowThreads(__tstate);
38893 if (PyErr_Occurred()) SWIG_fail;
38894 }
38895 resultobj = SWIG_Py_Void();
38896 return resultobj;
38897 fail:
38898 return NULL;
38899 }
38900
38901
38902 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38903 PyObject *resultobj = 0;
38904 bool result;
38905
38906 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
38907 {
38908 PyThreadState* __tstate = wxPyBeginAllowThreads();
38909 result = (bool)wxValidator::IsSilent();
38910 wxPyEndAllowThreads(__tstate);
38911 if (PyErr_Occurred()) SWIG_fail;
38912 }
38913 {
38914 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38915 }
38916 return resultobj;
38917 fail:
38918 return NULL;
38919 }
38920
38921
38922 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38923 PyObject *resultobj = 0;
38924 int arg1 = (int) true ;
38925 int val1 ;
38926 int ecode1 = 0 ;
38927 PyObject * obj0 = 0 ;
38928 char * kwnames[] = {
38929 (char *) "doIt", NULL
38930 };
38931
38932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
38933 if (obj0) {
38934 ecode1 = SWIG_AsVal_int(obj0, &val1);
38935 if (!SWIG_IsOK(ecode1)) {
38936 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
38937 }
38938 arg1 = static_cast< int >(val1);
38939 }
38940 {
38941 PyThreadState* __tstate = wxPyBeginAllowThreads();
38942 wxValidator::SetBellOnError(arg1);
38943 wxPyEndAllowThreads(__tstate);
38944 if (PyErr_Occurred()) SWIG_fail;
38945 }
38946 resultobj = SWIG_Py_Void();
38947 return resultobj;
38948 fail:
38949 return NULL;
38950 }
38951
38952
38953 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38954 PyObject *obj;
38955 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38956 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
38957 return SWIG_Py_Void();
38958 }
38959
38960 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38961 return SWIG_Python_InitShadowInstance(args);
38962 }
38963
38964 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38965 PyObject *resultobj = 0;
38966 wxPyValidator *result = 0 ;
38967
38968 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
38969 {
38970 PyThreadState* __tstate = wxPyBeginAllowThreads();
38971 result = (wxPyValidator *)new wxPyValidator();
38972 wxPyEndAllowThreads(__tstate);
38973 if (PyErr_Occurred()) SWIG_fail;
38974 }
38975 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
38976 return resultobj;
38977 fail:
38978 return NULL;
38979 }
38980
38981
38982 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38983 PyObject *resultobj = 0;
38984 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
38985 PyObject *arg2 = (PyObject *) 0 ;
38986 PyObject *arg3 = (PyObject *) 0 ;
38987 int arg4 = (int) true ;
38988 void *argp1 = 0 ;
38989 int res1 = 0 ;
38990 int val4 ;
38991 int ecode4 = 0 ;
38992 PyObject * obj0 = 0 ;
38993 PyObject * obj1 = 0 ;
38994 PyObject * obj2 = 0 ;
38995 PyObject * obj3 = 0 ;
38996 char * kwnames[] = {
38997 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
38998 };
38999
39000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39001 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
39002 if (!SWIG_IsOK(res1)) {
39003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
39004 }
39005 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
39006 arg2 = obj1;
39007 arg3 = obj2;
39008 if (obj3) {
39009 ecode4 = SWIG_AsVal_int(obj3, &val4);
39010 if (!SWIG_IsOK(ecode4)) {
39011 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
39012 }
39013 arg4 = static_cast< int >(val4);
39014 }
39015 {
39016 PyThreadState* __tstate = wxPyBeginAllowThreads();
39017 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
39018 wxPyEndAllowThreads(__tstate);
39019 if (PyErr_Occurred()) SWIG_fail;
39020 }
39021 resultobj = SWIG_Py_Void();
39022 return resultobj;
39023 fail:
39024 return NULL;
39025 }
39026
39027
39028 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39029 PyObject *obj;
39030 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
39031 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
39032 return SWIG_Py_Void();
39033 }
39034
39035 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39036 return SWIG_Python_InitShadowInstance(args);
39037 }
39038
39039 SWIGINTERN int DefaultValidator_set(PyObject *) {
39040 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
39041 return 1;
39042 }
39043
39044
39045 SWIGINTERN PyObject *DefaultValidator_get(void) {
39046 PyObject *pyobj = 0;
39047
39048 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
39049 return pyobj;
39050 }
39051
39052
39053 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39054 PyObject *resultobj = 0;
39055 wxString const &arg1_defvalue = wxPyEmptyString ;
39056 wxString *arg1 = (wxString *) &arg1_defvalue ;
39057 long arg2 = (long) 0 ;
39058 wxMenu *result = 0 ;
39059 bool temp1 = false ;
39060 long val2 ;
39061 int ecode2 = 0 ;
39062 PyObject * obj0 = 0 ;
39063 PyObject * obj1 = 0 ;
39064 char * kwnames[] = {
39065 (char *) "title",(char *) "style", NULL
39066 };
39067
39068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
39069 if (obj0) {
39070 {
39071 arg1 = wxString_in_helper(obj0);
39072 if (arg1 == NULL) SWIG_fail;
39073 temp1 = true;
39074 }
39075 }
39076 if (obj1) {
39077 ecode2 = SWIG_AsVal_long(obj1, &val2);
39078 if (!SWIG_IsOK(ecode2)) {
39079 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
39080 }
39081 arg2 = static_cast< long >(val2);
39082 }
39083 {
39084 if (!wxPyCheckForApp()) SWIG_fail;
39085 PyThreadState* __tstate = wxPyBeginAllowThreads();
39086 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
39087 wxPyEndAllowThreads(__tstate);
39088 if (PyErr_Occurred()) SWIG_fail;
39089 }
39090 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
39091 {
39092 if (temp1)
39093 delete arg1;
39094 }
39095 return resultobj;
39096 fail:
39097 {
39098 if (temp1)
39099 delete arg1;
39100 }
39101 return NULL;
39102 }
39103
39104
39105 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39106 PyObject *resultobj = 0;
39107 wxMenu *arg1 = (wxMenu *) 0 ;
39108 int arg2 ;
39109 wxString const &arg3_defvalue = wxPyEmptyString ;
39110 wxString *arg3 = (wxString *) &arg3_defvalue ;
39111 wxString const &arg4_defvalue = wxPyEmptyString ;
39112 wxString *arg4 = (wxString *) &arg4_defvalue ;
39113 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
39114 wxMenuItem *result = 0 ;
39115 void *argp1 = 0 ;
39116 int res1 = 0 ;
39117 int val2 ;
39118 int ecode2 = 0 ;
39119 bool temp3 = false ;
39120 bool temp4 = false ;
39121 int val5 ;
39122 int ecode5 = 0 ;
39123 PyObject * obj0 = 0 ;
39124 PyObject * obj1 = 0 ;
39125 PyObject * obj2 = 0 ;
39126 PyObject * obj3 = 0 ;
39127 PyObject * obj4 = 0 ;
39128 char * kwnames[] = {
39129 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
39130 };
39131
39132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39133 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39134 if (!SWIG_IsOK(res1)) {
39135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
39136 }
39137 arg1 = reinterpret_cast< wxMenu * >(argp1);
39138 ecode2 = SWIG_AsVal_int(obj1, &val2);
39139 if (!SWIG_IsOK(ecode2)) {
39140 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
39141 }
39142 arg2 = static_cast< int >(val2);
39143 if (obj2) {
39144 {
39145 arg3 = wxString_in_helper(obj2);
39146 if (arg3 == NULL) SWIG_fail;
39147 temp3 = true;
39148 }
39149 }
39150 if (obj3) {
39151 {
39152 arg4 = wxString_in_helper(obj3);
39153 if (arg4 == NULL) SWIG_fail;
39154 temp4 = true;
39155 }
39156 }
39157 if (obj4) {
39158 ecode5 = SWIG_AsVal_int(obj4, &val5);
39159 if (!SWIG_IsOK(ecode5)) {
39160 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
39161 }
39162 arg5 = static_cast< wxItemKind >(val5);
39163 }
39164 {
39165 PyThreadState* __tstate = wxPyBeginAllowThreads();
39166 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
39167 wxPyEndAllowThreads(__tstate);
39168 if (PyErr_Occurred()) SWIG_fail;
39169 }
39170 {
39171 resultobj = wxPyMake_wxObject(result, (bool)0);
39172 }
39173 {
39174 if (temp3)
39175 delete arg3;
39176 }
39177 {
39178 if (temp4)
39179 delete arg4;
39180 }
39181 return resultobj;
39182 fail:
39183 {
39184 if (temp3)
39185 delete arg3;
39186 }
39187 {
39188 if (temp4)
39189 delete arg4;
39190 }
39191 return NULL;
39192 }
39193
39194
39195 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39196 PyObject *resultobj = 0;
39197 wxMenu *arg1 = (wxMenu *) 0 ;
39198 wxMenuItem *result = 0 ;
39199 void *argp1 = 0 ;
39200 int res1 = 0 ;
39201 PyObject *swig_obj[1] ;
39202
39203 if (!args) SWIG_fail;
39204 swig_obj[0] = args;
39205 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39206 if (!SWIG_IsOK(res1)) {
39207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39208 }
39209 arg1 = reinterpret_cast< wxMenu * >(argp1);
39210 {
39211 PyThreadState* __tstate = wxPyBeginAllowThreads();
39212 result = (wxMenuItem *)(arg1)->AppendSeparator();
39213 wxPyEndAllowThreads(__tstate);
39214 if (PyErr_Occurred()) SWIG_fail;
39215 }
39216 {
39217 resultobj = wxPyMake_wxObject(result, (bool)0);
39218 }
39219 return resultobj;
39220 fail:
39221 return NULL;
39222 }
39223
39224
39225 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39226 PyObject *resultobj = 0;
39227 wxMenu *arg1 = (wxMenu *) 0 ;
39228 int arg2 ;
39229 wxString *arg3 = 0 ;
39230 wxString const &arg4_defvalue = wxPyEmptyString ;
39231 wxString *arg4 = (wxString *) &arg4_defvalue ;
39232 wxMenuItem *result = 0 ;
39233 void *argp1 = 0 ;
39234 int res1 = 0 ;
39235 int val2 ;
39236 int ecode2 = 0 ;
39237 bool temp3 = false ;
39238 bool temp4 = false ;
39239 PyObject * obj0 = 0 ;
39240 PyObject * obj1 = 0 ;
39241 PyObject * obj2 = 0 ;
39242 PyObject * obj3 = 0 ;
39243 char * kwnames[] = {
39244 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39245 };
39246
39247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39248 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39249 if (!SWIG_IsOK(res1)) {
39250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39251 }
39252 arg1 = reinterpret_cast< wxMenu * >(argp1);
39253 ecode2 = SWIG_AsVal_int(obj1, &val2);
39254 if (!SWIG_IsOK(ecode2)) {
39255 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
39256 }
39257 arg2 = static_cast< int >(val2);
39258 {
39259 arg3 = wxString_in_helper(obj2);
39260 if (arg3 == NULL) SWIG_fail;
39261 temp3 = true;
39262 }
39263 if (obj3) {
39264 {
39265 arg4 = wxString_in_helper(obj3);
39266 if (arg4 == NULL) SWIG_fail;
39267 temp4 = true;
39268 }
39269 }
39270 {
39271 PyThreadState* __tstate = wxPyBeginAllowThreads();
39272 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39273 wxPyEndAllowThreads(__tstate);
39274 if (PyErr_Occurred()) SWIG_fail;
39275 }
39276 {
39277 resultobj = wxPyMake_wxObject(result, (bool)0);
39278 }
39279 {
39280 if (temp3)
39281 delete arg3;
39282 }
39283 {
39284 if (temp4)
39285 delete arg4;
39286 }
39287 return resultobj;
39288 fail:
39289 {
39290 if (temp3)
39291 delete arg3;
39292 }
39293 {
39294 if (temp4)
39295 delete arg4;
39296 }
39297 return NULL;
39298 }
39299
39300
39301 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39302 PyObject *resultobj = 0;
39303 wxMenu *arg1 = (wxMenu *) 0 ;
39304 int arg2 ;
39305 wxString *arg3 = 0 ;
39306 wxString const &arg4_defvalue = wxPyEmptyString ;
39307 wxString *arg4 = (wxString *) &arg4_defvalue ;
39308 wxMenuItem *result = 0 ;
39309 void *argp1 = 0 ;
39310 int res1 = 0 ;
39311 int val2 ;
39312 int ecode2 = 0 ;
39313 bool temp3 = false ;
39314 bool temp4 = false ;
39315 PyObject * obj0 = 0 ;
39316 PyObject * obj1 = 0 ;
39317 PyObject * obj2 = 0 ;
39318 PyObject * obj3 = 0 ;
39319 char * kwnames[] = {
39320 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39321 };
39322
39323 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39324 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39325 if (!SWIG_IsOK(res1)) {
39326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39327 }
39328 arg1 = reinterpret_cast< wxMenu * >(argp1);
39329 ecode2 = SWIG_AsVal_int(obj1, &val2);
39330 if (!SWIG_IsOK(ecode2)) {
39331 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
39332 }
39333 arg2 = static_cast< int >(val2);
39334 {
39335 arg3 = wxString_in_helper(obj2);
39336 if (arg3 == NULL) SWIG_fail;
39337 temp3 = true;
39338 }
39339 if (obj3) {
39340 {
39341 arg4 = wxString_in_helper(obj3);
39342 if (arg4 == NULL) SWIG_fail;
39343 temp4 = true;
39344 }
39345 }
39346 {
39347 PyThreadState* __tstate = wxPyBeginAllowThreads();
39348 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39349 wxPyEndAllowThreads(__tstate);
39350 if (PyErr_Occurred()) SWIG_fail;
39351 }
39352 {
39353 resultobj = wxPyMake_wxObject(result, (bool)0);
39354 }
39355 {
39356 if (temp3)
39357 delete arg3;
39358 }
39359 {
39360 if (temp4)
39361 delete arg4;
39362 }
39363 return resultobj;
39364 fail:
39365 {
39366 if (temp3)
39367 delete arg3;
39368 }
39369 {
39370 if (temp4)
39371 delete arg4;
39372 }
39373 return NULL;
39374 }
39375
39376
39377 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39378 PyObject *resultobj = 0;
39379 wxMenu *arg1 = (wxMenu *) 0 ;
39380 int arg2 ;
39381 wxString *arg3 = 0 ;
39382 wxMenu *arg4 = (wxMenu *) 0 ;
39383 wxString const &arg5_defvalue = wxPyEmptyString ;
39384 wxString *arg5 = (wxString *) &arg5_defvalue ;
39385 wxMenuItem *result = 0 ;
39386 void *argp1 = 0 ;
39387 int res1 = 0 ;
39388 int val2 ;
39389 int ecode2 = 0 ;
39390 bool temp3 = false ;
39391 void *argp4 = 0 ;
39392 int res4 = 0 ;
39393 bool temp5 = false ;
39394 PyObject * obj0 = 0 ;
39395 PyObject * obj1 = 0 ;
39396 PyObject * obj2 = 0 ;
39397 PyObject * obj3 = 0 ;
39398 PyObject * obj4 = 0 ;
39399 char * kwnames[] = {
39400 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39401 };
39402
39403 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39404 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39405 if (!SWIG_IsOK(res1)) {
39406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39407 }
39408 arg1 = reinterpret_cast< wxMenu * >(argp1);
39409 ecode2 = SWIG_AsVal_int(obj1, &val2);
39410 if (!SWIG_IsOK(ecode2)) {
39411 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
39412 }
39413 arg2 = static_cast< int >(val2);
39414 {
39415 arg3 = wxString_in_helper(obj2);
39416 if (arg3 == NULL) SWIG_fail;
39417 temp3 = true;
39418 }
39419 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
39420 if (!SWIG_IsOK(res4)) {
39421 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
39422 }
39423 arg4 = reinterpret_cast< wxMenu * >(argp4);
39424 if (obj4) {
39425 {
39426 arg5 = wxString_in_helper(obj4);
39427 if (arg5 == NULL) SWIG_fail;
39428 temp5 = true;
39429 }
39430 }
39431 {
39432 PyThreadState* __tstate = wxPyBeginAllowThreads();
39433 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
39434 wxPyEndAllowThreads(__tstate);
39435 if (PyErr_Occurred()) SWIG_fail;
39436 }
39437 {
39438 resultobj = wxPyMake_wxObject(result, (bool)0);
39439 }
39440 {
39441 if (temp3)
39442 delete arg3;
39443 }
39444 {
39445 if (temp5)
39446 delete arg5;
39447 }
39448 return resultobj;
39449 fail:
39450 {
39451 if (temp3)
39452 delete arg3;
39453 }
39454 {
39455 if (temp5)
39456 delete arg5;
39457 }
39458 return NULL;
39459 }
39460
39461
39462 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39463 PyObject *resultobj = 0;
39464 wxMenu *arg1 = (wxMenu *) 0 ;
39465 wxMenu *arg2 = (wxMenu *) 0 ;
39466 wxString *arg3 = 0 ;
39467 wxString const &arg4_defvalue = wxPyEmptyString ;
39468 wxString *arg4 = (wxString *) &arg4_defvalue ;
39469 wxMenuItem *result = 0 ;
39470 void *argp1 = 0 ;
39471 int res1 = 0 ;
39472 void *argp2 = 0 ;
39473 int res2 = 0 ;
39474 bool temp3 = false ;
39475 bool temp4 = false ;
39476 PyObject * obj0 = 0 ;
39477 PyObject * obj1 = 0 ;
39478 PyObject * obj2 = 0 ;
39479 PyObject * obj3 = 0 ;
39480 char * kwnames[] = {
39481 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
39482 };
39483
39484 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39485 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39486 if (!SWIG_IsOK(res1)) {
39487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39488 }
39489 arg1 = reinterpret_cast< wxMenu * >(argp1);
39490 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
39491 if (!SWIG_IsOK(res2)) {
39492 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
39493 }
39494 arg2 = reinterpret_cast< wxMenu * >(argp2);
39495 {
39496 arg3 = wxString_in_helper(obj2);
39497 if (arg3 == NULL) SWIG_fail;
39498 temp3 = true;
39499 }
39500 if (obj3) {
39501 {
39502 arg4 = wxString_in_helper(obj3);
39503 if (arg4 == NULL) SWIG_fail;
39504 temp4 = true;
39505 }
39506 }
39507 {
39508 PyThreadState* __tstate = wxPyBeginAllowThreads();
39509 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39510 wxPyEndAllowThreads(__tstate);
39511 if (PyErr_Occurred()) SWIG_fail;
39512 }
39513 {
39514 resultobj = wxPyMake_wxObject(result, (bool)0);
39515 }
39516 {
39517 if (temp3)
39518 delete arg3;
39519 }
39520 {
39521 if (temp4)
39522 delete arg4;
39523 }
39524 return resultobj;
39525 fail:
39526 {
39527 if (temp3)
39528 delete arg3;
39529 }
39530 {
39531 if (temp4)
39532 delete arg4;
39533 }
39534 return NULL;
39535 }
39536
39537
39538 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39539 PyObject *resultobj = 0;
39540 wxMenu *arg1 = (wxMenu *) 0 ;
39541 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39542 wxMenuItem *result = 0 ;
39543 void *argp1 = 0 ;
39544 int res1 = 0 ;
39545 int res2 = 0 ;
39546 PyObject * obj0 = 0 ;
39547 PyObject * obj1 = 0 ;
39548 char * kwnames[] = {
39549 (char *) "self",(char *) "item", NULL
39550 };
39551
39552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
39553 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39554 if (!SWIG_IsOK(res1)) {
39555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39556 }
39557 arg1 = reinterpret_cast< wxMenu * >(argp1);
39558 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
39559 if (!SWIG_IsOK(res2)) {
39560 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39561 }
39562 {
39563 PyThreadState* __tstate = wxPyBeginAllowThreads();
39564 result = (wxMenuItem *)(arg1)->Append(arg2);
39565 wxPyEndAllowThreads(__tstate);
39566 if (PyErr_Occurred()) SWIG_fail;
39567 }
39568 {
39569 resultobj = wxPyMake_wxObject(result, (bool)0);
39570 }
39571 return resultobj;
39572 fail:
39573 return NULL;
39574 }
39575
39576
39577 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39578 PyObject *resultobj = 0;
39579 wxMenu *arg1 = (wxMenu *) 0 ;
39580 size_t arg2 ;
39581 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
39582 wxMenuItem *result = 0 ;
39583 void *argp1 = 0 ;
39584 int res1 = 0 ;
39585 size_t val2 ;
39586 int ecode2 = 0 ;
39587 int res3 = 0 ;
39588 PyObject * obj0 = 0 ;
39589 PyObject * obj1 = 0 ;
39590 PyObject * obj2 = 0 ;
39591 char * kwnames[] = {
39592 (char *) "self",(char *) "pos",(char *) "item", NULL
39593 };
39594
39595 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39596 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39597 if (!SWIG_IsOK(res1)) {
39598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39599 }
39600 arg1 = reinterpret_cast< wxMenu * >(argp1);
39601 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39602 if (!SWIG_IsOK(ecode2)) {
39603 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
39604 }
39605 arg2 = static_cast< size_t >(val2);
39606 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
39607 if (!SWIG_IsOK(res3)) {
39608 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
39609 }
39610 {
39611 PyThreadState* __tstate = wxPyBeginAllowThreads();
39612 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
39613 wxPyEndAllowThreads(__tstate);
39614 if (PyErr_Occurred()) SWIG_fail;
39615 }
39616 {
39617 resultobj = wxPyMake_wxObject(result, (bool)0);
39618 }
39619 return resultobj;
39620 fail:
39621 return NULL;
39622 }
39623
39624
39625 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39626 PyObject *resultobj = 0;
39627 wxMenu *arg1 = (wxMenu *) 0 ;
39628 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39629 wxMenuItem *result = 0 ;
39630 void *argp1 = 0 ;
39631 int res1 = 0 ;
39632 int res2 = 0 ;
39633 PyObject * obj0 = 0 ;
39634 PyObject * obj1 = 0 ;
39635 char * kwnames[] = {
39636 (char *) "self",(char *) "item", NULL
39637 };
39638
39639 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
39640 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39641 if (!SWIG_IsOK(res1)) {
39642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39643 }
39644 arg1 = reinterpret_cast< wxMenu * >(argp1);
39645 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
39646 if (!SWIG_IsOK(res2)) {
39647 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39648 }
39649 {
39650 PyThreadState* __tstate = wxPyBeginAllowThreads();
39651 result = (wxMenuItem *)(arg1)->Prepend(arg2);
39652 wxPyEndAllowThreads(__tstate);
39653 if (PyErr_Occurred()) SWIG_fail;
39654 }
39655 {
39656 resultobj = wxPyMake_wxObject(result, (bool)0);
39657 }
39658 return resultobj;
39659 fail:
39660 return NULL;
39661 }
39662
39663
39664 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39665 PyObject *resultobj = 0;
39666 wxMenu *arg1 = (wxMenu *) 0 ;
39667 void *argp1 = 0 ;
39668 int res1 = 0 ;
39669 PyObject *swig_obj[1] ;
39670
39671 if (!args) SWIG_fail;
39672 swig_obj[0] = args;
39673 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39674 if (!SWIG_IsOK(res1)) {
39675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
39676 }
39677 arg1 = reinterpret_cast< wxMenu * >(argp1);
39678 {
39679 PyThreadState* __tstate = wxPyBeginAllowThreads();
39680 (arg1)->Break();
39681 wxPyEndAllowThreads(__tstate);
39682 if (PyErr_Occurred()) SWIG_fail;
39683 }
39684 resultobj = SWIG_Py_Void();
39685 return resultobj;
39686 fail:
39687 return NULL;
39688 }
39689
39690
39691 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39692 PyObject *resultobj = 0;
39693 wxMenu *arg1 = (wxMenu *) 0 ;
39694 size_t arg2 ;
39695 int arg3 ;
39696 wxString const &arg4_defvalue = wxPyEmptyString ;
39697 wxString *arg4 = (wxString *) &arg4_defvalue ;
39698 wxString const &arg5_defvalue = wxPyEmptyString ;
39699 wxString *arg5 = (wxString *) &arg5_defvalue ;
39700 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
39701 wxMenuItem *result = 0 ;
39702 void *argp1 = 0 ;
39703 int res1 = 0 ;
39704 size_t val2 ;
39705 int ecode2 = 0 ;
39706 int val3 ;
39707 int ecode3 = 0 ;
39708 bool temp4 = false ;
39709 bool temp5 = false ;
39710 int val6 ;
39711 int ecode6 = 0 ;
39712 PyObject * obj0 = 0 ;
39713 PyObject * obj1 = 0 ;
39714 PyObject * obj2 = 0 ;
39715 PyObject * obj3 = 0 ;
39716 PyObject * obj4 = 0 ;
39717 PyObject * obj5 = 0 ;
39718 char * kwnames[] = {
39719 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
39720 };
39721
39722 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
39723 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39724 if (!SWIG_IsOK(res1)) {
39725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
39726 }
39727 arg1 = reinterpret_cast< wxMenu * >(argp1);
39728 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39729 if (!SWIG_IsOK(ecode2)) {
39730 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
39731 }
39732 arg2 = static_cast< size_t >(val2);
39733 ecode3 = SWIG_AsVal_int(obj2, &val3);
39734 if (!SWIG_IsOK(ecode3)) {
39735 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
39736 }
39737 arg3 = static_cast< int >(val3);
39738 if (obj3) {
39739 {
39740 arg4 = wxString_in_helper(obj3);
39741 if (arg4 == NULL) SWIG_fail;
39742 temp4 = true;
39743 }
39744 }
39745 if (obj4) {
39746 {
39747 arg5 = wxString_in_helper(obj4);
39748 if (arg5 == NULL) SWIG_fail;
39749 temp5 = true;
39750 }
39751 }
39752 if (obj5) {
39753 ecode6 = SWIG_AsVal_int(obj5, &val6);
39754 if (!SWIG_IsOK(ecode6)) {
39755 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
39756 }
39757 arg6 = static_cast< wxItemKind >(val6);
39758 }
39759 {
39760 PyThreadState* __tstate = wxPyBeginAllowThreads();
39761 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
39762 wxPyEndAllowThreads(__tstate);
39763 if (PyErr_Occurred()) SWIG_fail;
39764 }
39765 {
39766 resultobj = wxPyMake_wxObject(result, (bool)0);
39767 }
39768 {
39769 if (temp4)
39770 delete arg4;
39771 }
39772 {
39773 if (temp5)
39774 delete arg5;
39775 }
39776 return resultobj;
39777 fail:
39778 {
39779 if (temp4)
39780 delete arg4;
39781 }
39782 {
39783 if (temp5)
39784 delete arg5;
39785 }
39786 return NULL;
39787 }
39788
39789
39790 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39791 PyObject *resultobj = 0;
39792 wxMenu *arg1 = (wxMenu *) 0 ;
39793 size_t arg2 ;
39794 wxMenuItem *result = 0 ;
39795 void *argp1 = 0 ;
39796 int res1 = 0 ;
39797 size_t val2 ;
39798 int ecode2 = 0 ;
39799 PyObject * obj0 = 0 ;
39800 PyObject * obj1 = 0 ;
39801 char * kwnames[] = {
39802 (char *) "self",(char *) "pos", NULL
39803 };
39804
39805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
39806 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39807 if (!SWIG_IsOK(res1)) {
39808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39809 }
39810 arg1 = reinterpret_cast< wxMenu * >(argp1);
39811 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39812 if (!SWIG_IsOK(ecode2)) {
39813 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
39814 }
39815 arg2 = static_cast< size_t >(val2);
39816 {
39817 PyThreadState* __tstate = wxPyBeginAllowThreads();
39818 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
39819 wxPyEndAllowThreads(__tstate);
39820 if (PyErr_Occurred()) SWIG_fail;
39821 }
39822 {
39823 resultobj = wxPyMake_wxObject(result, (bool)0);
39824 }
39825 return resultobj;
39826 fail:
39827 return NULL;
39828 }
39829
39830
39831 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39832 PyObject *resultobj = 0;
39833 wxMenu *arg1 = (wxMenu *) 0 ;
39834 size_t arg2 ;
39835 int arg3 ;
39836 wxString *arg4 = 0 ;
39837 wxString const &arg5_defvalue = wxPyEmptyString ;
39838 wxString *arg5 = (wxString *) &arg5_defvalue ;
39839 wxMenuItem *result = 0 ;
39840 void *argp1 = 0 ;
39841 int res1 = 0 ;
39842 size_t val2 ;
39843 int ecode2 = 0 ;
39844 int val3 ;
39845 int ecode3 = 0 ;
39846 bool temp4 = false ;
39847 bool temp5 = false ;
39848 PyObject * obj0 = 0 ;
39849 PyObject * obj1 = 0 ;
39850 PyObject * obj2 = 0 ;
39851 PyObject * obj3 = 0 ;
39852 PyObject * obj4 = 0 ;
39853 char * kwnames[] = {
39854 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
39855 };
39856
39857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39859 if (!SWIG_IsOK(res1)) {
39860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39861 }
39862 arg1 = reinterpret_cast< wxMenu * >(argp1);
39863 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39864 if (!SWIG_IsOK(ecode2)) {
39865 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
39866 }
39867 arg2 = static_cast< size_t >(val2);
39868 ecode3 = SWIG_AsVal_int(obj2, &val3);
39869 if (!SWIG_IsOK(ecode3)) {
39870 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
39871 }
39872 arg3 = static_cast< int >(val3);
39873 {
39874 arg4 = wxString_in_helper(obj3);
39875 if (arg4 == NULL) SWIG_fail;
39876 temp4 = true;
39877 }
39878 if (obj4) {
39879 {
39880 arg5 = wxString_in_helper(obj4);
39881 if (arg5 == NULL) SWIG_fail;
39882 temp5 = true;
39883 }
39884 }
39885 {
39886 PyThreadState* __tstate = wxPyBeginAllowThreads();
39887 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
39888 wxPyEndAllowThreads(__tstate);
39889 if (PyErr_Occurred()) SWIG_fail;
39890 }
39891 {
39892 resultobj = wxPyMake_wxObject(result, (bool)0);
39893 }
39894 {
39895 if (temp4)
39896 delete arg4;
39897 }
39898 {
39899 if (temp5)
39900 delete arg5;
39901 }
39902 return resultobj;
39903 fail:
39904 {
39905 if (temp4)
39906 delete arg4;
39907 }
39908 {
39909 if (temp5)
39910 delete arg5;
39911 }
39912 return NULL;
39913 }
39914
39915
39916 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39917 PyObject *resultobj = 0;
39918 wxMenu *arg1 = (wxMenu *) 0 ;
39919 size_t arg2 ;
39920 int arg3 ;
39921 wxString *arg4 = 0 ;
39922 wxString const &arg5_defvalue = wxPyEmptyString ;
39923 wxString *arg5 = (wxString *) &arg5_defvalue ;
39924 wxMenuItem *result = 0 ;
39925 void *argp1 = 0 ;
39926 int res1 = 0 ;
39927 size_t val2 ;
39928 int ecode2 = 0 ;
39929 int val3 ;
39930 int ecode3 = 0 ;
39931 bool temp4 = false ;
39932 bool temp5 = false ;
39933 PyObject * obj0 = 0 ;
39934 PyObject * obj1 = 0 ;
39935 PyObject * obj2 = 0 ;
39936 PyObject * obj3 = 0 ;
39937 PyObject * obj4 = 0 ;
39938 char * kwnames[] = {
39939 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
39940 };
39941
39942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39944 if (!SWIG_IsOK(res1)) {
39945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39946 }
39947 arg1 = reinterpret_cast< wxMenu * >(argp1);
39948 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39949 if (!SWIG_IsOK(ecode2)) {
39950 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
39951 }
39952 arg2 = static_cast< size_t >(val2);
39953 ecode3 = SWIG_AsVal_int(obj2, &val3);
39954 if (!SWIG_IsOK(ecode3)) {
39955 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
39956 }
39957 arg3 = static_cast< int >(val3);
39958 {
39959 arg4 = wxString_in_helper(obj3);
39960 if (arg4 == NULL) SWIG_fail;
39961 temp4 = true;
39962 }
39963 if (obj4) {
39964 {
39965 arg5 = wxString_in_helper(obj4);
39966 if (arg5 == NULL) SWIG_fail;
39967 temp5 = true;
39968 }
39969 }
39970 {
39971 PyThreadState* __tstate = wxPyBeginAllowThreads();
39972 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
39973 wxPyEndAllowThreads(__tstate);
39974 if (PyErr_Occurred()) SWIG_fail;
39975 }
39976 {
39977 resultobj = wxPyMake_wxObject(result, (bool)0);
39978 }
39979 {
39980 if (temp4)
39981 delete arg4;
39982 }
39983 {
39984 if (temp5)
39985 delete arg5;
39986 }
39987 return resultobj;
39988 fail:
39989 {
39990 if (temp4)
39991 delete arg4;
39992 }
39993 {
39994 if (temp5)
39995 delete arg5;
39996 }
39997 return NULL;
39998 }
39999
40000
40001 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40002 PyObject *resultobj = 0;
40003 wxMenu *arg1 = (wxMenu *) 0 ;
40004 size_t arg2 ;
40005 int arg3 ;
40006 wxString *arg4 = 0 ;
40007 wxMenu *arg5 = (wxMenu *) 0 ;
40008 wxString const &arg6_defvalue = wxPyEmptyString ;
40009 wxString *arg6 = (wxString *) &arg6_defvalue ;
40010 wxMenuItem *result = 0 ;
40011 void *argp1 = 0 ;
40012 int res1 = 0 ;
40013 size_t val2 ;
40014 int ecode2 = 0 ;
40015 int val3 ;
40016 int ecode3 = 0 ;
40017 bool temp4 = false ;
40018 void *argp5 = 0 ;
40019 int res5 = 0 ;
40020 bool temp6 = false ;
40021 PyObject * obj0 = 0 ;
40022 PyObject * obj1 = 0 ;
40023 PyObject * obj2 = 0 ;
40024 PyObject * obj3 = 0 ;
40025 PyObject * obj4 = 0 ;
40026 PyObject * obj5 = 0 ;
40027 char * kwnames[] = {
40028 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
40029 };
40030
40031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
40032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40033 if (!SWIG_IsOK(res1)) {
40034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
40035 }
40036 arg1 = reinterpret_cast< wxMenu * >(argp1);
40037 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40038 if (!SWIG_IsOK(ecode2)) {
40039 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
40040 }
40041 arg2 = static_cast< size_t >(val2);
40042 ecode3 = SWIG_AsVal_int(obj2, &val3);
40043 if (!SWIG_IsOK(ecode3)) {
40044 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
40045 }
40046 arg3 = static_cast< int >(val3);
40047 {
40048 arg4 = wxString_in_helper(obj3);
40049 if (arg4 == NULL) SWIG_fail;
40050 temp4 = true;
40051 }
40052 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
40053 if (!SWIG_IsOK(res5)) {
40054 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
40055 }
40056 arg5 = reinterpret_cast< wxMenu * >(argp5);
40057 if (obj5) {
40058 {
40059 arg6 = wxString_in_helper(obj5);
40060 if (arg6 == NULL) SWIG_fail;
40061 temp6 = true;
40062 }
40063 }
40064 {
40065 PyThreadState* __tstate = wxPyBeginAllowThreads();
40066 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
40067 wxPyEndAllowThreads(__tstate);
40068 if (PyErr_Occurred()) SWIG_fail;
40069 }
40070 {
40071 resultobj = wxPyMake_wxObject(result, (bool)0);
40072 }
40073 {
40074 if (temp4)
40075 delete arg4;
40076 }
40077 {
40078 if (temp6)
40079 delete arg6;
40080 }
40081 return resultobj;
40082 fail:
40083 {
40084 if (temp4)
40085 delete arg4;
40086 }
40087 {
40088 if (temp6)
40089 delete arg6;
40090 }
40091 return NULL;
40092 }
40093
40094
40095 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40096 PyObject *resultobj = 0;
40097 wxMenu *arg1 = (wxMenu *) 0 ;
40098 int arg2 ;
40099 wxString const &arg3_defvalue = wxPyEmptyString ;
40100 wxString *arg3 = (wxString *) &arg3_defvalue ;
40101 wxString const &arg4_defvalue = wxPyEmptyString ;
40102 wxString *arg4 = (wxString *) &arg4_defvalue ;
40103 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
40104 wxMenuItem *result = 0 ;
40105 void *argp1 = 0 ;
40106 int res1 = 0 ;
40107 int val2 ;
40108 int ecode2 = 0 ;
40109 bool temp3 = false ;
40110 bool temp4 = false ;
40111 int val5 ;
40112 int ecode5 = 0 ;
40113 PyObject * obj0 = 0 ;
40114 PyObject * obj1 = 0 ;
40115 PyObject * obj2 = 0 ;
40116 PyObject * obj3 = 0 ;
40117 PyObject * obj4 = 0 ;
40118 char * kwnames[] = {
40119 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
40120 };
40121
40122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
40123 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40124 if (!SWIG_IsOK(res1)) {
40125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
40126 }
40127 arg1 = reinterpret_cast< wxMenu * >(argp1);
40128 ecode2 = SWIG_AsVal_int(obj1, &val2);
40129 if (!SWIG_IsOK(ecode2)) {
40130 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
40131 }
40132 arg2 = static_cast< int >(val2);
40133 if (obj2) {
40134 {
40135 arg3 = wxString_in_helper(obj2);
40136 if (arg3 == NULL) SWIG_fail;
40137 temp3 = true;
40138 }
40139 }
40140 if (obj3) {
40141 {
40142 arg4 = wxString_in_helper(obj3);
40143 if (arg4 == NULL) SWIG_fail;
40144 temp4 = true;
40145 }
40146 }
40147 if (obj4) {
40148 ecode5 = SWIG_AsVal_int(obj4, &val5);
40149 if (!SWIG_IsOK(ecode5)) {
40150 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
40151 }
40152 arg5 = static_cast< wxItemKind >(val5);
40153 }
40154 {
40155 PyThreadState* __tstate = wxPyBeginAllowThreads();
40156 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
40157 wxPyEndAllowThreads(__tstate);
40158 if (PyErr_Occurred()) SWIG_fail;
40159 }
40160 {
40161 resultobj = wxPyMake_wxObject(result, (bool)0);
40162 }
40163 {
40164 if (temp3)
40165 delete arg3;
40166 }
40167 {
40168 if (temp4)
40169 delete arg4;
40170 }
40171 return resultobj;
40172 fail:
40173 {
40174 if (temp3)
40175 delete arg3;
40176 }
40177 {
40178 if (temp4)
40179 delete arg4;
40180 }
40181 return NULL;
40182 }
40183
40184
40185 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40186 PyObject *resultobj = 0;
40187 wxMenu *arg1 = (wxMenu *) 0 ;
40188 wxMenuItem *result = 0 ;
40189 void *argp1 = 0 ;
40190 int res1 = 0 ;
40191 PyObject *swig_obj[1] ;
40192
40193 if (!args) SWIG_fail;
40194 swig_obj[0] = args;
40195 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40196 if (!SWIG_IsOK(res1)) {
40197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
40198 }
40199 arg1 = reinterpret_cast< wxMenu * >(argp1);
40200 {
40201 PyThreadState* __tstate = wxPyBeginAllowThreads();
40202 result = (wxMenuItem *)(arg1)->PrependSeparator();
40203 wxPyEndAllowThreads(__tstate);
40204 if (PyErr_Occurred()) SWIG_fail;
40205 }
40206 {
40207 resultobj = wxPyMake_wxObject(result, (bool)0);
40208 }
40209 return resultobj;
40210 fail:
40211 return NULL;
40212 }
40213
40214
40215 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40216 PyObject *resultobj = 0;
40217 wxMenu *arg1 = (wxMenu *) 0 ;
40218 int arg2 ;
40219 wxString *arg3 = 0 ;
40220 wxString const &arg4_defvalue = wxPyEmptyString ;
40221 wxString *arg4 = (wxString *) &arg4_defvalue ;
40222 wxMenuItem *result = 0 ;
40223 void *argp1 = 0 ;
40224 int res1 = 0 ;
40225 int val2 ;
40226 int ecode2 = 0 ;
40227 bool temp3 = false ;
40228 bool temp4 = false ;
40229 PyObject * obj0 = 0 ;
40230 PyObject * obj1 = 0 ;
40231 PyObject * obj2 = 0 ;
40232 PyObject * obj3 = 0 ;
40233 char * kwnames[] = {
40234 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
40235 };
40236
40237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40238 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40239 if (!SWIG_IsOK(res1)) {
40240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40241 }
40242 arg1 = reinterpret_cast< wxMenu * >(argp1);
40243 ecode2 = SWIG_AsVal_int(obj1, &val2);
40244 if (!SWIG_IsOK(ecode2)) {
40245 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
40246 }
40247 arg2 = static_cast< int >(val2);
40248 {
40249 arg3 = wxString_in_helper(obj2);
40250 if (arg3 == NULL) SWIG_fail;
40251 temp3 = true;
40252 }
40253 if (obj3) {
40254 {
40255 arg4 = wxString_in_helper(obj3);
40256 if (arg4 == NULL) SWIG_fail;
40257 temp4 = true;
40258 }
40259 }
40260 {
40261 PyThreadState* __tstate = wxPyBeginAllowThreads();
40262 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
40263 wxPyEndAllowThreads(__tstate);
40264 if (PyErr_Occurred()) SWIG_fail;
40265 }
40266 {
40267 resultobj = wxPyMake_wxObject(result, (bool)0);
40268 }
40269 {
40270 if (temp3)
40271 delete arg3;
40272 }
40273 {
40274 if (temp4)
40275 delete arg4;
40276 }
40277 return resultobj;
40278 fail:
40279 {
40280 if (temp3)
40281 delete arg3;
40282 }
40283 {
40284 if (temp4)
40285 delete arg4;
40286 }
40287 return NULL;
40288 }
40289
40290
40291 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40292 PyObject *resultobj = 0;
40293 wxMenu *arg1 = (wxMenu *) 0 ;
40294 int arg2 ;
40295 wxString *arg3 = 0 ;
40296 wxString const &arg4_defvalue = wxPyEmptyString ;
40297 wxString *arg4 = (wxString *) &arg4_defvalue ;
40298 wxMenuItem *result = 0 ;
40299 void *argp1 = 0 ;
40300 int res1 = 0 ;
40301 int val2 ;
40302 int ecode2 = 0 ;
40303 bool temp3 = false ;
40304 bool temp4 = false ;
40305 PyObject * obj0 = 0 ;
40306 PyObject * obj1 = 0 ;
40307 PyObject * obj2 = 0 ;
40308 PyObject * obj3 = 0 ;
40309 char * kwnames[] = {
40310 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
40311 };
40312
40313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40314 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40315 if (!SWIG_IsOK(res1)) {
40316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40317 }
40318 arg1 = reinterpret_cast< wxMenu * >(argp1);
40319 ecode2 = SWIG_AsVal_int(obj1, &val2);
40320 if (!SWIG_IsOK(ecode2)) {
40321 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
40322 }
40323 arg2 = static_cast< int >(val2);
40324 {
40325 arg3 = wxString_in_helper(obj2);
40326 if (arg3 == NULL) SWIG_fail;
40327 temp3 = true;
40328 }
40329 if (obj3) {
40330 {
40331 arg4 = wxString_in_helper(obj3);
40332 if (arg4 == NULL) SWIG_fail;
40333 temp4 = true;
40334 }
40335 }
40336 {
40337 PyThreadState* __tstate = wxPyBeginAllowThreads();
40338 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
40339 wxPyEndAllowThreads(__tstate);
40340 if (PyErr_Occurred()) SWIG_fail;
40341 }
40342 {
40343 resultobj = wxPyMake_wxObject(result, (bool)0);
40344 }
40345 {
40346 if (temp3)
40347 delete arg3;
40348 }
40349 {
40350 if (temp4)
40351 delete arg4;
40352 }
40353 return resultobj;
40354 fail:
40355 {
40356 if (temp3)
40357 delete arg3;
40358 }
40359 {
40360 if (temp4)
40361 delete arg4;
40362 }
40363 return NULL;
40364 }
40365
40366
40367 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40368 PyObject *resultobj = 0;
40369 wxMenu *arg1 = (wxMenu *) 0 ;
40370 int arg2 ;
40371 wxString *arg3 = 0 ;
40372 wxMenu *arg4 = (wxMenu *) 0 ;
40373 wxString const &arg5_defvalue = wxPyEmptyString ;
40374 wxString *arg5 = (wxString *) &arg5_defvalue ;
40375 wxMenuItem *result = 0 ;
40376 void *argp1 = 0 ;
40377 int res1 = 0 ;
40378 int val2 ;
40379 int ecode2 = 0 ;
40380 bool temp3 = false ;
40381 void *argp4 = 0 ;
40382 int res4 = 0 ;
40383 bool temp5 = false ;
40384 PyObject * obj0 = 0 ;
40385 PyObject * obj1 = 0 ;
40386 PyObject * obj2 = 0 ;
40387 PyObject * obj3 = 0 ;
40388 PyObject * obj4 = 0 ;
40389 char * kwnames[] = {
40390 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
40391 };
40392
40393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
40394 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40395 if (!SWIG_IsOK(res1)) {
40396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
40397 }
40398 arg1 = reinterpret_cast< wxMenu * >(argp1);
40399 ecode2 = SWIG_AsVal_int(obj1, &val2);
40400 if (!SWIG_IsOK(ecode2)) {
40401 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
40402 }
40403 arg2 = static_cast< int >(val2);
40404 {
40405 arg3 = wxString_in_helper(obj2);
40406 if (arg3 == NULL) SWIG_fail;
40407 temp3 = true;
40408 }
40409 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
40410 if (!SWIG_IsOK(res4)) {
40411 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
40412 }
40413 arg4 = reinterpret_cast< wxMenu * >(argp4);
40414 if (obj4) {
40415 {
40416 arg5 = wxString_in_helper(obj4);
40417 if (arg5 == NULL) SWIG_fail;
40418 temp5 = true;
40419 }
40420 }
40421 {
40422 PyThreadState* __tstate = wxPyBeginAllowThreads();
40423 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
40424 wxPyEndAllowThreads(__tstate);
40425 if (PyErr_Occurred()) SWIG_fail;
40426 }
40427 {
40428 resultobj = wxPyMake_wxObject(result, (bool)0);
40429 }
40430 {
40431 if (temp3)
40432 delete arg3;
40433 }
40434 {
40435 if (temp5)
40436 delete arg5;
40437 }
40438 return resultobj;
40439 fail:
40440 {
40441 if (temp3)
40442 delete arg3;
40443 }
40444 {
40445 if (temp5)
40446 delete arg5;
40447 }
40448 return NULL;
40449 }
40450
40451
40452 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40453 PyObject *resultobj = 0;
40454 wxMenu *arg1 = (wxMenu *) 0 ;
40455 int arg2 ;
40456 wxMenuItem *result = 0 ;
40457 void *argp1 = 0 ;
40458 int res1 = 0 ;
40459 int val2 ;
40460 int ecode2 = 0 ;
40461 PyObject * obj0 = 0 ;
40462 PyObject * obj1 = 0 ;
40463 char * kwnames[] = {
40464 (char *) "self",(char *) "id", NULL
40465 };
40466
40467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
40468 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40469 if (!SWIG_IsOK(res1)) {
40470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
40471 }
40472 arg1 = reinterpret_cast< wxMenu * >(argp1);
40473 ecode2 = SWIG_AsVal_int(obj1, &val2);
40474 if (!SWIG_IsOK(ecode2)) {
40475 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
40476 }
40477 arg2 = static_cast< int >(val2);
40478 {
40479 PyThreadState* __tstate = wxPyBeginAllowThreads();
40480 result = (wxMenuItem *)(arg1)->Remove(arg2);
40481 wxPyEndAllowThreads(__tstate);
40482 if (PyErr_Occurred()) SWIG_fail;
40483 }
40484 {
40485 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
40486 }
40487 return resultobj;
40488 fail:
40489 return NULL;
40490 }
40491
40492
40493 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40494 PyObject *resultobj = 0;
40495 wxMenu *arg1 = (wxMenu *) 0 ;
40496 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
40497 wxMenuItem *result = 0 ;
40498 void *argp1 = 0 ;
40499 int res1 = 0 ;
40500 void *argp2 = 0 ;
40501 int res2 = 0 ;
40502 PyObject * obj0 = 0 ;
40503 PyObject * obj1 = 0 ;
40504 char * kwnames[] = {
40505 (char *) "self",(char *) "item", NULL
40506 };
40507
40508 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
40509 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40510 if (!SWIG_IsOK(res1)) {
40511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40512 }
40513 arg1 = reinterpret_cast< wxMenu * >(argp1);
40514 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
40515 if (!SWIG_IsOK(res2)) {
40516 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
40517 }
40518 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
40519 {
40520 PyThreadState* __tstate = wxPyBeginAllowThreads();
40521 result = (wxMenuItem *)(arg1)->Remove(arg2);
40522 wxPyEndAllowThreads(__tstate);
40523 if (PyErr_Occurred()) SWIG_fail;
40524 }
40525 {
40526 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
40527 }
40528 return resultobj;
40529 fail:
40530 return NULL;
40531 }
40532
40533
40534 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40535 PyObject *resultobj = 0;
40536 wxMenu *arg1 = (wxMenu *) 0 ;
40537 int arg2 ;
40538 bool result;
40539 void *argp1 = 0 ;
40540 int res1 = 0 ;
40541 int val2 ;
40542 int ecode2 = 0 ;
40543 PyObject * obj0 = 0 ;
40544 PyObject * obj1 = 0 ;
40545 char * kwnames[] = {
40546 (char *) "self",(char *) "id", NULL
40547 };
40548
40549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
40550 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40551 if (!SWIG_IsOK(res1)) {
40552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
40553 }
40554 arg1 = reinterpret_cast< wxMenu * >(argp1);
40555 ecode2 = SWIG_AsVal_int(obj1, &val2);
40556 if (!SWIG_IsOK(ecode2)) {
40557 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
40558 }
40559 arg2 = static_cast< int >(val2);
40560 {
40561 PyThreadState* __tstate = wxPyBeginAllowThreads();
40562 result = (bool)(arg1)->Delete(arg2);
40563 wxPyEndAllowThreads(__tstate);
40564 if (PyErr_Occurred()) SWIG_fail;
40565 }
40566 {
40567 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40568 }
40569 return resultobj;
40570 fail:
40571 return NULL;
40572 }
40573
40574
40575 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40576 PyObject *resultobj = 0;
40577 wxMenu *arg1 = (wxMenu *) 0 ;
40578 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
40579 bool result;
40580 void *argp1 = 0 ;
40581 int res1 = 0 ;
40582 void *argp2 = 0 ;
40583 int res2 = 0 ;
40584 PyObject * obj0 = 0 ;
40585 PyObject * obj1 = 0 ;
40586 char * kwnames[] = {
40587 (char *) "self",(char *) "item", NULL
40588 };
40589
40590 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
40591 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40592 if (!SWIG_IsOK(res1)) {
40593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40594 }
40595 arg1 = reinterpret_cast< wxMenu * >(argp1);
40596 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
40597 if (!SWIG_IsOK(res2)) {
40598 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
40599 }
40600 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
40601 {
40602 PyThreadState* __tstate = wxPyBeginAllowThreads();
40603 result = (bool)(arg1)->Delete(arg2);
40604 wxPyEndAllowThreads(__tstate);
40605 if (PyErr_Occurred()) SWIG_fail;
40606 }
40607 {
40608 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40609 }
40610 return resultobj;
40611 fail:
40612 return NULL;
40613 }
40614
40615
40616 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40617 PyObject *resultobj = 0;
40618 wxMenu *arg1 = (wxMenu *) 0 ;
40619 void *argp1 = 0 ;
40620 int res1 = 0 ;
40621 PyObject *swig_obj[1] ;
40622
40623 if (!args) SWIG_fail;
40624 swig_obj[0] = args;
40625 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40626 if (!SWIG_IsOK(res1)) {
40627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
40628 }
40629 arg1 = reinterpret_cast< wxMenu * >(argp1);
40630 {
40631 PyThreadState* __tstate = wxPyBeginAllowThreads();
40632 wxMenu_Destroy(arg1);
40633 wxPyEndAllowThreads(__tstate);
40634 if (PyErr_Occurred()) SWIG_fail;
40635 }
40636 resultobj = SWIG_Py_Void();
40637 return resultobj;
40638 fail:
40639 return NULL;
40640 }
40641
40642
40643 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40644 PyObject *resultobj = 0;
40645 wxMenu *arg1 = (wxMenu *) 0 ;
40646 int arg2 ;
40647 bool result;
40648 void *argp1 = 0 ;
40649 int res1 = 0 ;
40650 int val2 ;
40651 int ecode2 = 0 ;
40652 PyObject * obj0 = 0 ;
40653 PyObject * obj1 = 0 ;
40654 char * kwnames[] = {
40655 (char *) "self",(char *) "id", NULL
40656 };
40657
40658 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
40659 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40660 if (!SWIG_IsOK(res1)) {
40661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
40662 }
40663 arg1 = reinterpret_cast< wxMenu * >(argp1);
40664 ecode2 = SWIG_AsVal_int(obj1, &val2);
40665 if (!SWIG_IsOK(ecode2)) {
40666 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
40667 }
40668 arg2 = static_cast< int >(val2);
40669 {
40670 PyThreadState* __tstate = wxPyBeginAllowThreads();
40671 result = (bool)(arg1)->Destroy(arg2);
40672 wxPyEndAllowThreads(__tstate);
40673 if (PyErr_Occurred()) SWIG_fail;
40674 }
40675 {
40676 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40677 }
40678 return resultobj;
40679 fail:
40680 return NULL;
40681 }
40682
40683
40684 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40685 PyObject *resultobj = 0;
40686 wxMenu *arg1 = (wxMenu *) 0 ;
40687 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
40688 bool result;
40689 void *argp1 = 0 ;
40690 int res1 = 0 ;
40691 void *argp2 = 0 ;
40692 int res2 = 0 ;
40693 PyObject * obj0 = 0 ;
40694 PyObject * obj1 = 0 ;
40695 char * kwnames[] = {
40696 (char *) "self",(char *) "item", NULL
40697 };
40698
40699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
40700 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40701 if (!SWIG_IsOK(res1)) {
40702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40703 }
40704 arg1 = reinterpret_cast< wxMenu * >(argp1);
40705 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
40706 if (!SWIG_IsOK(res2)) {
40707 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
40708 }
40709 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
40710 {
40711 PyThreadState* __tstate = wxPyBeginAllowThreads();
40712 result = (bool)(arg1)->Destroy(arg2);
40713 wxPyEndAllowThreads(__tstate);
40714 if (PyErr_Occurred()) SWIG_fail;
40715 }
40716 {
40717 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40718 }
40719 return resultobj;
40720 fail:
40721 return NULL;
40722 }
40723
40724
40725 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40726 PyObject *resultobj = 0;
40727 wxMenu *arg1 = (wxMenu *) 0 ;
40728 size_t result;
40729 void *argp1 = 0 ;
40730 int res1 = 0 ;
40731 PyObject *swig_obj[1] ;
40732
40733 if (!args) SWIG_fail;
40734 swig_obj[0] = args;
40735 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40736 if (!SWIG_IsOK(res1)) {
40737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
40738 }
40739 arg1 = reinterpret_cast< wxMenu * >(argp1);
40740 {
40741 PyThreadState* __tstate = wxPyBeginAllowThreads();
40742 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
40743 wxPyEndAllowThreads(__tstate);
40744 if (PyErr_Occurred()) SWIG_fail;
40745 }
40746 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
40747 return resultobj;
40748 fail:
40749 return NULL;
40750 }
40751
40752
40753 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40754 PyObject *resultobj = 0;
40755 wxMenu *arg1 = (wxMenu *) 0 ;
40756 PyObject *result = 0 ;
40757 void *argp1 = 0 ;
40758 int res1 = 0 ;
40759 PyObject *swig_obj[1] ;
40760
40761 if (!args) SWIG_fail;
40762 swig_obj[0] = args;
40763 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40764 if (!SWIG_IsOK(res1)) {
40765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
40766 }
40767 arg1 = reinterpret_cast< wxMenu * >(argp1);
40768 {
40769 PyThreadState* __tstate = wxPyBeginAllowThreads();
40770 result = (PyObject *)wxMenu_GetMenuItems(arg1);
40771 wxPyEndAllowThreads(__tstate);
40772 if (PyErr_Occurred()) SWIG_fail;
40773 }
40774 resultobj = result;
40775 return resultobj;
40776 fail:
40777 return NULL;
40778 }
40779
40780
40781 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40782 PyObject *resultobj = 0;
40783 wxMenu *arg1 = (wxMenu *) 0 ;
40784 wxString *arg2 = 0 ;
40785 int result;
40786 void *argp1 = 0 ;
40787 int res1 = 0 ;
40788 bool temp2 = false ;
40789 PyObject * obj0 = 0 ;
40790 PyObject * obj1 = 0 ;
40791 char * kwnames[] = {
40792 (char *) "self",(char *) "item", NULL
40793 };
40794
40795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
40796 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40797 if (!SWIG_IsOK(res1)) {
40798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
40799 }
40800 arg1 = reinterpret_cast< wxMenu * >(argp1);
40801 {
40802 arg2 = wxString_in_helper(obj1);
40803 if (arg2 == NULL) SWIG_fail;
40804 temp2 = true;
40805 }
40806 {
40807 PyThreadState* __tstate = wxPyBeginAllowThreads();
40808 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
40809 wxPyEndAllowThreads(__tstate);
40810 if (PyErr_Occurred()) SWIG_fail;
40811 }
40812 resultobj = SWIG_From_int(static_cast< int >(result));
40813 {
40814 if (temp2)
40815 delete arg2;
40816 }
40817 return resultobj;
40818 fail:
40819 {
40820 if (temp2)
40821 delete arg2;
40822 }
40823 return NULL;
40824 }
40825
40826
40827 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40828 PyObject *resultobj = 0;
40829 wxMenu *arg1 = (wxMenu *) 0 ;
40830 int arg2 ;
40831 wxMenuItem *result = 0 ;
40832 void *argp1 = 0 ;
40833 int res1 = 0 ;
40834 int val2 ;
40835 int ecode2 = 0 ;
40836 PyObject * obj0 = 0 ;
40837 PyObject * obj1 = 0 ;
40838 char * kwnames[] = {
40839 (char *) "self",(char *) "id", NULL
40840 };
40841
40842 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
40843 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40844 if (!SWIG_IsOK(res1)) {
40845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
40846 }
40847 arg1 = reinterpret_cast< wxMenu * >(argp1);
40848 ecode2 = SWIG_AsVal_int(obj1, &val2);
40849 if (!SWIG_IsOK(ecode2)) {
40850 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
40851 }
40852 arg2 = static_cast< int >(val2);
40853 {
40854 PyThreadState* __tstate = wxPyBeginAllowThreads();
40855 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
40856 wxPyEndAllowThreads(__tstate);
40857 if (PyErr_Occurred()) SWIG_fail;
40858 }
40859 {
40860 resultobj = wxPyMake_wxObject(result, (bool)0);
40861 }
40862 return resultobj;
40863 fail:
40864 return NULL;
40865 }
40866
40867
40868 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40869 PyObject *resultobj = 0;
40870 wxMenu *arg1 = (wxMenu *) 0 ;
40871 size_t arg2 ;
40872 wxMenuItem *result = 0 ;
40873 void *argp1 = 0 ;
40874 int res1 = 0 ;
40875 size_t val2 ;
40876 int ecode2 = 0 ;
40877 PyObject * obj0 = 0 ;
40878 PyObject * obj1 = 0 ;
40879 char * kwnames[] = {
40880 (char *) "self",(char *) "position", NULL
40881 };
40882
40883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
40884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40885 if (!SWIG_IsOK(res1)) {
40886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
40887 }
40888 arg1 = reinterpret_cast< wxMenu * >(argp1);
40889 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40890 if (!SWIG_IsOK(ecode2)) {
40891 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
40892 }
40893 arg2 = static_cast< size_t >(val2);
40894 {
40895 PyThreadState* __tstate = wxPyBeginAllowThreads();
40896 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
40897 wxPyEndAllowThreads(__tstate);
40898 if (PyErr_Occurred()) SWIG_fail;
40899 }
40900 {
40901 resultobj = wxPyMake_wxObject(result, (bool)0);
40902 }
40903 return resultobj;
40904 fail:
40905 return NULL;
40906 }
40907
40908
40909 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40910 PyObject *resultobj = 0;
40911 wxMenu *arg1 = (wxMenu *) 0 ;
40912 int arg2 ;
40913 bool arg3 ;
40914 void *argp1 = 0 ;
40915 int res1 = 0 ;
40916 int val2 ;
40917 int ecode2 = 0 ;
40918 bool val3 ;
40919 int ecode3 = 0 ;
40920 PyObject * obj0 = 0 ;
40921 PyObject * obj1 = 0 ;
40922 PyObject * obj2 = 0 ;
40923 char * kwnames[] = {
40924 (char *) "self",(char *) "id",(char *) "enable", NULL
40925 };
40926
40927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40928 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40929 if (!SWIG_IsOK(res1)) {
40930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
40931 }
40932 arg1 = reinterpret_cast< wxMenu * >(argp1);
40933 ecode2 = SWIG_AsVal_int(obj1, &val2);
40934 if (!SWIG_IsOK(ecode2)) {
40935 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
40936 }
40937 arg2 = static_cast< int >(val2);
40938 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40939 if (!SWIG_IsOK(ecode3)) {
40940 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
40941 }
40942 arg3 = static_cast< bool >(val3);
40943 {
40944 PyThreadState* __tstate = wxPyBeginAllowThreads();
40945 (arg1)->Enable(arg2,arg3);
40946 wxPyEndAllowThreads(__tstate);
40947 if (PyErr_Occurred()) SWIG_fail;
40948 }
40949 resultobj = SWIG_Py_Void();
40950 return resultobj;
40951 fail:
40952 return NULL;
40953 }
40954
40955
40956 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40957 PyObject *resultobj = 0;
40958 wxMenu *arg1 = (wxMenu *) 0 ;
40959 int arg2 ;
40960 bool result;
40961 void *argp1 = 0 ;
40962 int res1 = 0 ;
40963 int val2 ;
40964 int ecode2 = 0 ;
40965 PyObject * obj0 = 0 ;
40966 PyObject * obj1 = 0 ;
40967 char * kwnames[] = {
40968 (char *) "self",(char *) "id", NULL
40969 };
40970
40971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
40972 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40973 if (!SWIG_IsOK(res1)) {
40974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
40975 }
40976 arg1 = reinterpret_cast< wxMenu * >(argp1);
40977 ecode2 = SWIG_AsVal_int(obj1, &val2);
40978 if (!SWIG_IsOK(ecode2)) {
40979 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
40980 }
40981 arg2 = static_cast< int >(val2);
40982 {
40983 PyThreadState* __tstate = wxPyBeginAllowThreads();
40984 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
40985 wxPyEndAllowThreads(__tstate);
40986 if (PyErr_Occurred()) SWIG_fail;
40987 }
40988 {
40989 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40990 }
40991 return resultobj;
40992 fail:
40993 return NULL;
40994 }
40995
40996
40997 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40998 PyObject *resultobj = 0;
40999 wxMenu *arg1 = (wxMenu *) 0 ;
41000 int arg2 ;
41001 bool arg3 ;
41002 void *argp1 = 0 ;
41003 int res1 = 0 ;
41004 int val2 ;
41005 int ecode2 = 0 ;
41006 bool val3 ;
41007 int ecode3 = 0 ;
41008 PyObject * obj0 = 0 ;
41009 PyObject * obj1 = 0 ;
41010 PyObject * obj2 = 0 ;
41011 char * kwnames[] = {
41012 (char *) "self",(char *) "id",(char *) "check", NULL
41013 };
41014
41015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41016 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41017 if (!SWIG_IsOK(res1)) {
41018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
41019 }
41020 arg1 = reinterpret_cast< wxMenu * >(argp1);
41021 ecode2 = SWIG_AsVal_int(obj1, &val2);
41022 if (!SWIG_IsOK(ecode2)) {
41023 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
41024 }
41025 arg2 = static_cast< int >(val2);
41026 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41027 if (!SWIG_IsOK(ecode3)) {
41028 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
41029 }
41030 arg3 = static_cast< bool >(val3);
41031 {
41032 PyThreadState* __tstate = wxPyBeginAllowThreads();
41033 (arg1)->Check(arg2,arg3);
41034 wxPyEndAllowThreads(__tstate);
41035 if (PyErr_Occurred()) SWIG_fail;
41036 }
41037 resultobj = SWIG_Py_Void();
41038 return resultobj;
41039 fail:
41040 return NULL;
41041 }
41042
41043
41044 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41045 PyObject *resultobj = 0;
41046 wxMenu *arg1 = (wxMenu *) 0 ;
41047 int arg2 ;
41048 bool result;
41049 void *argp1 = 0 ;
41050 int res1 = 0 ;
41051 int val2 ;
41052 int ecode2 = 0 ;
41053 PyObject * obj0 = 0 ;
41054 PyObject * obj1 = 0 ;
41055 char * kwnames[] = {
41056 (char *) "self",(char *) "id", NULL
41057 };
41058
41059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
41060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41061 if (!SWIG_IsOK(res1)) {
41062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
41063 }
41064 arg1 = reinterpret_cast< wxMenu * >(argp1);
41065 ecode2 = SWIG_AsVal_int(obj1, &val2);
41066 if (!SWIG_IsOK(ecode2)) {
41067 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
41068 }
41069 arg2 = static_cast< int >(val2);
41070 {
41071 PyThreadState* __tstate = wxPyBeginAllowThreads();
41072 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
41073 wxPyEndAllowThreads(__tstate);
41074 if (PyErr_Occurred()) SWIG_fail;
41075 }
41076 {
41077 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41078 }
41079 return resultobj;
41080 fail:
41081 return NULL;
41082 }
41083
41084
41085 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41086 PyObject *resultobj = 0;
41087 wxMenu *arg1 = (wxMenu *) 0 ;
41088 int arg2 ;
41089 wxString *arg3 = 0 ;
41090 void *argp1 = 0 ;
41091 int res1 = 0 ;
41092 int val2 ;
41093 int ecode2 = 0 ;
41094 bool temp3 = false ;
41095 PyObject * obj0 = 0 ;
41096 PyObject * obj1 = 0 ;
41097 PyObject * obj2 = 0 ;
41098 char * kwnames[] = {
41099 (char *) "self",(char *) "id",(char *) "label", NULL
41100 };
41101
41102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41103 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41104 if (!SWIG_IsOK(res1)) {
41105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
41106 }
41107 arg1 = reinterpret_cast< wxMenu * >(argp1);
41108 ecode2 = SWIG_AsVal_int(obj1, &val2);
41109 if (!SWIG_IsOK(ecode2)) {
41110 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
41111 }
41112 arg2 = static_cast< int >(val2);
41113 {
41114 arg3 = wxString_in_helper(obj2);
41115 if (arg3 == NULL) SWIG_fail;
41116 temp3 = true;
41117 }
41118 {
41119 PyThreadState* __tstate = wxPyBeginAllowThreads();
41120 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
41121 wxPyEndAllowThreads(__tstate);
41122 if (PyErr_Occurred()) SWIG_fail;
41123 }
41124 resultobj = SWIG_Py_Void();
41125 {
41126 if (temp3)
41127 delete arg3;
41128 }
41129 return resultobj;
41130 fail:
41131 {
41132 if (temp3)
41133 delete arg3;
41134 }
41135 return NULL;
41136 }
41137
41138
41139 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41140 PyObject *resultobj = 0;
41141 wxMenu *arg1 = (wxMenu *) 0 ;
41142 int arg2 ;
41143 wxString result;
41144 void *argp1 = 0 ;
41145 int res1 = 0 ;
41146 int val2 ;
41147 int ecode2 = 0 ;
41148 PyObject * obj0 = 0 ;
41149 PyObject * obj1 = 0 ;
41150 char * kwnames[] = {
41151 (char *) "self",(char *) "id", NULL
41152 };
41153
41154 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41155 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41156 if (!SWIG_IsOK(res1)) {
41157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
41158 }
41159 arg1 = reinterpret_cast< wxMenu * >(argp1);
41160 ecode2 = SWIG_AsVal_int(obj1, &val2);
41161 if (!SWIG_IsOK(ecode2)) {
41162 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
41163 }
41164 arg2 = static_cast< int >(val2);
41165 {
41166 PyThreadState* __tstate = wxPyBeginAllowThreads();
41167 result = ((wxMenu const *)arg1)->GetLabel(arg2);
41168 wxPyEndAllowThreads(__tstate);
41169 if (PyErr_Occurred()) SWIG_fail;
41170 }
41171 {
41172 #if wxUSE_UNICODE
41173 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41174 #else
41175 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41176 #endif
41177 }
41178 return resultobj;
41179 fail:
41180 return NULL;
41181 }
41182
41183
41184 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41185 PyObject *resultobj = 0;
41186 wxMenu *arg1 = (wxMenu *) 0 ;
41187 int arg2 ;
41188 wxString *arg3 = 0 ;
41189 void *argp1 = 0 ;
41190 int res1 = 0 ;
41191 int val2 ;
41192 int ecode2 = 0 ;
41193 bool temp3 = false ;
41194 PyObject * obj0 = 0 ;
41195 PyObject * obj1 = 0 ;
41196 PyObject * obj2 = 0 ;
41197 char * kwnames[] = {
41198 (char *) "self",(char *) "id",(char *) "helpString", NULL
41199 };
41200
41201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41203 if (!SWIG_IsOK(res1)) {
41204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
41205 }
41206 arg1 = reinterpret_cast< wxMenu * >(argp1);
41207 ecode2 = SWIG_AsVal_int(obj1, &val2);
41208 if (!SWIG_IsOK(ecode2)) {
41209 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
41210 }
41211 arg2 = static_cast< int >(val2);
41212 {
41213 arg3 = wxString_in_helper(obj2);
41214 if (arg3 == NULL) SWIG_fail;
41215 temp3 = true;
41216 }
41217 {
41218 PyThreadState* __tstate = wxPyBeginAllowThreads();
41219 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
41220 wxPyEndAllowThreads(__tstate);
41221 if (PyErr_Occurred()) SWIG_fail;
41222 }
41223 resultobj = SWIG_Py_Void();
41224 {
41225 if (temp3)
41226 delete arg3;
41227 }
41228 return resultobj;
41229 fail:
41230 {
41231 if (temp3)
41232 delete arg3;
41233 }
41234 return NULL;
41235 }
41236
41237
41238 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41239 PyObject *resultobj = 0;
41240 wxMenu *arg1 = (wxMenu *) 0 ;
41241 int arg2 ;
41242 wxString result;
41243 void *argp1 = 0 ;
41244 int res1 = 0 ;
41245 int val2 ;
41246 int ecode2 = 0 ;
41247 PyObject * obj0 = 0 ;
41248 PyObject * obj1 = 0 ;
41249 char * kwnames[] = {
41250 (char *) "self",(char *) "id", NULL
41251 };
41252
41253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
41254 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41255 if (!SWIG_IsOK(res1)) {
41256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
41257 }
41258 arg1 = reinterpret_cast< wxMenu * >(argp1);
41259 ecode2 = SWIG_AsVal_int(obj1, &val2);
41260 if (!SWIG_IsOK(ecode2)) {
41261 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
41262 }
41263 arg2 = static_cast< int >(val2);
41264 {
41265 PyThreadState* __tstate = wxPyBeginAllowThreads();
41266 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
41267 wxPyEndAllowThreads(__tstate);
41268 if (PyErr_Occurred()) SWIG_fail;
41269 }
41270 {
41271 #if wxUSE_UNICODE
41272 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41273 #else
41274 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41275 #endif
41276 }
41277 return resultobj;
41278 fail:
41279 return NULL;
41280 }
41281
41282
41283 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41284 PyObject *resultobj = 0;
41285 wxMenu *arg1 = (wxMenu *) 0 ;
41286 wxString *arg2 = 0 ;
41287 void *argp1 = 0 ;
41288 int res1 = 0 ;
41289 bool temp2 = false ;
41290 PyObject * obj0 = 0 ;
41291 PyObject * obj1 = 0 ;
41292 char * kwnames[] = {
41293 (char *) "self",(char *) "title", NULL
41294 };
41295
41296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
41297 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41298 if (!SWIG_IsOK(res1)) {
41299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
41300 }
41301 arg1 = reinterpret_cast< wxMenu * >(argp1);
41302 {
41303 arg2 = wxString_in_helper(obj1);
41304 if (arg2 == NULL) SWIG_fail;
41305 temp2 = true;
41306 }
41307 {
41308 PyThreadState* __tstate = wxPyBeginAllowThreads();
41309 (arg1)->SetTitle((wxString const &)*arg2);
41310 wxPyEndAllowThreads(__tstate);
41311 if (PyErr_Occurred()) SWIG_fail;
41312 }
41313 resultobj = SWIG_Py_Void();
41314 {
41315 if (temp2)
41316 delete arg2;
41317 }
41318 return resultobj;
41319 fail:
41320 {
41321 if (temp2)
41322 delete arg2;
41323 }
41324 return NULL;
41325 }
41326
41327
41328 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41329 PyObject *resultobj = 0;
41330 wxMenu *arg1 = (wxMenu *) 0 ;
41331 wxString result;
41332 void *argp1 = 0 ;
41333 int res1 = 0 ;
41334 PyObject *swig_obj[1] ;
41335
41336 if (!args) SWIG_fail;
41337 swig_obj[0] = args;
41338 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41339 if (!SWIG_IsOK(res1)) {
41340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
41341 }
41342 arg1 = reinterpret_cast< wxMenu * >(argp1);
41343 {
41344 PyThreadState* __tstate = wxPyBeginAllowThreads();
41345 result = ((wxMenu const *)arg1)->GetTitle();
41346 wxPyEndAllowThreads(__tstate);
41347 if (PyErr_Occurred()) SWIG_fail;
41348 }
41349 {
41350 #if wxUSE_UNICODE
41351 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41352 #else
41353 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41354 #endif
41355 }
41356 return resultobj;
41357 fail:
41358 return NULL;
41359 }
41360
41361
41362 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41363 PyObject *resultobj = 0;
41364 wxMenu *arg1 = (wxMenu *) 0 ;
41365 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
41366 void *argp1 = 0 ;
41367 int res1 = 0 ;
41368 void *argp2 = 0 ;
41369 int res2 = 0 ;
41370 PyObject * obj0 = 0 ;
41371 PyObject * obj1 = 0 ;
41372 char * kwnames[] = {
41373 (char *) "self",(char *) "handler", NULL
41374 };
41375
41376 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
41377 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41378 if (!SWIG_IsOK(res1)) {
41379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
41380 }
41381 arg1 = reinterpret_cast< wxMenu * >(argp1);
41382 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
41383 if (!SWIG_IsOK(res2)) {
41384 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
41385 }
41386 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
41387 {
41388 PyThreadState* __tstate = wxPyBeginAllowThreads();
41389 (arg1)->SetEventHandler(arg2);
41390 wxPyEndAllowThreads(__tstate);
41391 if (PyErr_Occurred()) SWIG_fail;
41392 }
41393 resultobj = SWIG_Py_Void();
41394 return resultobj;
41395 fail:
41396 return NULL;
41397 }
41398
41399
41400 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41401 PyObject *resultobj = 0;
41402 wxMenu *arg1 = (wxMenu *) 0 ;
41403 wxEvtHandler *result = 0 ;
41404 void *argp1 = 0 ;
41405 int res1 = 0 ;
41406 PyObject *swig_obj[1] ;
41407
41408 if (!args) SWIG_fail;
41409 swig_obj[0] = args;
41410 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41411 if (!SWIG_IsOK(res1)) {
41412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
41413 }
41414 arg1 = reinterpret_cast< wxMenu * >(argp1);
41415 {
41416 PyThreadState* __tstate = wxPyBeginAllowThreads();
41417 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
41418 wxPyEndAllowThreads(__tstate);
41419 if (PyErr_Occurred()) SWIG_fail;
41420 }
41421 {
41422 resultobj = wxPyMake_wxObject(result, 0);
41423 }
41424 return resultobj;
41425 fail:
41426 return NULL;
41427 }
41428
41429
41430 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41431 PyObject *resultobj = 0;
41432 wxMenu *arg1 = (wxMenu *) 0 ;
41433 wxWindow *arg2 = (wxWindow *) 0 ;
41434 void *argp1 = 0 ;
41435 int res1 = 0 ;
41436 void *argp2 = 0 ;
41437 int res2 = 0 ;
41438 PyObject * obj0 = 0 ;
41439 PyObject * obj1 = 0 ;
41440 char * kwnames[] = {
41441 (char *) "self",(char *) "win", NULL
41442 };
41443
41444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
41445 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41446 if (!SWIG_IsOK(res1)) {
41447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
41448 }
41449 arg1 = reinterpret_cast< wxMenu * >(argp1);
41450 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41451 if (!SWIG_IsOK(res2)) {
41452 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
41453 }
41454 arg2 = reinterpret_cast< wxWindow * >(argp2);
41455 {
41456 PyThreadState* __tstate = wxPyBeginAllowThreads();
41457 (arg1)->SetInvokingWindow(arg2);
41458 wxPyEndAllowThreads(__tstate);
41459 if (PyErr_Occurred()) SWIG_fail;
41460 }
41461 resultobj = SWIG_Py_Void();
41462 return resultobj;
41463 fail:
41464 return NULL;
41465 }
41466
41467
41468 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41469 PyObject *resultobj = 0;
41470 wxMenu *arg1 = (wxMenu *) 0 ;
41471 wxWindow *result = 0 ;
41472 void *argp1 = 0 ;
41473 int res1 = 0 ;
41474 PyObject *swig_obj[1] ;
41475
41476 if (!args) SWIG_fail;
41477 swig_obj[0] = args;
41478 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41479 if (!SWIG_IsOK(res1)) {
41480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
41481 }
41482 arg1 = reinterpret_cast< wxMenu * >(argp1);
41483 {
41484 PyThreadState* __tstate = wxPyBeginAllowThreads();
41485 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
41486 wxPyEndAllowThreads(__tstate);
41487 if (PyErr_Occurred()) SWIG_fail;
41488 }
41489 {
41490 resultobj = wxPyMake_wxObject(result, 0);
41491 }
41492 return resultobj;
41493 fail:
41494 return NULL;
41495 }
41496
41497
41498 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41499 PyObject *resultobj = 0;
41500 wxMenu *arg1 = (wxMenu *) 0 ;
41501 long result;
41502 void *argp1 = 0 ;
41503 int res1 = 0 ;
41504 PyObject *swig_obj[1] ;
41505
41506 if (!args) SWIG_fail;
41507 swig_obj[0] = args;
41508 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41509 if (!SWIG_IsOK(res1)) {
41510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
41511 }
41512 arg1 = reinterpret_cast< wxMenu * >(argp1);
41513 {
41514 PyThreadState* __tstate = wxPyBeginAllowThreads();
41515 result = (long)((wxMenu const *)arg1)->GetStyle();
41516 wxPyEndAllowThreads(__tstate);
41517 if (PyErr_Occurred()) SWIG_fail;
41518 }
41519 resultobj = SWIG_From_long(static_cast< long >(result));
41520 return resultobj;
41521 fail:
41522 return NULL;
41523 }
41524
41525
41526 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41527 PyObject *resultobj = 0;
41528 wxMenu *arg1 = (wxMenu *) 0 ;
41529 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
41530 void *argp1 = 0 ;
41531 int res1 = 0 ;
41532 void *argp2 = 0 ;
41533 int res2 = 0 ;
41534 PyObject * obj0 = 0 ;
41535 PyObject * obj1 = 0 ;
41536 char * kwnames[] = {
41537 (char *) "self",(char *) "source", NULL
41538 };
41539
41540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
41541 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41542 if (!SWIG_IsOK(res1)) {
41543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
41544 }
41545 arg1 = reinterpret_cast< wxMenu * >(argp1);
41546 if (obj1) {
41547 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
41548 if (!SWIG_IsOK(res2)) {
41549 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
41550 }
41551 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
41552 }
41553 {
41554 PyThreadState* __tstate = wxPyBeginAllowThreads();
41555 (arg1)->UpdateUI(arg2);
41556 wxPyEndAllowThreads(__tstate);
41557 if (PyErr_Occurred()) SWIG_fail;
41558 }
41559 resultobj = SWIG_Py_Void();
41560 return resultobj;
41561 fail:
41562 return NULL;
41563 }
41564
41565
41566 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41567 PyObject *resultobj = 0;
41568 wxMenu *arg1 = (wxMenu *) 0 ;
41569 wxMenuBar *result = 0 ;
41570 void *argp1 = 0 ;
41571 int res1 = 0 ;
41572 PyObject *swig_obj[1] ;
41573
41574 if (!args) SWIG_fail;
41575 swig_obj[0] = args;
41576 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41577 if (!SWIG_IsOK(res1)) {
41578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
41579 }
41580 arg1 = reinterpret_cast< wxMenu * >(argp1);
41581 {
41582 PyThreadState* __tstate = wxPyBeginAllowThreads();
41583 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
41584 wxPyEndAllowThreads(__tstate);
41585 if (PyErr_Occurred()) SWIG_fail;
41586 }
41587 {
41588 resultobj = wxPyMake_wxObject(result, (bool)0);
41589 }
41590 return resultobj;
41591 fail:
41592 return NULL;
41593 }
41594
41595
41596 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41597 PyObject *resultobj = 0;
41598 wxMenu *arg1 = (wxMenu *) 0 ;
41599 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
41600 void *argp1 = 0 ;
41601 int res1 = 0 ;
41602 void *argp2 = 0 ;
41603 int res2 = 0 ;
41604 PyObject * obj0 = 0 ;
41605 PyObject * obj1 = 0 ;
41606 char * kwnames[] = {
41607 (char *) "self",(char *) "menubar", NULL
41608 };
41609
41610 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
41611 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41612 if (!SWIG_IsOK(res1)) {
41613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
41614 }
41615 arg1 = reinterpret_cast< wxMenu * >(argp1);
41616 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
41617 if (!SWIG_IsOK(res2)) {
41618 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
41619 }
41620 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
41621 {
41622 PyThreadState* __tstate = wxPyBeginAllowThreads();
41623 (arg1)->Attach(arg2);
41624 wxPyEndAllowThreads(__tstate);
41625 if (PyErr_Occurred()) SWIG_fail;
41626 }
41627 resultobj = SWIG_Py_Void();
41628 return resultobj;
41629 fail:
41630 return NULL;
41631 }
41632
41633
41634 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41635 PyObject *resultobj = 0;
41636 wxMenu *arg1 = (wxMenu *) 0 ;
41637 void *argp1 = 0 ;
41638 int res1 = 0 ;
41639 PyObject *swig_obj[1] ;
41640
41641 if (!args) SWIG_fail;
41642 swig_obj[0] = args;
41643 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41644 if (!SWIG_IsOK(res1)) {
41645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
41646 }
41647 arg1 = reinterpret_cast< wxMenu * >(argp1);
41648 {
41649 PyThreadState* __tstate = wxPyBeginAllowThreads();
41650 (arg1)->Detach();
41651 wxPyEndAllowThreads(__tstate);
41652 if (PyErr_Occurred()) SWIG_fail;
41653 }
41654 resultobj = SWIG_Py_Void();
41655 return resultobj;
41656 fail:
41657 return NULL;
41658 }
41659
41660
41661 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41662 PyObject *resultobj = 0;
41663 wxMenu *arg1 = (wxMenu *) 0 ;
41664 bool result;
41665 void *argp1 = 0 ;
41666 int res1 = 0 ;
41667 PyObject *swig_obj[1] ;
41668
41669 if (!args) SWIG_fail;
41670 swig_obj[0] = args;
41671 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41672 if (!SWIG_IsOK(res1)) {
41673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
41674 }
41675 arg1 = reinterpret_cast< wxMenu * >(argp1);
41676 {
41677 PyThreadState* __tstate = wxPyBeginAllowThreads();
41678 result = (bool)((wxMenu const *)arg1)->IsAttached();
41679 wxPyEndAllowThreads(__tstate);
41680 if (PyErr_Occurred()) SWIG_fail;
41681 }
41682 {
41683 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41684 }
41685 return resultobj;
41686 fail:
41687 return NULL;
41688 }
41689
41690
41691 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41692 PyObject *resultobj = 0;
41693 wxMenu *arg1 = (wxMenu *) 0 ;
41694 wxMenu *arg2 = (wxMenu *) 0 ;
41695 void *argp1 = 0 ;
41696 int res1 = 0 ;
41697 void *argp2 = 0 ;
41698 int res2 = 0 ;
41699 PyObject * obj0 = 0 ;
41700 PyObject * obj1 = 0 ;
41701 char * kwnames[] = {
41702 (char *) "self",(char *) "parent", NULL
41703 };
41704
41705 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
41706 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41707 if (!SWIG_IsOK(res1)) {
41708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
41709 }
41710 arg1 = reinterpret_cast< wxMenu * >(argp1);
41711 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
41712 if (!SWIG_IsOK(res2)) {
41713 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
41714 }
41715 arg2 = reinterpret_cast< wxMenu * >(argp2);
41716 {
41717 PyThreadState* __tstate = wxPyBeginAllowThreads();
41718 (arg1)->SetParent(arg2);
41719 wxPyEndAllowThreads(__tstate);
41720 if (PyErr_Occurred()) SWIG_fail;
41721 }
41722 resultobj = SWIG_Py_Void();
41723 return resultobj;
41724 fail:
41725 return NULL;
41726 }
41727
41728
41729 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41730 PyObject *resultobj = 0;
41731 wxMenu *arg1 = (wxMenu *) 0 ;
41732 wxMenu *result = 0 ;
41733 void *argp1 = 0 ;
41734 int res1 = 0 ;
41735 PyObject *swig_obj[1] ;
41736
41737 if (!args) SWIG_fail;
41738 swig_obj[0] = args;
41739 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41740 if (!SWIG_IsOK(res1)) {
41741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
41742 }
41743 arg1 = reinterpret_cast< wxMenu * >(argp1);
41744 {
41745 PyThreadState* __tstate = wxPyBeginAllowThreads();
41746 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
41747 wxPyEndAllowThreads(__tstate);
41748 if (PyErr_Occurred()) SWIG_fail;
41749 }
41750 {
41751 resultobj = wxPyMake_wxObject(result, 0);
41752 }
41753 return resultobj;
41754 fail:
41755 return NULL;
41756 }
41757
41758
41759 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41760 PyObject *obj;
41761 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41762 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
41763 return SWIG_Py_Void();
41764 }
41765
41766 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41767 return SWIG_Python_InitShadowInstance(args);
41768 }
41769
41770 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41771 PyObject *resultobj = 0;
41772 long arg1 = (long) 0 ;
41773 wxMenuBar *result = 0 ;
41774 long val1 ;
41775 int ecode1 = 0 ;
41776 PyObject * obj0 = 0 ;
41777 char * kwnames[] = {
41778 (char *) "style", NULL
41779 };
41780
41781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
41782 if (obj0) {
41783 ecode1 = SWIG_AsVal_long(obj0, &val1);
41784 if (!SWIG_IsOK(ecode1)) {
41785 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
41786 }
41787 arg1 = static_cast< long >(val1);
41788 }
41789 {
41790 if (!wxPyCheckForApp()) SWIG_fail;
41791 PyThreadState* __tstate = wxPyBeginAllowThreads();
41792 result = (wxMenuBar *)new wxMenuBar(arg1);
41793 wxPyEndAllowThreads(__tstate);
41794 if (PyErr_Occurred()) SWIG_fail;
41795 }
41796 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
41797 return resultobj;
41798 fail:
41799 return NULL;
41800 }
41801
41802
41803 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41804 PyObject *resultobj = 0;
41805 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41806 wxMenu *arg2 = (wxMenu *) 0 ;
41807 wxString *arg3 = 0 ;
41808 bool result;
41809 void *argp1 = 0 ;
41810 int res1 = 0 ;
41811 void *argp2 = 0 ;
41812 int res2 = 0 ;
41813 bool temp3 = false ;
41814 PyObject * obj0 = 0 ;
41815 PyObject * obj1 = 0 ;
41816 PyObject * obj2 = 0 ;
41817 char * kwnames[] = {
41818 (char *) "self",(char *) "menu",(char *) "title", NULL
41819 };
41820
41821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41823 if (!SWIG_IsOK(res1)) {
41824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41825 }
41826 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41827 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
41828 if (!SWIG_IsOK(res2)) {
41829 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
41830 }
41831 arg2 = reinterpret_cast< wxMenu * >(argp2);
41832 {
41833 arg3 = wxString_in_helper(obj2);
41834 if (arg3 == NULL) SWIG_fail;
41835 temp3 = true;
41836 }
41837 {
41838 PyThreadState* __tstate = wxPyBeginAllowThreads();
41839 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
41840 wxPyEndAllowThreads(__tstate);
41841 if (PyErr_Occurred()) SWIG_fail;
41842 }
41843 {
41844 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41845 }
41846 {
41847 if (temp3)
41848 delete arg3;
41849 }
41850 return resultobj;
41851 fail:
41852 {
41853 if (temp3)
41854 delete arg3;
41855 }
41856 return NULL;
41857 }
41858
41859
41860 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41861 PyObject *resultobj = 0;
41862 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41863 size_t arg2 ;
41864 wxMenu *arg3 = (wxMenu *) 0 ;
41865 wxString *arg4 = 0 ;
41866 bool result;
41867 void *argp1 = 0 ;
41868 int res1 = 0 ;
41869 size_t val2 ;
41870 int ecode2 = 0 ;
41871 void *argp3 = 0 ;
41872 int res3 = 0 ;
41873 bool temp4 = false ;
41874 PyObject * obj0 = 0 ;
41875 PyObject * obj1 = 0 ;
41876 PyObject * obj2 = 0 ;
41877 PyObject * obj3 = 0 ;
41878 char * kwnames[] = {
41879 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
41880 };
41881
41882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41884 if (!SWIG_IsOK(res1)) {
41885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41886 }
41887 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41888 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41889 if (!SWIG_IsOK(ecode2)) {
41890 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
41891 }
41892 arg2 = static_cast< size_t >(val2);
41893 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
41894 if (!SWIG_IsOK(res3)) {
41895 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
41896 }
41897 arg3 = reinterpret_cast< wxMenu * >(argp3);
41898 {
41899 arg4 = wxString_in_helper(obj3);
41900 if (arg4 == NULL) SWIG_fail;
41901 temp4 = true;
41902 }
41903 {
41904 PyThreadState* __tstate = wxPyBeginAllowThreads();
41905 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
41906 wxPyEndAllowThreads(__tstate);
41907 if (PyErr_Occurred()) SWIG_fail;
41908 }
41909 {
41910 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41911 }
41912 {
41913 if (temp4)
41914 delete arg4;
41915 }
41916 return resultobj;
41917 fail:
41918 {
41919 if (temp4)
41920 delete arg4;
41921 }
41922 return NULL;
41923 }
41924
41925
41926 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41927 PyObject *resultobj = 0;
41928 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41929 size_t result;
41930 void *argp1 = 0 ;
41931 int res1 = 0 ;
41932 PyObject *swig_obj[1] ;
41933
41934 if (!args) SWIG_fail;
41935 swig_obj[0] = args;
41936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41937 if (!SWIG_IsOK(res1)) {
41938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41939 }
41940 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41941 {
41942 PyThreadState* __tstate = wxPyBeginAllowThreads();
41943 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
41944 wxPyEndAllowThreads(__tstate);
41945 if (PyErr_Occurred()) SWIG_fail;
41946 }
41947 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
41948 return resultobj;
41949 fail:
41950 return NULL;
41951 }
41952
41953
41954 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41955 PyObject *resultobj = 0;
41956 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41957 size_t arg2 ;
41958 wxMenu *result = 0 ;
41959 void *argp1 = 0 ;
41960 int res1 = 0 ;
41961 size_t val2 ;
41962 int ecode2 = 0 ;
41963 PyObject * obj0 = 0 ;
41964 PyObject * obj1 = 0 ;
41965 char * kwnames[] = {
41966 (char *) "self",(char *) "pos", NULL
41967 };
41968
41969 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41970 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41971 if (!SWIG_IsOK(res1)) {
41972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41973 }
41974 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41975 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41976 if (!SWIG_IsOK(ecode2)) {
41977 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
41978 }
41979 arg2 = static_cast< size_t >(val2);
41980 {
41981 PyThreadState* __tstate = wxPyBeginAllowThreads();
41982 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
41983 wxPyEndAllowThreads(__tstate);
41984 if (PyErr_Occurred()) SWIG_fail;
41985 }
41986 {
41987 resultobj = wxPyMake_wxObject(result, 0);
41988 }
41989 return resultobj;
41990 fail:
41991 return NULL;
41992 }
41993
41994
41995 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41996 PyObject *resultobj = 0;
41997 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41998 size_t arg2 ;
41999 wxMenu *arg3 = (wxMenu *) 0 ;
42000 wxString *arg4 = 0 ;
42001 wxMenu *result = 0 ;
42002 void *argp1 = 0 ;
42003 int res1 = 0 ;
42004 size_t val2 ;
42005 int ecode2 = 0 ;
42006 void *argp3 = 0 ;
42007 int res3 = 0 ;
42008 bool temp4 = false ;
42009 PyObject * obj0 = 0 ;
42010 PyObject * obj1 = 0 ;
42011 PyObject * obj2 = 0 ;
42012 PyObject * obj3 = 0 ;
42013 char * kwnames[] = {
42014 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
42015 };
42016
42017 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42018 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42019 if (!SWIG_IsOK(res1)) {
42020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42021 }
42022 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42023 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42024 if (!SWIG_IsOK(ecode2)) {
42025 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
42026 }
42027 arg2 = static_cast< size_t >(val2);
42028 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
42029 if (!SWIG_IsOK(res3)) {
42030 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
42031 }
42032 arg3 = reinterpret_cast< wxMenu * >(argp3);
42033 {
42034 arg4 = wxString_in_helper(obj3);
42035 if (arg4 == NULL) SWIG_fail;
42036 temp4 = true;
42037 }
42038 {
42039 PyThreadState* __tstate = wxPyBeginAllowThreads();
42040 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
42041 wxPyEndAllowThreads(__tstate);
42042 if (PyErr_Occurred()) SWIG_fail;
42043 }
42044 {
42045 resultobj = wxPyMake_wxObject(result, 0);
42046 }
42047 {
42048 if (temp4)
42049 delete arg4;
42050 }
42051 return resultobj;
42052 fail:
42053 {
42054 if (temp4)
42055 delete arg4;
42056 }
42057 return NULL;
42058 }
42059
42060
42061 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42062 PyObject *resultobj = 0;
42063 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42064 size_t arg2 ;
42065 wxMenu *result = 0 ;
42066 void *argp1 = 0 ;
42067 int res1 = 0 ;
42068 size_t val2 ;
42069 int ecode2 = 0 ;
42070 PyObject * obj0 = 0 ;
42071 PyObject * obj1 = 0 ;
42072 char * kwnames[] = {
42073 (char *) "self",(char *) "pos", NULL
42074 };
42075
42076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
42077 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42078 if (!SWIG_IsOK(res1)) {
42079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42080 }
42081 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42082 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42083 if (!SWIG_IsOK(ecode2)) {
42084 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
42085 }
42086 arg2 = static_cast< size_t >(val2);
42087 {
42088 PyThreadState* __tstate = wxPyBeginAllowThreads();
42089 result = (wxMenu *)(arg1)->Remove(arg2);
42090 wxPyEndAllowThreads(__tstate);
42091 if (PyErr_Occurred()) SWIG_fail;
42092 }
42093 {
42094 resultobj = wxPyMake_wxObject(result, 0);
42095 }
42096 return resultobj;
42097 fail:
42098 return NULL;
42099 }
42100
42101
42102 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42103 PyObject *resultobj = 0;
42104 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42105 size_t arg2 ;
42106 bool arg3 ;
42107 void *argp1 = 0 ;
42108 int res1 = 0 ;
42109 size_t val2 ;
42110 int ecode2 = 0 ;
42111 bool val3 ;
42112 int ecode3 = 0 ;
42113 PyObject * obj0 = 0 ;
42114 PyObject * obj1 = 0 ;
42115 PyObject * obj2 = 0 ;
42116 char * kwnames[] = {
42117 (char *) "self",(char *) "pos",(char *) "enable", NULL
42118 };
42119
42120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42121 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42122 if (!SWIG_IsOK(res1)) {
42123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42124 }
42125 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42126 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42127 if (!SWIG_IsOK(ecode2)) {
42128 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
42129 }
42130 arg2 = static_cast< size_t >(val2);
42131 ecode3 = SWIG_AsVal_bool(obj2, &val3);
42132 if (!SWIG_IsOK(ecode3)) {
42133 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
42134 }
42135 arg3 = static_cast< bool >(val3);
42136 {
42137 PyThreadState* __tstate = wxPyBeginAllowThreads();
42138 (arg1)->EnableTop(arg2,arg3);
42139 wxPyEndAllowThreads(__tstate);
42140 if (PyErr_Occurred()) SWIG_fail;
42141 }
42142 resultobj = SWIG_Py_Void();
42143 return resultobj;
42144 fail:
42145 return NULL;
42146 }
42147
42148
42149 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42150 PyObject *resultobj = 0;
42151 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42152 size_t arg2 ;
42153 bool result;
42154 void *argp1 = 0 ;
42155 int res1 = 0 ;
42156 size_t val2 ;
42157 int ecode2 = 0 ;
42158 PyObject * obj0 = 0 ;
42159 PyObject * obj1 = 0 ;
42160 char * kwnames[] = {
42161 (char *) "self",(char *) "pos", NULL
42162 };
42163
42164 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
42165 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42166 if (!SWIG_IsOK(res1)) {
42167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42168 }
42169 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42170 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42171 if (!SWIG_IsOK(ecode2)) {
42172 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
42173 }
42174 arg2 = static_cast< size_t >(val2);
42175 {
42176 PyThreadState* __tstate = wxPyBeginAllowThreads();
42177 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
42178 wxPyEndAllowThreads(__tstate);
42179 if (PyErr_Occurred()) SWIG_fail;
42180 }
42181 {
42182 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42183 }
42184 return resultobj;
42185 fail:
42186 return NULL;
42187 }
42188
42189
42190 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42191 PyObject *resultobj = 0;
42192 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42193 size_t arg2 ;
42194 wxString *arg3 = 0 ;
42195 void *argp1 = 0 ;
42196 int res1 = 0 ;
42197 size_t val2 ;
42198 int ecode2 = 0 ;
42199 bool temp3 = false ;
42200 PyObject * obj0 = 0 ;
42201 PyObject * obj1 = 0 ;
42202 PyObject * obj2 = 0 ;
42203 char * kwnames[] = {
42204 (char *) "self",(char *) "pos",(char *) "label", NULL
42205 };
42206
42207 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42208 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42209 if (!SWIG_IsOK(res1)) {
42210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42211 }
42212 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42213 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42214 if (!SWIG_IsOK(ecode2)) {
42215 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
42216 }
42217 arg2 = static_cast< size_t >(val2);
42218 {
42219 arg3 = wxString_in_helper(obj2);
42220 if (arg3 == NULL) SWIG_fail;
42221 temp3 = true;
42222 }
42223 {
42224 PyThreadState* __tstate = wxPyBeginAllowThreads();
42225 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
42226 wxPyEndAllowThreads(__tstate);
42227 if (PyErr_Occurred()) SWIG_fail;
42228 }
42229 resultobj = SWIG_Py_Void();
42230 {
42231 if (temp3)
42232 delete arg3;
42233 }
42234 return resultobj;
42235 fail:
42236 {
42237 if (temp3)
42238 delete arg3;
42239 }
42240 return NULL;
42241 }
42242
42243
42244 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42245 PyObject *resultobj = 0;
42246 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42247 size_t arg2 ;
42248 wxString result;
42249 void *argp1 = 0 ;
42250 int res1 = 0 ;
42251 size_t val2 ;
42252 int ecode2 = 0 ;
42253 PyObject * obj0 = 0 ;
42254 PyObject * obj1 = 0 ;
42255 char * kwnames[] = {
42256 (char *) "self",(char *) "pos", NULL
42257 };
42258
42259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
42260 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42261 if (!SWIG_IsOK(res1)) {
42262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42263 }
42264 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42265 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42266 if (!SWIG_IsOK(ecode2)) {
42267 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
42268 }
42269 arg2 = static_cast< size_t >(val2);
42270 {
42271 PyThreadState* __tstate = wxPyBeginAllowThreads();
42272 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
42273 wxPyEndAllowThreads(__tstate);
42274 if (PyErr_Occurred()) SWIG_fail;
42275 }
42276 {
42277 #if wxUSE_UNICODE
42278 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42279 #else
42280 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42281 #endif
42282 }
42283 return resultobj;
42284 fail:
42285 return NULL;
42286 }
42287
42288
42289 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42290 PyObject *resultobj = 0;
42291 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42292 wxString *arg2 = 0 ;
42293 wxString *arg3 = 0 ;
42294 int result;
42295 void *argp1 = 0 ;
42296 int res1 = 0 ;
42297 bool temp2 = false ;
42298 bool temp3 = false ;
42299 PyObject * obj0 = 0 ;
42300 PyObject * obj1 = 0 ;
42301 PyObject * obj2 = 0 ;
42302 char * kwnames[] = {
42303 (char *) "self",(char *) "menu",(char *) "item", NULL
42304 };
42305
42306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42307 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42308 if (!SWIG_IsOK(res1)) {
42309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42310 }
42311 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42312 {
42313 arg2 = wxString_in_helper(obj1);
42314 if (arg2 == NULL) SWIG_fail;
42315 temp2 = true;
42316 }
42317 {
42318 arg3 = wxString_in_helper(obj2);
42319 if (arg3 == NULL) SWIG_fail;
42320 temp3 = true;
42321 }
42322 {
42323 PyThreadState* __tstate = wxPyBeginAllowThreads();
42324 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
42325 wxPyEndAllowThreads(__tstate);
42326 if (PyErr_Occurred()) SWIG_fail;
42327 }
42328 resultobj = SWIG_From_int(static_cast< int >(result));
42329 {
42330 if (temp2)
42331 delete arg2;
42332 }
42333 {
42334 if (temp3)
42335 delete arg3;
42336 }
42337 return resultobj;
42338 fail:
42339 {
42340 if (temp2)
42341 delete arg2;
42342 }
42343 {
42344 if (temp3)
42345 delete arg3;
42346 }
42347 return NULL;
42348 }
42349
42350
42351 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42352 PyObject *resultobj = 0;
42353 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42354 int arg2 ;
42355 wxMenuItem *result = 0 ;
42356 void *argp1 = 0 ;
42357 int res1 = 0 ;
42358 int val2 ;
42359 int ecode2 = 0 ;
42360 PyObject * obj0 = 0 ;
42361 PyObject * obj1 = 0 ;
42362 char * kwnames[] = {
42363 (char *) "self",(char *) "id", NULL
42364 };
42365
42366 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
42367 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42368 if (!SWIG_IsOK(res1)) {
42369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42370 }
42371 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42372 ecode2 = SWIG_AsVal_int(obj1, &val2);
42373 if (!SWIG_IsOK(ecode2)) {
42374 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
42375 }
42376 arg2 = static_cast< int >(val2);
42377 {
42378 PyThreadState* __tstate = wxPyBeginAllowThreads();
42379 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
42380 wxPyEndAllowThreads(__tstate);
42381 if (PyErr_Occurred()) SWIG_fail;
42382 }
42383 {
42384 resultobj = wxPyMake_wxObject(result, (bool)0);
42385 }
42386 return resultobj;
42387 fail:
42388 return NULL;
42389 }
42390
42391
42392 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42393 PyObject *resultobj = 0;
42394 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42395 wxString *arg2 = 0 ;
42396 int result;
42397 void *argp1 = 0 ;
42398 int res1 = 0 ;
42399 bool temp2 = false ;
42400 PyObject * obj0 = 0 ;
42401 PyObject * obj1 = 0 ;
42402 char * kwnames[] = {
42403 (char *) "self",(char *) "title", NULL
42404 };
42405
42406 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42407 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42408 if (!SWIG_IsOK(res1)) {
42409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42410 }
42411 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42412 {
42413 arg2 = wxString_in_helper(obj1);
42414 if (arg2 == NULL) SWIG_fail;
42415 temp2 = true;
42416 }
42417 {
42418 PyThreadState* __tstate = wxPyBeginAllowThreads();
42419 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
42420 wxPyEndAllowThreads(__tstate);
42421 if (PyErr_Occurred()) SWIG_fail;
42422 }
42423 resultobj = SWIG_From_int(static_cast< int >(result));
42424 {
42425 if (temp2)
42426 delete arg2;
42427 }
42428 return resultobj;
42429 fail:
42430 {
42431 if (temp2)
42432 delete arg2;
42433 }
42434 return NULL;
42435 }
42436
42437
42438 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42439 PyObject *resultobj = 0;
42440 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42441 int arg2 ;
42442 bool arg3 ;
42443 void *argp1 = 0 ;
42444 int res1 = 0 ;
42445 int val2 ;
42446 int ecode2 = 0 ;
42447 bool val3 ;
42448 int ecode3 = 0 ;
42449 PyObject * obj0 = 0 ;
42450 PyObject * obj1 = 0 ;
42451 PyObject * obj2 = 0 ;
42452 char * kwnames[] = {
42453 (char *) "self",(char *) "id",(char *) "enable", NULL
42454 };
42455
42456 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42457 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42458 if (!SWIG_IsOK(res1)) {
42459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42460 }
42461 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42462 ecode2 = SWIG_AsVal_int(obj1, &val2);
42463 if (!SWIG_IsOK(ecode2)) {
42464 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
42465 }
42466 arg2 = static_cast< int >(val2);
42467 ecode3 = SWIG_AsVal_bool(obj2, &val3);
42468 if (!SWIG_IsOK(ecode3)) {
42469 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
42470 }
42471 arg3 = static_cast< bool >(val3);
42472 {
42473 PyThreadState* __tstate = wxPyBeginAllowThreads();
42474 (arg1)->Enable(arg2,arg3);
42475 wxPyEndAllowThreads(__tstate);
42476 if (PyErr_Occurred()) SWIG_fail;
42477 }
42478 resultobj = SWIG_Py_Void();
42479 return resultobj;
42480 fail:
42481 return NULL;
42482 }
42483
42484
42485 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42486 PyObject *resultobj = 0;
42487 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42488 int arg2 ;
42489 bool arg3 ;
42490 void *argp1 = 0 ;
42491 int res1 = 0 ;
42492 int val2 ;
42493 int ecode2 = 0 ;
42494 bool val3 ;
42495 int ecode3 = 0 ;
42496 PyObject * obj0 = 0 ;
42497 PyObject * obj1 = 0 ;
42498 PyObject * obj2 = 0 ;
42499 char * kwnames[] = {
42500 (char *) "self",(char *) "id",(char *) "check", NULL
42501 };
42502
42503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42504 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42505 if (!SWIG_IsOK(res1)) {
42506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42507 }
42508 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42509 ecode2 = SWIG_AsVal_int(obj1, &val2);
42510 if (!SWIG_IsOK(ecode2)) {
42511 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
42512 }
42513 arg2 = static_cast< int >(val2);
42514 ecode3 = SWIG_AsVal_bool(obj2, &val3);
42515 if (!SWIG_IsOK(ecode3)) {
42516 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
42517 }
42518 arg3 = static_cast< bool >(val3);
42519 {
42520 PyThreadState* __tstate = wxPyBeginAllowThreads();
42521 (arg1)->Check(arg2,arg3);
42522 wxPyEndAllowThreads(__tstate);
42523 if (PyErr_Occurred()) SWIG_fail;
42524 }
42525 resultobj = SWIG_Py_Void();
42526 return resultobj;
42527 fail:
42528 return NULL;
42529 }
42530
42531
42532 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42533 PyObject *resultobj = 0;
42534 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42535 int arg2 ;
42536 bool result;
42537 void *argp1 = 0 ;
42538 int res1 = 0 ;
42539 int val2 ;
42540 int ecode2 = 0 ;
42541 PyObject * obj0 = 0 ;
42542 PyObject * obj1 = 0 ;
42543 char * kwnames[] = {
42544 (char *) "self",(char *) "id", NULL
42545 };
42546
42547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
42548 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42549 if (!SWIG_IsOK(res1)) {
42550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42551 }
42552 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42553 ecode2 = SWIG_AsVal_int(obj1, &val2);
42554 if (!SWIG_IsOK(ecode2)) {
42555 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
42556 }
42557 arg2 = static_cast< int >(val2);
42558 {
42559 PyThreadState* __tstate = wxPyBeginAllowThreads();
42560 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
42561 wxPyEndAllowThreads(__tstate);
42562 if (PyErr_Occurred()) SWIG_fail;
42563 }
42564 {
42565 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42566 }
42567 return resultobj;
42568 fail:
42569 return NULL;
42570 }
42571
42572
42573 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42574 PyObject *resultobj = 0;
42575 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42576 int arg2 ;
42577 bool result;
42578 void *argp1 = 0 ;
42579 int res1 = 0 ;
42580 int val2 ;
42581 int ecode2 = 0 ;
42582 PyObject * obj0 = 0 ;
42583 PyObject * obj1 = 0 ;
42584 char * kwnames[] = {
42585 (char *) "self",(char *) "id", NULL
42586 };
42587
42588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
42589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42590 if (!SWIG_IsOK(res1)) {
42591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42592 }
42593 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42594 ecode2 = SWIG_AsVal_int(obj1, &val2);
42595 if (!SWIG_IsOK(ecode2)) {
42596 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
42597 }
42598 arg2 = static_cast< int >(val2);
42599 {
42600 PyThreadState* __tstate = wxPyBeginAllowThreads();
42601 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
42602 wxPyEndAllowThreads(__tstate);
42603 if (PyErr_Occurred()) SWIG_fail;
42604 }
42605 {
42606 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42607 }
42608 return resultobj;
42609 fail:
42610 return NULL;
42611 }
42612
42613
42614 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42615 PyObject *resultobj = 0;
42616 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42617 int arg2 ;
42618 wxString *arg3 = 0 ;
42619 void *argp1 = 0 ;
42620 int res1 = 0 ;
42621 int val2 ;
42622 int ecode2 = 0 ;
42623 bool temp3 = false ;
42624 PyObject * obj0 = 0 ;
42625 PyObject * obj1 = 0 ;
42626 PyObject * obj2 = 0 ;
42627 char * kwnames[] = {
42628 (char *) "self",(char *) "id",(char *) "label", NULL
42629 };
42630
42631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42632 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42633 if (!SWIG_IsOK(res1)) {
42634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42635 }
42636 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42637 ecode2 = SWIG_AsVal_int(obj1, &val2);
42638 if (!SWIG_IsOK(ecode2)) {
42639 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
42640 }
42641 arg2 = static_cast< int >(val2);
42642 {
42643 arg3 = wxString_in_helper(obj2);
42644 if (arg3 == NULL) SWIG_fail;
42645 temp3 = true;
42646 }
42647 {
42648 PyThreadState* __tstate = wxPyBeginAllowThreads();
42649 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
42650 wxPyEndAllowThreads(__tstate);
42651 if (PyErr_Occurred()) SWIG_fail;
42652 }
42653 resultobj = SWIG_Py_Void();
42654 {
42655 if (temp3)
42656 delete arg3;
42657 }
42658 return resultobj;
42659 fail:
42660 {
42661 if (temp3)
42662 delete arg3;
42663 }
42664 return NULL;
42665 }
42666
42667
42668 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42669 PyObject *resultobj = 0;
42670 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42671 int arg2 ;
42672 wxString result;
42673 void *argp1 = 0 ;
42674 int res1 = 0 ;
42675 int val2 ;
42676 int ecode2 = 0 ;
42677 PyObject * obj0 = 0 ;
42678 PyObject * obj1 = 0 ;
42679 char * kwnames[] = {
42680 (char *) "self",(char *) "id", NULL
42681 };
42682
42683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
42684 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42685 if (!SWIG_IsOK(res1)) {
42686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42687 }
42688 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42689 ecode2 = SWIG_AsVal_int(obj1, &val2);
42690 if (!SWIG_IsOK(ecode2)) {
42691 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
42692 }
42693 arg2 = static_cast< int >(val2);
42694 {
42695 PyThreadState* __tstate = wxPyBeginAllowThreads();
42696 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
42697 wxPyEndAllowThreads(__tstate);
42698 if (PyErr_Occurred()) SWIG_fail;
42699 }
42700 {
42701 #if wxUSE_UNICODE
42702 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42703 #else
42704 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42705 #endif
42706 }
42707 return resultobj;
42708 fail:
42709 return NULL;
42710 }
42711
42712
42713 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42714 PyObject *resultobj = 0;
42715 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42716 int arg2 ;
42717 wxString *arg3 = 0 ;
42718 void *argp1 = 0 ;
42719 int res1 = 0 ;
42720 int val2 ;
42721 int ecode2 = 0 ;
42722 bool temp3 = false ;
42723 PyObject * obj0 = 0 ;
42724 PyObject * obj1 = 0 ;
42725 PyObject * obj2 = 0 ;
42726 char * kwnames[] = {
42727 (char *) "self",(char *) "id",(char *) "helpString", NULL
42728 };
42729
42730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42731 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42732 if (!SWIG_IsOK(res1)) {
42733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42734 }
42735 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42736 ecode2 = SWIG_AsVal_int(obj1, &val2);
42737 if (!SWIG_IsOK(ecode2)) {
42738 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
42739 }
42740 arg2 = static_cast< int >(val2);
42741 {
42742 arg3 = wxString_in_helper(obj2);
42743 if (arg3 == NULL) SWIG_fail;
42744 temp3 = true;
42745 }
42746 {
42747 PyThreadState* __tstate = wxPyBeginAllowThreads();
42748 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
42749 wxPyEndAllowThreads(__tstate);
42750 if (PyErr_Occurred()) SWIG_fail;
42751 }
42752 resultobj = SWIG_Py_Void();
42753 {
42754 if (temp3)
42755 delete arg3;
42756 }
42757 return resultobj;
42758 fail:
42759 {
42760 if (temp3)
42761 delete arg3;
42762 }
42763 return NULL;
42764 }
42765
42766
42767 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42768 PyObject *resultobj = 0;
42769 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42770 int arg2 ;
42771 wxString result;
42772 void *argp1 = 0 ;
42773 int res1 = 0 ;
42774 int val2 ;
42775 int ecode2 = 0 ;
42776 PyObject * obj0 = 0 ;
42777 PyObject * obj1 = 0 ;
42778 char * kwnames[] = {
42779 (char *) "self",(char *) "id", NULL
42780 };
42781
42782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
42783 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42784 if (!SWIG_IsOK(res1)) {
42785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42786 }
42787 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42788 ecode2 = SWIG_AsVal_int(obj1, &val2);
42789 if (!SWIG_IsOK(ecode2)) {
42790 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
42791 }
42792 arg2 = static_cast< int >(val2);
42793 {
42794 PyThreadState* __tstate = wxPyBeginAllowThreads();
42795 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
42796 wxPyEndAllowThreads(__tstate);
42797 if (PyErr_Occurred()) SWIG_fail;
42798 }
42799 {
42800 #if wxUSE_UNICODE
42801 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42802 #else
42803 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42804 #endif
42805 }
42806 return resultobj;
42807 fail:
42808 return NULL;
42809 }
42810
42811
42812 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42813 PyObject *resultobj = 0;
42814 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42815 wxFrame *result = 0 ;
42816 void *argp1 = 0 ;
42817 int res1 = 0 ;
42818 PyObject *swig_obj[1] ;
42819
42820 if (!args) SWIG_fail;
42821 swig_obj[0] = args;
42822 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42823 if (!SWIG_IsOK(res1)) {
42824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42825 }
42826 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42827 {
42828 PyThreadState* __tstate = wxPyBeginAllowThreads();
42829 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
42830 wxPyEndAllowThreads(__tstate);
42831 if (PyErr_Occurred()) SWIG_fail;
42832 }
42833 {
42834 resultobj = wxPyMake_wxObject(result, (bool)0);
42835 }
42836 return resultobj;
42837 fail:
42838 return NULL;
42839 }
42840
42841
42842 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42843 PyObject *resultobj = 0;
42844 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42845 bool result;
42846 void *argp1 = 0 ;
42847 int res1 = 0 ;
42848 PyObject *swig_obj[1] ;
42849
42850 if (!args) SWIG_fail;
42851 swig_obj[0] = args;
42852 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42853 if (!SWIG_IsOK(res1)) {
42854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42855 }
42856 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42857 {
42858 PyThreadState* __tstate = wxPyBeginAllowThreads();
42859 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
42860 wxPyEndAllowThreads(__tstate);
42861 if (PyErr_Occurred()) SWIG_fail;
42862 }
42863 {
42864 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42865 }
42866 return resultobj;
42867 fail:
42868 return NULL;
42869 }
42870
42871
42872 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42873 PyObject *resultobj = 0;
42874 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42875 wxFrame *arg2 = (wxFrame *) 0 ;
42876 void *argp1 = 0 ;
42877 int res1 = 0 ;
42878 void *argp2 = 0 ;
42879 int res2 = 0 ;
42880 PyObject * obj0 = 0 ;
42881 PyObject * obj1 = 0 ;
42882 char * kwnames[] = {
42883 (char *) "self",(char *) "frame", NULL
42884 };
42885
42886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
42887 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42888 if (!SWIG_IsOK(res1)) {
42889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42890 }
42891 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42892 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
42893 if (!SWIG_IsOK(res2)) {
42894 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
42895 }
42896 arg2 = reinterpret_cast< wxFrame * >(argp2);
42897 {
42898 PyThreadState* __tstate = wxPyBeginAllowThreads();
42899 (arg1)->Attach(arg2);
42900 wxPyEndAllowThreads(__tstate);
42901 if (PyErr_Occurred()) SWIG_fail;
42902 }
42903 resultobj = SWIG_Py_Void();
42904 return resultobj;
42905 fail:
42906 return NULL;
42907 }
42908
42909
42910 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42911 PyObject *resultobj = 0;
42912 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42913 void *argp1 = 0 ;
42914 int res1 = 0 ;
42915 PyObject *swig_obj[1] ;
42916
42917 if (!args) SWIG_fail;
42918 swig_obj[0] = args;
42919 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42920 if (!SWIG_IsOK(res1)) {
42921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42922 }
42923 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42924 {
42925 PyThreadState* __tstate = wxPyBeginAllowThreads();
42926 (arg1)->Detach();
42927 wxPyEndAllowThreads(__tstate);
42928 if (PyErr_Occurred()) SWIG_fail;
42929 }
42930 resultobj = SWIG_Py_Void();
42931 return resultobj;
42932 fail:
42933 return NULL;
42934 }
42935
42936
42937 SWIGINTERN PyObject *_wrap_MenuBar_UpdateMenus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42938 PyObject *resultobj = 0;
42939 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42940 void *argp1 = 0 ;
42941 int res1 = 0 ;
42942 PyObject *swig_obj[1] ;
42943
42944 if (!args) SWIG_fail;
42945 swig_obj[0] = args;
42946 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42947 if (!SWIG_IsOK(res1)) {
42948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_UpdateMenus" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42949 }
42950 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42951 {
42952 PyThreadState* __tstate = wxPyBeginAllowThreads();
42953 (arg1)->UpdateMenus();
42954 wxPyEndAllowThreads(__tstate);
42955 if (PyErr_Occurred()) SWIG_fail;
42956 }
42957 resultobj = SWIG_Py_Void();
42958 return resultobj;
42959 fail:
42960 return NULL;
42961 }
42962
42963
42964 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42965 PyObject *resultobj = 0;
42966 bool arg1 ;
42967 bool val1 ;
42968 int ecode1 = 0 ;
42969 PyObject * obj0 = 0 ;
42970 char * kwnames[] = {
42971 (char *) "enable", NULL
42972 };
42973
42974 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
42975 ecode1 = SWIG_AsVal_bool(obj0, &val1);
42976 if (!SWIG_IsOK(ecode1)) {
42977 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
42978 }
42979 arg1 = static_cast< bool >(val1);
42980 {
42981 PyThreadState* __tstate = wxPyBeginAllowThreads();
42982 wxMenuBar_SetAutoWindowMenu(arg1);
42983 wxPyEndAllowThreads(__tstate);
42984 if (PyErr_Occurred()) SWIG_fail;
42985 }
42986 resultobj = SWIG_Py_Void();
42987 return resultobj;
42988 fail:
42989 return NULL;
42990 }
42991
42992
42993 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42994 PyObject *resultobj = 0;
42995 bool result;
42996
42997 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
42998 {
42999 PyThreadState* __tstate = wxPyBeginAllowThreads();
43000 result = (bool)wxMenuBar_GetAutoWindowMenu();
43001 wxPyEndAllowThreads(__tstate);
43002 if (PyErr_Occurred()) SWIG_fail;
43003 }
43004 {
43005 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43006 }
43007 return resultobj;
43008 fail:
43009 return NULL;
43010 }
43011
43012
43013 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43014 PyObject *obj;
43015 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
43016 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
43017 return SWIG_Py_Void();
43018 }
43019
43020 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43021 return SWIG_Python_InitShadowInstance(args);
43022 }
43023
43024 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43025 PyObject *resultobj = 0;
43026 wxMenu *arg1 = (wxMenu *) NULL ;
43027 int arg2 = (int) wxID_ANY ;
43028 wxString const &arg3_defvalue = wxPyEmptyString ;
43029 wxString *arg3 = (wxString *) &arg3_defvalue ;
43030 wxString const &arg4_defvalue = wxPyEmptyString ;
43031 wxString *arg4 = (wxString *) &arg4_defvalue ;
43032 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
43033 wxMenu *arg6 = (wxMenu *) NULL ;
43034 wxMenuItem *result = 0 ;
43035 void *argp1 = 0 ;
43036 int res1 = 0 ;
43037 int val2 ;
43038 int ecode2 = 0 ;
43039 bool temp3 = false ;
43040 bool temp4 = false ;
43041 int val5 ;
43042 int ecode5 = 0 ;
43043 void *argp6 = 0 ;
43044 int res6 = 0 ;
43045 PyObject * obj0 = 0 ;
43046 PyObject * obj1 = 0 ;
43047 PyObject * obj2 = 0 ;
43048 PyObject * obj3 = 0 ;
43049 PyObject * obj4 = 0 ;
43050 PyObject * obj5 = 0 ;
43051 char * kwnames[] = {
43052 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
43053 };
43054
43055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
43056 if (obj0) {
43057 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43058 if (!SWIG_IsOK(res1)) {
43059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43060 }
43061 arg1 = reinterpret_cast< wxMenu * >(argp1);
43062 }
43063 if (obj1) {
43064 ecode2 = SWIG_AsVal_int(obj1, &val2);
43065 if (!SWIG_IsOK(ecode2)) {
43066 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
43067 }
43068 arg2 = static_cast< int >(val2);
43069 }
43070 if (obj2) {
43071 {
43072 arg3 = wxString_in_helper(obj2);
43073 if (arg3 == NULL) SWIG_fail;
43074 temp3 = true;
43075 }
43076 }
43077 if (obj3) {
43078 {
43079 arg4 = wxString_in_helper(obj3);
43080 if (arg4 == NULL) SWIG_fail;
43081 temp4 = true;
43082 }
43083 }
43084 if (obj4) {
43085 ecode5 = SWIG_AsVal_int(obj4, &val5);
43086 if (!SWIG_IsOK(ecode5)) {
43087 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
43088 }
43089 arg5 = static_cast< wxItemKind >(val5);
43090 }
43091 if (obj5) {
43092 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
43093 if (!SWIG_IsOK(res6)) {
43094 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
43095 }
43096 arg6 = reinterpret_cast< wxMenu * >(argp6);
43097 }
43098 {
43099 PyThreadState* __tstate = wxPyBeginAllowThreads();
43100 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
43101 wxPyEndAllowThreads(__tstate);
43102 if (PyErr_Occurred()) SWIG_fail;
43103 }
43104 {
43105 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
43106 }
43107 {
43108 if (temp3)
43109 delete arg3;
43110 }
43111 {
43112 if (temp4)
43113 delete arg4;
43114 }
43115 return resultobj;
43116 fail:
43117 {
43118 if (temp3)
43119 delete arg3;
43120 }
43121 {
43122 if (temp4)
43123 delete arg4;
43124 }
43125 return NULL;
43126 }
43127
43128
43129 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43130 PyObject *resultobj = 0;
43131 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43132 void *argp1 = 0 ;
43133 int res1 = 0 ;
43134 PyObject *swig_obj[1] ;
43135
43136 if (!args) SWIG_fail;
43137 swig_obj[0] = args;
43138 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
43139 if (!SWIG_IsOK(res1)) {
43140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43141 }
43142 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43143 {
43144 PyThreadState* __tstate = wxPyBeginAllowThreads();
43145 delete arg1;
43146
43147 wxPyEndAllowThreads(__tstate);
43148 if (PyErr_Occurred()) SWIG_fail;
43149 }
43150 resultobj = SWIG_Py_Void();
43151 return resultobj;
43152 fail:
43153 return NULL;
43154 }
43155
43156
43157 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43158 PyObject *resultobj = 0;
43159 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43160 wxMenu *result = 0 ;
43161 void *argp1 = 0 ;
43162 int res1 = 0 ;
43163 PyObject *swig_obj[1] ;
43164
43165 if (!args) SWIG_fail;
43166 swig_obj[0] = args;
43167 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43168 if (!SWIG_IsOK(res1)) {
43169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43170 }
43171 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43172 {
43173 PyThreadState* __tstate = wxPyBeginAllowThreads();
43174 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
43175 wxPyEndAllowThreads(__tstate);
43176 if (PyErr_Occurred()) SWIG_fail;
43177 }
43178 {
43179 resultobj = wxPyMake_wxObject(result, 0);
43180 }
43181 return resultobj;
43182 fail:
43183 return NULL;
43184 }
43185
43186
43187 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43188 PyObject *resultobj = 0;
43189 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43190 wxMenu *arg2 = (wxMenu *) 0 ;
43191 void *argp1 = 0 ;
43192 int res1 = 0 ;
43193 void *argp2 = 0 ;
43194 int res2 = 0 ;
43195 PyObject * obj0 = 0 ;
43196 PyObject * obj1 = 0 ;
43197 char * kwnames[] = {
43198 (char *) "self",(char *) "menu", NULL
43199 };
43200
43201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
43202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43203 if (!SWIG_IsOK(res1)) {
43204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43205 }
43206 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43207 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
43208 if (!SWIG_IsOK(res2)) {
43209 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
43210 }
43211 arg2 = reinterpret_cast< wxMenu * >(argp2);
43212 {
43213 PyThreadState* __tstate = wxPyBeginAllowThreads();
43214 (arg1)->SetMenu(arg2);
43215 wxPyEndAllowThreads(__tstate);
43216 if (PyErr_Occurred()) SWIG_fail;
43217 }
43218 resultobj = SWIG_Py_Void();
43219 return resultobj;
43220 fail:
43221 return NULL;
43222 }
43223
43224
43225 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43226 PyObject *resultobj = 0;
43227 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43228 int arg2 ;
43229 void *argp1 = 0 ;
43230 int res1 = 0 ;
43231 int val2 ;
43232 int ecode2 = 0 ;
43233 PyObject * obj0 = 0 ;
43234 PyObject * obj1 = 0 ;
43235 char * kwnames[] = {
43236 (char *) "self",(char *) "id", NULL
43237 };
43238
43239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
43240 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43241 if (!SWIG_IsOK(res1)) {
43242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43243 }
43244 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43245 ecode2 = SWIG_AsVal_int(obj1, &val2);
43246 if (!SWIG_IsOK(ecode2)) {
43247 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
43248 }
43249 arg2 = static_cast< int >(val2);
43250 {
43251 PyThreadState* __tstate = wxPyBeginAllowThreads();
43252 (arg1)->SetId(arg2);
43253 wxPyEndAllowThreads(__tstate);
43254 if (PyErr_Occurred()) SWIG_fail;
43255 }
43256 resultobj = SWIG_Py_Void();
43257 return resultobj;
43258 fail:
43259 return NULL;
43260 }
43261
43262
43263 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43264 PyObject *resultobj = 0;
43265 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43266 int result;
43267 void *argp1 = 0 ;
43268 int res1 = 0 ;
43269 PyObject *swig_obj[1] ;
43270
43271 if (!args) SWIG_fail;
43272 swig_obj[0] = args;
43273 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43274 if (!SWIG_IsOK(res1)) {
43275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43276 }
43277 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43278 {
43279 PyThreadState* __tstate = wxPyBeginAllowThreads();
43280 result = (int)((wxMenuItem const *)arg1)->GetId();
43281 wxPyEndAllowThreads(__tstate);
43282 if (PyErr_Occurred()) SWIG_fail;
43283 }
43284 resultobj = SWIG_From_int(static_cast< int >(result));
43285 return resultobj;
43286 fail:
43287 return NULL;
43288 }
43289
43290
43291 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43292 PyObject *resultobj = 0;
43293 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43294 bool result;
43295 void *argp1 = 0 ;
43296 int res1 = 0 ;
43297 PyObject *swig_obj[1] ;
43298
43299 if (!args) SWIG_fail;
43300 swig_obj[0] = args;
43301 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43302 if (!SWIG_IsOK(res1)) {
43303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43304 }
43305 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43306 {
43307 PyThreadState* __tstate = wxPyBeginAllowThreads();
43308 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
43309 wxPyEndAllowThreads(__tstate);
43310 if (PyErr_Occurred()) SWIG_fail;
43311 }
43312 {
43313 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43314 }
43315 return resultobj;
43316 fail:
43317 return NULL;
43318 }
43319
43320
43321 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43322 PyObject *resultobj = 0;
43323 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43324 wxString *arg2 = 0 ;
43325 void *argp1 = 0 ;
43326 int res1 = 0 ;
43327 bool temp2 = false ;
43328 PyObject * obj0 = 0 ;
43329 PyObject * obj1 = 0 ;
43330 char * kwnames[] = {
43331 (char *) "self",(char *) "str", NULL
43332 };
43333
43334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
43335 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43336 if (!SWIG_IsOK(res1)) {
43337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43338 }
43339 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43340 {
43341 arg2 = wxString_in_helper(obj1);
43342 if (arg2 == NULL) SWIG_fail;
43343 temp2 = true;
43344 }
43345 {
43346 PyThreadState* __tstate = wxPyBeginAllowThreads();
43347 (arg1)->SetText((wxString const &)*arg2);
43348 wxPyEndAllowThreads(__tstate);
43349 if (PyErr_Occurred()) SWIG_fail;
43350 }
43351 resultobj = SWIG_Py_Void();
43352 {
43353 if (temp2)
43354 delete arg2;
43355 }
43356 return resultobj;
43357 fail:
43358 {
43359 if (temp2)
43360 delete arg2;
43361 }
43362 return NULL;
43363 }
43364
43365
43366 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43367 PyObject *resultobj = 0;
43368 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43369 wxString result;
43370 void *argp1 = 0 ;
43371 int res1 = 0 ;
43372 PyObject *swig_obj[1] ;
43373
43374 if (!args) SWIG_fail;
43375 swig_obj[0] = args;
43376 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43377 if (!SWIG_IsOK(res1)) {
43378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43379 }
43380 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43381 {
43382 PyThreadState* __tstate = wxPyBeginAllowThreads();
43383 result = ((wxMenuItem const *)arg1)->GetLabel();
43384 wxPyEndAllowThreads(__tstate);
43385 if (PyErr_Occurred()) SWIG_fail;
43386 }
43387 {
43388 #if wxUSE_UNICODE
43389 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43390 #else
43391 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43392 #endif
43393 }
43394 return resultobj;
43395 fail:
43396 return NULL;
43397 }
43398
43399
43400 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43401 PyObject *resultobj = 0;
43402 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43403 wxString *result = 0 ;
43404 void *argp1 = 0 ;
43405 int res1 = 0 ;
43406 PyObject *swig_obj[1] ;
43407
43408 if (!args) SWIG_fail;
43409 swig_obj[0] = args;
43410 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43411 if (!SWIG_IsOK(res1)) {
43412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43413 }
43414 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43415 {
43416 PyThreadState* __tstate = wxPyBeginAllowThreads();
43417 {
43418 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
43419 result = (wxString *) &_result_ref;
43420 }
43421 wxPyEndAllowThreads(__tstate);
43422 if (PyErr_Occurred()) SWIG_fail;
43423 }
43424 {
43425 #if wxUSE_UNICODE
43426 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
43427 #else
43428 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
43429 #endif
43430 }
43431 return resultobj;
43432 fail:
43433 return NULL;
43434 }
43435
43436
43437 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43438 PyObject *resultobj = 0;
43439 wxString *arg1 = 0 ;
43440 wxString result;
43441 bool temp1 = false ;
43442 PyObject * obj0 = 0 ;
43443 char * kwnames[] = {
43444 (char *) "text", NULL
43445 };
43446
43447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
43448 {
43449 arg1 = wxString_in_helper(obj0);
43450 if (arg1 == NULL) SWIG_fail;
43451 temp1 = true;
43452 }
43453 {
43454 PyThreadState* __tstate = wxPyBeginAllowThreads();
43455 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
43456 wxPyEndAllowThreads(__tstate);
43457 if (PyErr_Occurred()) SWIG_fail;
43458 }
43459 {
43460 #if wxUSE_UNICODE
43461 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43462 #else
43463 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43464 #endif
43465 }
43466 {
43467 if (temp1)
43468 delete arg1;
43469 }
43470 return resultobj;
43471 fail:
43472 {
43473 if (temp1)
43474 delete arg1;
43475 }
43476 return NULL;
43477 }
43478
43479
43480 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43481 PyObject *resultobj = 0;
43482 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43483 wxItemKind result;
43484 void *argp1 = 0 ;
43485 int res1 = 0 ;
43486 PyObject *swig_obj[1] ;
43487
43488 if (!args) SWIG_fail;
43489 swig_obj[0] = args;
43490 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43491 if (!SWIG_IsOK(res1)) {
43492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43493 }
43494 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43495 {
43496 PyThreadState* __tstate = wxPyBeginAllowThreads();
43497 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
43498 wxPyEndAllowThreads(__tstate);
43499 if (PyErr_Occurred()) SWIG_fail;
43500 }
43501 resultobj = SWIG_From_int(static_cast< int >(result));
43502 return resultobj;
43503 fail:
43504 return NULL;
43505 }
43506
43507
43508 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43509 PyObject *resultobj = 0;
43510 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43511 wxItemKind arg2 ;
43512 void *argp1 = 0 ;
43513 int res1 = 0 ;
43514 int val2 ;
43515 int ecode2 = 0 ;
43516 PyObject * obj0 = 0 ;
43517 PyObject * obj1 = 0 ;
43518 char * kwnames[] = {
43519 (char *) "self",(char *) "kind", NULL
43520 };
43521
43522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
43523 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43524 if (!SWIG_IsOK(res1)) {
43525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43526 }
43527 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43528 ecode2 = SWIG_AsVal_int(obj1, &val2);
43529 if (!SWIG_IsOK(ecode2)) {
43530 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
43531 }
43532 arg2 = static_cast< wxItemKind >(val2);
43533 {
43534 PyThreadState* __tstate = wxPyBeginAllowThreads();
43535 (arg1)->SetKind(arg2);
43536 wxPyEndAllowThreads(__tstate);
43537 if (PyErr_Occurred()) SWIG_fail;
43538 }
43539 resultobj = SWIG_Py_Void();
43540 return resultobj;
43541 fail:
43542 return NULL;
43543 }
43544
43545
43546 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43547 PyObject *resultobj = 0;
43548 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43549 bool arg2 ;
43550 void *argp1 = 0 ;
43551 int res1 = 0 ;
43552 bool val2 ;
43553 int ecode2 = 0 ;
43554 PyObject * obj0 = 0 ;
43555 PyObject * obj1 = 0 ;
43556 char * kwnames[] = {
43557 (char *) "self",(char *) "checkable", NULL
43558 };
43559
43560 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
43561 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43562 if (!SWIG_IsOK(res1)) {
43563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43564 }
43565 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43566 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43567 if (!SWIG_IsOK(ecode2)) {
43568 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
43569 }
43570 arg2 = static_cast< bool >(val2);
43571 {
43572 PyThreadState* __tstate = wxPyBeginAllowThreads();
43573 (arg1)->SetCheckable(arg2);
43574 wxPyEndAllowThreads(__tstate);
43575 if (PyErr_Occurred()) SWIG_fail;
43576 }
43577 resultobj = SWIG_Py_Void();
43578 return resultobj;
43579 fail:
43580 return NULL;
43581 }
43582
43583
43584 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43585 PyObject *resultobj = 0;
43586 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43587 bool result;
43588 void *argp1 = 0 ;
43589 int res1 = 0 ;
43590 PyObject *swig_obj[1] ;
43591
43592 if (!args) SWIG_fail;
43593 swig_obj[0] = args;
43594 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43595 if (!SWIG_IsOK(res1)) {
43596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43597 }
43598 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43599 {
43600 PyThreadState* __tstate = wxPyBeginAllowThreads();
43601 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
43602 wxPyEndAllowThreads(__tstate);
43603 if (PyErr_Occurred()) SWIG_fail;
43604 }
43605 {
43606 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43607 }
43608 return resultobj;
43609 fail:
43610 return NULL;
43611 }
43612
43613
43614 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43615 PyObject *resultobj = 0;
43616 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43617 bool result;
43618 void *argp1 = 0 ;
43619 int res1 = 0 ;
43620 PyObject *swig_obj[1] ;
43621
43622 if (!args) SWIG_fail;
43623 swig_obj[0] = args;
43624 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43625 if (!SWIG_IsOK(res1)) {
43626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43627 }
43628 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43629 {
43630 PyThreadState* __tstate = wxPyBeginAllowThreads();
43631 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
43632 wxPyEndAllowThreads(__tstate);
43633 if (PyErr_Occurred()) SWIG_fail;
43634 }
43635 {
43636 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43637 }
43638 return resultobj;
43639 fail:
43640 return NULL;
43641 }
43642
43643
43644 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43645 PyObject *resultobj = 0;
43646 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43647 wxMenu *arg2 = (wxMenu *) 0 ;
43648 void *argp1 = 0 ;
43649 int res1 = 0 ;
43650 void *argp2 = 0 ;
43651 int res2 = 0 ;
43652 PyObject * obj0 = 0 ;
43653 PyObject * obj1 = 0 ;
43654 char * kwnames[] = {
43655 (char *) "self",(char *) "menu", NULL
43656 };
43657
43658 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
43659 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43660 if (!SWIG_IsOK(res1)) {
43661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43662 }
43663 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43664 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
43665 if (!SWIG_IsOK(res2)) {
43666 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
43667 }
43668 arg2 = reinterpret_cast< wxMenu * >(argp2);
43669 {
43670 PyThreadState* __tstate = wxPyBeginAllowThreads();
43671 (arg1)->SetSubMenu(arg2);
43672 wxPyEndAllowThreads(__tstate);
43673 if (PyErr_Occurred()) SWIG_fail;
43674 }
43675 resultobj = SWIG_Py_Void();
43676 return resultobj;
43677 fail:
43678 return NULL;
43679 }
43680
43681
43682 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43683 PyObject *resultobj = 0;
43684 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43685 wxMenu *result = 0 ;
43686 void *argp1 = 0 ;
43687 int res1 = 0 ;
43688 PyObject *swig_obj[1] ;
43689
43690 if (!args) SWIG_fail;
43691 swig_obj[0] = args;
43692 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43693 if (!SWIG_IsOK(res1)) {
43694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43695 }
43696 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43697 {
43698 PyThreadState* __tstate = wxPyBeginAllowThreads();
43699 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
43700 wxPyEndAllowThreads(__tstate);
43701 if (PyErr_Occurred()) SWIG_fail;
43702 }
43703 {
43704 resultobj = wxPyMake_wxObject(result, 0);
43705 }
43706 return resultobj;
43707 fail:
43708 return NULL;
43709 }
43710
43711
43712 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43713 PyObject *resultobj = 0;
43714 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43715 bool arg2 = (bool) true ;
43716 void *argp1 = 0 ;
43717 int res1 = 0 ;
43718 bool val2 ;
43719 int ecode2 = 0 ;
43720 PyObject * obj0 = 0 ;
43721 PyObject * obj1 = 0 ;
43722 char * kwnames[] = {
43723 (char *) "self",(char *) "enable", NULL
43724 };
43725
43726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
43727 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43728 if (!SWIG_IsOK(res1)) {
43729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43730 }
43731 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43732 if (obj1) {
43733 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43734 if (!SWIG_IsOK(ecode2)) {
43735 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
43736 }
43737 arg2 = static_cast< bool >(val2);
43738 }
43739 {
43740 PyThreadState* __tstate = wxPyBeginAllowThreads();
43741 (arg1)->Enable(arg2);
43742 wxPyEndAllowThreads(__tstate);
43743 if (PyErr_Occurred()) SWIG_fail;
43744 }
43745 resultobj = SWIG_Py_Void();
43746 return resultobj;
43747 fail:
43748 return NULL;
43749 }
43750
43751
43752 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43753 PyObject *resultobj = 0;
43754 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43755 bool result;
43756 void *argp1 = 0 ;
43757 int res1 = 0 ;
43758 PyObject *swig_obj[1] ;
43759
43760 if (!args) SWIG_fail;
43761 swig_obj[0] = args;
43762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43763 if (!SWIG_IsOK(res1)) {
43764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43765 }
43766 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43767 {
43768 PyThreadState* __tstate = wxPyBeginAllowThreads();
43769 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
43770 wxPyEndAllowThreads(__tstate);
43771 if (PyErr_Occurred()) SWIG_fail;
43772 }
43773 {
43774 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43775 }
43776 return resultobj;
43777 fail:
43778 return NULL;
43779 }
43780
43781
43782 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43783 PyObject *resultobj = 0;
43784 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43785 bool arg2 = (bool) true ;
43786 void *argp1 = 0 ;
43787 int res1 = 0 ;
43788 bool val2 ;
43789 int ecode2 = 0 ;
43790 PyObject * obj0 = 0 ;
43791 PyObject * obj1 = 0 ;
43792 char * kwnames[] = {
43793 (char *) "self",(char *) "check", NULL
43794 };
43795
43796 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
43797 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43798 if (!SWIG_IsOK(res1)) {
43799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43800 }
43801 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43802 if (obj1) {
43803 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43804 if (!SWIG_IsOK(ecode2)) {
43805 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
43806 }
43807 arg2 = static_cast< bool >(val2);
43808 }
43809 {
43810 PyThreadState* __tstate = wxPyBeginAllowThreads();
43811 (arg1)->Check(arg2);
43812 wxPyEndAllowThreads(__tstate);
43813 if (PyErr_Occurred()) SWIG_fail;
43814 }
43815 resultobj = SWIG_Py_Void();
43816 return resultobj;
43817 fail:
43818 return NULL;
43819 }
43820
43821
43822 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43823 PyObject *resultobj = 0;
43824 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43825 bool result;
43826 void *argp1 = 0 ;
43827 int res1 = 0 ;
43828 PyObject *swig_obj[1] ;
43829
43830 if (!args) SWIG_fail;
43831 swig_obj[0] = args;
43832 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43833 if (!SWIG_IsOK(res1)) {
43834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43835 }
43836 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43837 {
43838 PyThreadState* __tstate = wxPyBeginAllowThreads();
43839 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
43840 wxPyEndAllowThreads(__tstate);
43841 if (PyErr_Occurred()) SWIG_fail;
43842 }
43843 {
43844 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43845 }
43846 return resultobj;
43847 fail:
43848 return NULL;
43849 }
43850
43851
43852 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43853 PyObject *resultobj = 0;
43854 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43855 void *argp1 = 0 ;
43856 int res1 = 0 ;
43857 PyObject *swig_obj[1] ;
43858
43859 if (!args) SWIG_fail;
43860 swig_obj[0] = args;
43861 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43862 if (!SWIG_IsOK(res1)) {
43863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43864 }
43865 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43866 {
43867 PyThreadState* __tstate = wxPyBeginAllowThreads();
43868 (arg1)->Toggle();
43869 wxPyEndAllowThreads(__tstate);
43870 if (PyErr_Occurred()) SWIG_fail;
43871 }
43872 resultobj = SWIG_Py_Void();
43873 return resultobj;
43874 fail:
43875 return NULL;
43876 }
43877
43878
43879 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43880 PyObject *resultobj = 0;
43881 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43882 wxString *arg2 = 0 ;
43883 void *argp1 = 0 ;
43884 int res1 = 0 ;
43885 bool temp2 = false ;
43886 PyObject * obj0 = 0 ;
43887 PyObject * obj1 = 0 ;
43888 char * kwnames[] = {
43889 (char *) "self",(char *) "str", NULL
43890 };
43891
43892 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
43893 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43894 if (!SWIG_IsOK(res1)) {
43895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43896 }
43897 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43898 {
43899 arg2 = wxString_in_helper(obj1);
43900 if (arg2 == NULL) SWIG_fail;
43901 temp2 = true;
43902 }
43903 {
43904 PyThreadState* __tstate = wxPyBeginAllowThreads();
43905 (arg1)->SetHelp((wxString const &)*arg2);
43906 wxPyEndAllowThreads(__tstate);
43907 if (PyErr_Occurred()) SWIG_fail;
43908 }
43909 resultobj = SWIG_Py_Void();
43910 {
43911 if (temp2)
43912 delete arg2;
43913 }
43914 return resultobj;
43915 fail:
43916 {
43917 if (temp2)
43918 delete arg2;
43919 }
43920 return NULL;
43921 }
43922
43923
43924 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43925 PyObject *resultobj = 0;
43926 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43927 wxString *result = 0 ;
43928 void *argp1 = 0 ;
43929 int res1 = 0 ;
43930 PyObject *swig_obj[1] ;
43931
43932 if (!args) SWIG_fail;
43933 swig_obj[0] = args;
43934 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43935 if (!SWIG_IsOK(res1)) {
43936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43937 }
43938 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43939 {
43940 PyThreadState* __tstate = wxPyBeginAllowThreads();
43941 {
43942 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
43943 result = (wxString *) &_result_ref;
43944 }
43945 wxPyEndAllowThreads(__tstate);
43946 if (PyErr_Occurred()) SWIG_fail;
43947 }
43948 {
43949 #if wxUSE_UNICODE
43950 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
43951 #else
43952 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
43953 #endif
43954 }
43955 return resultobj;
43956 fail:
43957 return NULL;
43958 }
43959
43960
43961 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43962 PyObject *resultobj = 0;
43963 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43964 wxAcceleratorEntry *result = 0 ;
43965 void *argp1 = 0 ;
43966 int res1 = 0 ;
43967 PyObject *swig_obj[1] ;
43968
43969 if (!args) SWIG_fail;
43970 swig_obj[0] = args;
43971 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43972 if (!SWIG_IsOK(res1)) {
43973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43974 }
43975 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43976 {
43977 PyThreadState* __tstate = wxPyBeginAllowThreads();
43978 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
43979 wxPyEndAllowThreads(__tstate);
43980 if (PyErr_Occurred()) SWIG_fail;
43981 }
43982 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
43983 return resultobj;
43984 fail:
43985 return NULL;
43986 }
43987
43988
43989 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43990 PyObject *resultobj = 0;
43991 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43992 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
43993 void *argp1 = 0 ;
43994 int res1 = 0 ;
43995 void *argp2 = 0 ;
43996 int res2 = 0 ;
43997 PyObject * obj0 = 0 ;
43998 PyObject * obj1 = 0 ;
43999 char * kwnames[] = {
44000 (char *) "self",(char *) "accel", NULL
44001 };
44002
44003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
44004 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44005 if (!SWIG_IsOK(res1)) {
44006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44007 }
44008 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44009 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
44010 if (!SWIG_IsOK(res2)) {
44011 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
44012 }
44013 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
44014 {
44015 PyThreadState* __tstate = wxPyBeginAllowThreads();
44016 (arg1)->SetAccel(arg2);
44017 wxPyEndAllowThreads(__tstate);
44018 if (PyErr_Occurred()) SWIG_fail;
44019 }
44020 resultobj = SWIG_Py_Void();
44021 return resultobj;
44022 fail:
44023 return NULL;
44024 }
44025
44026
44027 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44028 PyObject *resultobj = 0;
44029 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44030 wxBitmap *arg2 = 0 ;
44031 void *argp1 = 0 ;
44032 int res1 = 0 ;
44033 void *argp2 = 0 ;
44034 int res2 = 0 ;
44035 PyObject * obj0 = 0 ;
44036 PyObject * obj1 = 0 ;
44037 char * kwnames[] = {
44038 (char *) "self",(char *) "bitmap", NULL
44039 };
44040
44041 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
44042 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44043 if (!SWIG_IsOK(res1)) {
44044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44045 }
44046 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44047 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
44048 if (!SWIG_IsOK(res2)) {
44049 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44050 }
44051 if (!argp2) {
44052 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44053 }
44054 arg2 = reinterpret_cast< wxBitmap * >(argp2);
44055 {
44056 PyThreadState* __tstate = wxPyBeginAllowThreads();
44057 (arg1)->SetBitmap((wxBitmap const &)*arg2);
44058 wxPyEndAllowThreads(__tstate);
44059 if (PyErr_Occurred()) SWIG_fail;
44060 }
44061 resultobj = SWIG_Py_Void();
44062 return resultobj;
44063 fail:
44064 return NULL;
44065 }
44066
44067
44068 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44069 PyObject *resultobj = 0;
44070 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44071 wxBitmap *result = 0 ;
44072 void *argp1 = 0 ;
44073 int res1 = 0 ;
44074 PyObject *swig_obj[1] ;
44075
44076 if (!args) SWIG_fail;
44077 swig_obj[0] = args;
44078 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44079 if (!SWIG_IsOK(res1)) {
44080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44081 }
44082 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44083 {
44084 PyThreadState* __tstate = wxPyBeginAllowThreads();
44085 {
44086 wxBitmap const &_result_ref = (arg1)->GetBitmap();
44087 result = (wxBitmap *) &_result_ref;
44088 }
44089 wxPyEndAllowThreads(__tstate);
44090 if (PyErr_Occurred()) SWIG_fail;
44091 }
44092 {
44093 wxBitmap* resultptr = new wxBitmap(*result);
44094 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
44095 }
44096 return resultobj;
44097 fail:
44098 return NULL;
44099 }
44100
44101
44102 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44103 PyObject *resultobj = 0;
44104 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44105 wxFont *arg2 = 0 ;
44106 void *argp1 = 0 ;
44107 int res1 = 0 ;
44108 void *argp2 = 0 ;
44109 int res2 = 0 ;
44110 PyObject * obj0 = 0 ;
44111 PyObject * obj1 = 0 ;
44112 char * kwnames[] = {
44113 (char *) "self",(char *) "font", NULL
44114 };
44115
44116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
44117 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44118 if (!SWIG_IsOK(res1)) {
44119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44120 }
44121 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44122 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
44123 if (!SWIG_IsOK(res2)) {
44124 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
44125 }
44126 if (!argp2) {
44127 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
44128 }
44129 arg2 = reinterpret_cast< wxFont * >(argp2);
44130 {
44131 PyThreadState* __tstate = wxPyBeginAllowThreads();
44132 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
44133 wxPyEndAllowThreads(__tstate);
44134 if (PyErr_Occurred()) SWIG_fail;
44135 }
44136 resultobj = SWIG_Py_Void();
44137 return resultobj;
44138 fail:
44139 return NULL;
44140 }
44141
44142
44143 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44144 PyObject *resultobj = 0;
44145 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44146 wxFont result;
44147 void *argp1 = 0 ;
44148 int res1 = 0 ;
44149 PyObject *swig_obj[1] ;
44150
44151 if (!args) SWIG_fail;
44152 swig_obj[0] = args;
44153 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44154 if (!SWIG_IsOK(res1)) {
44155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44156 }
44157 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44158 {
44159 PyThreadState* __tstate = wxPyBeginAllowThreads();
44160 result = wxMenuItem_GetFont(arg1);
44161 wxPyEndAllowThreads(__tstate);
44162 if (PyErr_Occurred()) SWIG_fail;
44163 }
44164 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
44165 return resultobj;
44166 fail:
44167 return NULL;
44168 }
44169
44170
44171 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44172 PyObject *resultobj = 0;
44173 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44174 wxColour *arg2 = 0 ;
44175 void *argp1 = 0 ;
44176 int res1 = 0 ;
44177 wxColour temp2 ;
44178 PyObject * obj0 = 0 ;
44179 PyObject * obj1 = 0 ;
44180 char * kwnames[] = {
44181 (char *) "self",(char *) "colText", NULL
44182 };
44183
44184 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
44185 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44186 if (!SWIG_IsOK(res1)) {
44187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44188 }
44189 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44190 {
44191 arg2 = &temp2;
44192 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
44193 }
44194 {
44195 PyThreadState* __tstate = wxPyBeginAllowThreads();
44196 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
44197 wxPyEndAllowThreads(__tstate);
44198 if (PyErr_Occurred()) SWIG_fail;
44199 }
44200 resultobj = SWIG_Py_Void();
44201 return resultobj;
44202 fail:
44203 return NULL;
44204 }
44205
44206
44207 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44208 PyObject *resultobj = 0;
44209 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44210 wxColour result;
44211 void *argp1 = 0 ;
44212 int res1 = 0 ;
44213 PyObject *swig_obj[1] ;
44214
44215 if (!args) SWIG_fail;
44216 swig_obj[0] = args;
44217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44218 if (!SWIG_IsOK(res1)) {
44219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44220 }
44221 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44222 {
44223 PyThreadState* __tstate = wxPyBeginAllowThreads();
44224 result = wxMenuItem_GetTextColour(arg1);
44225 wxPyEndAllowThreads(__tstate);
44226 if (PyErr_Occurred()) SWIG_fail;
44227 }
44228 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
44229 return resultobj;
44230 fail:
44231 return NULL;
44232 }
44233
44234
44235 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44236 PyObject *resultobj = 0;
44237 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44238 wxColour *arg2 = 0 ;
44239 void *argp1 = 0 ;
44240 int res1 = 0 ;
44241 wxColour temp2 ;
44242 PyObject * obj0 = 0 ;
44243 PyObject * obj1 = 0 ;
44244 char * kwnames[] = {
44245 (char *) "self",(char *) "colBack", NULL
44246 };
44247
44248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
44249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44250 if (!SWIG_IsOK(res1)) {
44251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44252 }
44253 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44254 {
44255 arg2 = &temp2;
44256 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
44257 }
44258 {
44259 PyThreadState* __tstate = wxPyBeginAllowThreads();
44260 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
44261 wxPyEndAllowThreads(__tstate);
44262 if (PyErr_Occurred()) SWIG_fail;
44263 }
44264 resultobj = SWIG_Py_Void();
44265 return resultobj;
44266 fail:
44267 return NULL;
44268 }
44269
44270
44271 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44272 PyObject *resultobj = 0;
44273 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44274 wxColour result;
44275 void *argp1 = 0 ;
44276 int res1 = 0 ;
44277 PyObject *swig_obj[1] ;
44278
44279 if (!args) SWIG_fail;
44280 swig_obj[0] = args;
44281 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44282 if (!SWIG_IsOK(res1)) {
44283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44284 }
44285 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44286 {
44287 PyThreadState* __tstate = wxPyBeginAllowThreads();
44288 result = wxMenuItem_GetBackgroundColour(arg1);
44289 wxPyEndAllowThreads(__tstate);
44290 if (PyErr_Occurred()) SWIG_fail;
44291 }
44292 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
44293 return resultobj;
44294 fail:
44295 return NULL;
44296 }
44297
44298
44299 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44300 PyObject *resultobj = 0;
44301 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44302 wxBitmap *arg2 = 0 ;
44303 wxBitmap const &arg3_defvalue = wxNullBitmap ;
44304 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
44305 void *argp1 = 0 ;
44306 int res1 = 0 ;
44307 void *argp2 = 0 ;
44308 int res2 = 0 ;
44309 void *argp3 = 0 ;
44310 int res3 = 0 ;
44311 PyObject * obj0 = 0 ;
44312 PyObject * obj1 = 0 ;
44313 PyObject * obj2 = 0 ;
44314 char * kwnames[] = {
44315 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
44316 };
44317
44318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44319 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44320 if (!SWIG_IsOK(res1)) {
44321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44322 }
44323 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44324 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
44325 if (!SWIG_IsOK(res2)) {
44326 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44327 }
44328 if (!argp2) {
44329 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44330 }
44331 arg2 = reinterpret_cast< wxBitmap * >(argp2);
44332 if (obj2) {
44333 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
44334 if (!SWIG_IsOK(res3)) {
44335 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
44336 }
44337 if (!argp3) {
44338 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
44339 }
44340 arg3 = reinterpret_cast< wxBitmap * >(argp3);
44341 }
44342 {
44343 PyThreadState* __tstate = wxPyBeginAllowThreads();
44344 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
44345 wxPyEndAllowThreads(__tstate);
44346 if (PyErr_Occurred()) SWIG_fail;
44347 }
44348 resultobj = SWIG_Py_Void();
44349 return resultobj;
44350 fail:
44351 return NULL;
44352 }
44353
44354
44355 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44356 PyObject *resultobj = 0;
44357 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44358 wxBitmap *arg2 = 0 ;
44359 void *argp1 = 0 ;
44360 int res1 = 0 ;
44361 void *argp2 = 0 ;
44362 int res2 = 0 ;
44363 PyObject * obj0 = 0 ;
44364 PyObject * obj1 = 0 ;
44365 char * kwnames[] = {
44366 (char *) "self",(char *) "bmpDisabled", NULL
44367 };
44368
44369 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
44370 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44371 if (!SWIG_IsOK(res1)) {
44372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44373 }
44374 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44375 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
44376 if (!SWIG_IsOK(res2)) {
44377 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44378 }
44379 if (!argp2) {
44380 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44381 }
44382 arg2 = reinterpret_cast< wxBitmap * >(argp2);
44383 {
44384 PyThreadState* __tstate = wxPyBeginAllowThreads();
44385 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
44386 wxPyEndAllowThreads(__tstate);
44387 if (PyErr_Occurred()) SWIG_fail;
44388 }
44389 resultobj = SWIG_Py_Void();
44390 return resultobj;
44391 fail:
44392 return NULL;
44393 }
44394
44395
44396 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44397 PyObject *resultobj = 0;
44398 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44399 wxBitmap *result = 0 ;
44400 void *argp1 = 0 ;
44401 int res1 = 0 ;
44402 PyObject *swig_obj[1] ;
44403
44404 if (!args) SWIG_fail;
44405 swig_obj[0] = args;
44406 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44407 if (!SWIG_IsOK(res1)) {
44408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44409 }
44410 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44411 {
44412 PyThreadState* __tstate = wxPyBeginAllowThreads();
44413 {
44414 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
44415 result = (wxBitmap *) &_result_ref;
44416 }
44417 wxPyEndAllowThreads(__tstate);
44418 if (PyErr_Occurred()) SWIG_fail;
44419 }
44420 {
44421 wxBitmap* resultptr = new wxBitmap(*result);
44422 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
44423 }
44424 return resultobj;
44425 fail:
44426 return NULL;
44427 }
44428
44429
44430 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44431 PyObject *resultobj = 0;
44432 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44433 int arg2 ;
44434 void *argp1 = 0 ;
44435 int res1 = 0 ;
44436 int val2 ;
44437 int ecode2 = 0 ;
44438 PyObject * obj0 = 0 ;
44439 PyObject * obj1 = 0 ;
44440 char * kwnames[] = {
44441 (char *) "self",(char *) "nWidth", NULL
44442 };
44443
44444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
44445 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44446 if (!SWIG_IsOK(res1)) {
44447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44448 }
44449 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44450 ecode2 = SWIG_AsVal_int(obj1, &val2);
44451 if (!SWIG_IsOK(ecode2)) {
44452 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
44453 }
44454 arg2 = static_cast< int >(val2);
44455 {
44456 PyThreadState* __tstate = wxPyBeginAllowThreads();
44457 wxMenuItem_SetMarginWidth(arg1,arg2);
44458 wxPyEndAllowThreads(__tstate);
44459 if (PyErr_Occurred()) SWIG_fail;
44460 }
44461 resultobj = SWIG_Py_Void();
44462 return resultobj;
44463 fail:
44464 return NULL;
44465 }
44466
44467
44468 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44469 PyObject *resultobj = 0;
44470 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44471 int result;
44472 void *argp1 = 0 ;
44473 int res1 = 0 ;
44474 PyObject *swig_obj[1] ;
44475
44476 if (!args) SWIG_fail;
44477 swig_obj[0] = args;
44478 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44479 if (!SWIG_IsOK(res1)) {
44480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44481 }
44482 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44483 {
44484 PyThreadState* __tstate = wxPyBeginAllowThreads();
44485 result = (int)wxMenuItem_GetMarginWidth(arg1);
44486 wxPyEndAllowThreads(__tstate);
44487 if (PyErr_Occurred()) SWIG_fail;
44488 }
44489 resultobj = SWIG_From_int(static_cast< int >(result));
44490 return resultobj;
44491 fail:
44492 return NULL;
44493 }
44494
44495
44496 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44497 PyObject *resultobj = 0;
44498 int result;
44499
44500 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
44501 {
44502 PyThreadState* __tstate = wxPyBeginAllowThreads();
44503 result = (int)wxMenuItem_GetDefaultMarginWidth();
44504 wxPyEndAllowThreads(__tstate);
44505 if (PyErr_Occurred()) SWIG_fail;
44506 }
44507 resultobj = SWIG_From_int(static_cast< int >(result));
44508 return resultobj;
44509 fail:
44510 return NULL;
44511 }
44512
44513
44514 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44515 PyObject *resultobj = 0;
44516 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44517 bool result;
44518 void *argp1 = 0 ;
44519 int res1 = 0 ;
44520 PyObject *swig_obj[1] ;
44521
44522 if (!args) SWIG_fail;
44523 swig_obj[0] = args;
44524 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44525 if (!SWIG_IsOK(res1)) {
44526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44527 }
44528 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44529 {
44530 PyThreadState* __tstate = wxPyBeginAllowThreads();
44531 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
44532 wxPyEndAllowThreads(__tstate);
44533 if (PyErr_Occurred()) SWIG_fail;
44534 }
44535 {
44536 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44537 }
44538 return resultobj;
44539 fail:
44540 return NULL;
44541 }
44542
44543
44544 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44545 PyObject *resultobj = 0;
44546 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44547 bool arg2 = (bool) true ;
44548 void *argp1 = 0 ;
44549 int res1 = 0 ;
44550 bool val2 ;
44551 int ecode2 = 0 ;
44552 PyObject * obj0 = 0 ;
44553 PyObject * obj1 = 0 ;
44554 char * kwnames[] = {
44555 (char *) "self",(char *) "ownerDrawn", NULL
44556 };
44557
44558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
44559 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44560 if (!SWIG_IsOK(res1)) {
44561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44562 }
44563 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44564 if (obj1) {
44565 ecode2 = SWIG_AsVal_bool(obj1, &val2);
44566 if (!SWIG_IsOK(ecode2)) {
44567 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
44568 }
44569 arg2 = static_cast< bool >(val2);
44570 }
44571 {
44572 PyThreadState* __tstate = wxPyBeginAllowThreads();
44573 wxMenuItem_SetOwnerDrawn(arg1,arg2);
44574 wxPyEndAllowThreads(__tstate);
44575 if (PyErr_Occurred()) SWIG_fail;
44576 }
44577 resultobj = SWIG_Py_Void();
44578 return resultobj;
44579 fail:
44580 return NULL;
44581 }
44582
44583
44584 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44585 PyObject *resultobj = 0;
44586 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44587 void *argp1 = 0 ;
44588 int res1 = 0 ;
44589 PyObject *swig_obj[1] ;
44590
44591 if (!args) SWIG_fail;
44592 swig_obj[0] = args;
44593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44594 if (!SWIG_IsOK(res1)) {
44595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44596 }
44597 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44598 {
44599 PyThreadState* __tstate = wxPyBeginAllowThreads();
44600 wxMenuItem_ResetOwnerDrawn(arg1);
44601 wxPyEndAllowThreads(__tstate);
44602 if (PyErr_Occurred()) SWIG_fail;
44603 }
44604 resultobj = SWIG_Py_Void();
44605 return resultobj;
44606 fail:
44607 return NULL;
44608 }
44609
44610
44611 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44612 PyObject *obj;
44613 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44614 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
44615 return SWIG_Py_Void();
44616 }
44617
44618 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44619 return SWIG_Python_InitShadowInstance(args);
44620 }
44621
44622 SWIGINTERN int ControlNameStr_set(PyObject *) {
44623 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
44624 return 1;
44625 }
44626
44627
44628 SWIGINTERN PyObject *ControlNameStr_get(void) {
44629 PyObject *pyobj = 0;
44630
44631 {
44632 #if wxUSE_UNICODE
44633 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
44634 #else
44635 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
44636 #endif
44637 }
44638 return pyobj;
44639 }
44640
44641
44642 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44643 PyObject *resultobj = 0;
44644 wxWindow *arg1 = (wxWindow *) 0 ;
44645 int arg2 = (int) -1 ;
44646 wxPoint const &arg3_defvalue = wxDefaultPosition ;
44647 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
44648 wxSize const &arg4_defvalue = wxDefaultSize ;
44649 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
44650 long arg5 = (long) 0 ;
44651 wxValidator const &arg6_defvalue = wxDefaultValidator ;
44652 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
44653 wxString const &arg7_defvalue = wxPyControlNameStr ;
44654 wxString *arg7 = (wxString *) &arg7_defvalue ;
44655 wxControl *result = 0 ;
44656 void *argp1 = 0 ;
44657 int res1 = 0 ;
44658 int val2 ;
44659 int ecode2 = 0 ;
44660 wxPoint temp3 ;
44661 wxSize temp4 ;
44662 long val5 ;
44663 int ecode5 = 0 ;
44664 void *argp6 = 0 ;
44665 int res6 = 0 ;
44666 bool temp7 = false ;
44667 PyObject * obj0 = 0 ;
44668 PyObject * obj1 = 0 ;
44669 PyObject * obj2 = 0 ;
44670 PyObject * obj3 = 0 ;
44671 PyObject * obj4 = 0 ;
44672 PyObject * obj5 = 0 ;
44673 PyObject * obj6 = 0 ;
44674 char * kwnames[] = {
44675 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
44676 };
44677
44678 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
44679 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
44680 if (!SWIG_IsOK(res1)) {
44681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
44682 }
44683 arg1 = reinterpret_cast< wxWindow * >(argp1);
44684 if (obj1) {
44685 ecode2 = SWIG_AsVal_int(obj1, &val2);
44686 if (!SWIG_IsOK(ecode2)) {
44687 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
44688 }
44689 arg2 = static_cast< int >(val2);
44690 }
44691 if (obj2) {
44692 {
44693 arg3 = &temp3;
44694 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
44695 }
44696 }
44697 if (obj3) {
44698 {
44699 arg4 = &temp4;
44700 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
44701 }
44702 }
44703 if (obj4) {
44704 ecode5 = SWIG_AsVal_long(obj4, &val5);
44705 if (!SWIG_IsOK(ecode5)) {
44706 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
44707 }
44708 arg5 = static_cast< long >(val5);
44709 }
44710 if (obj5) {
44711 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
44712 if (!SWIG_IsOK(res6)) {
44713 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
44714 }
44715 if (!argp6) {
44716 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
44717 }
44718 arg6 = reinterpret_cast< wxValidator * >(argp6);
44719 }
44720 if (obj6) {
44721 {
44722 arg7 = wxString_in_helper(obj6);
44723 if (arg7 == NULL) SWIG_fail;
44724 temp7 = true;
44725 }
44726 }
44727 {
44728 if (!wxPyCheckForApp()) SWIG_fail;
44729 PyThreadState* __tstate = wxPyBeginAllowThreads();
44730 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
44731 wxPyEndAllowThreads(__tstate);
44732 if (PyErr_Occurred()) SWIG_fail;
44733 }
44734 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
44735 {
44736 if (temp7)
44737 delete arg7;
44738 }
44739 return resultobj;
44740 fail:
44741 {
44742 if (temp7)
44743 delete arg7;
44744 }
44745 return NULL;
44746 }
44747
44748
44749 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44750 PyObject *resultobj = 0;
44751 wxControl *result = 0 ;
44752
44753 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
44754 {
44755 if (!wxPyCheckForApp()) SWIG_fail;
44756 PyThreadState* __tstate = wxPyBeginAllowThreads();
44757 result = (wxControl *)new wxControl();
44758 wxPyEndAllowThreads(__tstate);
44759 if (PyErr_Occurred()) SWIG_fail;
44760 }
44761 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
44762 return resultobj;
44763 fail:
44764 return NULL;
44765 }
44766
44767
44768 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44769 PyObject *resultobj = 0;
44770 wxControl *arg1 = (wxControl *) 0 ;
44771 wxWindow *arg2 = (wxWindow *) 0 ;
44772 int arg3 = (int) -1 ;
44773 wxPoint const &arg4_defvalue = wxDefaultPosition ;
44774 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
44775 wxSize const &arg5_defvalue = wxDefaultSize ;
44776 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
44777 long arg6 = (long) 0 ;
44778 wxValidator const &arg7_defvalue = wxDefaultValidator ;
44779 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
44780 wxString const &arg8_defvalue = wxPyControlNameStr ;
44781 wxString *arg8 = (wxString *) &arg8_defvalue ;
44782 bool result;
44783 void *argp1 = 0 ;
44784 int res1 = 0 ;
44785 void *argp2 = 0 ;
44786 int res2 = 0 ;
44787 int val3 ;
44788 int ecode3 = 0 ;
44789 wxPoint temp4 ;
44790 wxSize temp5 ;
44791 long val6 ;
44792 int ecode6 = 0 ;
44793 void *argp7 = 0 ;
44794 int res7 = 0 ;
44795 bool temp8 = false ;
44796 PyObject * obj0 = 0 ;
44797 PyObject * obj1 = 0 ;
44798 PyObject * obj2 = 0 ;
44799 PyObject * obj3 = 0 ;
44800 PyObject * obj4 = 0 ;
44801 PyObject * obj5 = 0 ;
44802 PyObject * obj6 = 0 ;
44803 PyObject * obj7 = 0 ;
44804 char * kwnames[] = {
44805 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
44806 };
44807
44808 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
44809 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44810 if (!SWIG_IsOK(res1)) {
44811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
44812 }
44813 arg1 = reinterpret_cast< wxControl * >(argp1);
44814 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
44815 if (!SWIG_IsOK(res2)) {
44816 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
44817 }
44818 arg2 = reinterpret_cast< wxWindow * >(argp2);
44819 if (obj2) {
44820 ecode3 = SWIG_AsVal_int(obj2, &val3);
44821 if (!SWIG_IsOK(ecode3)) {
44822 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
44823 }
44824 arg3 = static_cast< int >(val3);
44825 }
44826 if (obj3) {
44827 {
44828 arg4 = &temp4;
44829 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
44830 }
44831 }
44832 if (obj4) {
44833 {
44834 arg5 = &temp5;
44835 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
44836 }
44837 }
44838 if (obj5) {
44839 ecode6 = SWIG_AsVal_long(obj5, &val6);
44840 if (!SWIG_IsOK(ecode6)) {
44841 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
44842 }
44843 arg6 = static_cast< long >(val6);
44844 }
44845 if (obj6) {
44846 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
44847 if (!SWIG_IsOK(res7)) {
44848 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
44849 }
44850 if (!argp7) {
44851 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
44852 }
44853 arg7 = reinterpret_cast< wxValidator * >(argp7);
44854 }
44855 if (obj7) {
44856 {
44857 arg8 = wxString_in_helper(obj7);
44858 if (arg8 == NULL) SWIG_fail;
44859 temp8 = true;
44860 }
44861 }
44862 {
44863 PyThreadState* __tstate = wxPyBeginAllowThreads();
44864 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
44865 wxPyEndAllowThreads(__tstate);
44866 if (PyErr_Occurred()) SWIG_fail;
44867 }
44868 {
44869 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44870 }
44871 {
44872 if (temp8)
44873 delete arg8;
44874 }
44875 return resultobj;
44876 fail:
44877 {
44878 if (temp8)
44879 delete arg8;
44880 }
44881 return NULL;
44882 }
44883
44884
44885 SWIGINTERN PyObject *_wrap_Control_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44886 PyObject *resultobj = 0;
44887 wxControl *arg1 = (wxControl *) 0 ;
44888 int result;
44889 void *argp1 = 0 ;
44890 int res1 = 0 ;
44891 PyObject *swig_obj[1] ;
44892
44893 if (!args) SWIG_fail;
44894 swig_obj[0] = args;
44895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44896 if (!SWIG_IsOK(res1)) {
44897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetAlignment" "', expected argument " "1"" of type '" "wxControl const *""'");
44898 }
44899 arg1 = reinterpret_cast< wxControl * >(argp1);
44900 {
44901 PyThreadState* __tstate = wxPyBeginAllowThreads();
44902 result = (int)((wxControl const *)arg1)->GetAlignment();
44903 wxPyEndAllowThreads(__tstate);
44904 if (PyErr_Occurred()) SWIG_fail;
44905 }
44906 resultobj = SWIG_From_int(static_cast< int >(result));
44907 return resultobj;
44908 fail:
44909 return NULL;
44910 }
44911
44912
44913 SWIGINTERN PyObject *_wrap_Control_GetLabelText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44914 PyObject *resultobj = 0;
44915 wxControl *arg1 = (wxControl *) 0 ;
44916 wxString result;
44917 void *argp1 = 0 ;
44918 int res1 = 0 ;
44919 PyObject *swig_obj[1] ;
44920
44921 if (!args) SWIG_fail;
44922 swig_obj[0] = args;
44923 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44924 if (!SWIG_IsOK(res1)) {
44925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabelText" "', expected argument " "1"" of type '" "wxControl const *""'");
44926 }
44927 arg1 = reinterpret_cast< wxControl * >(argp1);
44928 {
44929 PyThreadState* __tstate = wxPyBeginAllowThreads();
44930 result = ((wxControl const *)arg1)->GetLabelText();
44931 wxPyEndAllowThreads(__tstate);
44932 if (PyErr_Occurred()) SWIG_fail;
44933 }
44934 {
44935 #if wxUSE_UNICODE
44936 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44937 #else
44938 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44939 #endif
44940 }
44941 return resultobj;
44942 fail:
44943 return NULL;
44944 }
44945
44946
44947 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44948 PyObject *resultobj = 0;
44949 wxControl *arg1 = (wxControl *) 0 ;
44950 wxCommandEvent *arg2 = 0 ;
44951 void *argp1 = 0 ;
44952 int res1 = 0 ;
44953 void *argp2 = 0 ;
44954 int res2 = 0 ;
44955 PyObject * obj0 = 0 ;
44956 PyObject * obj1 = 0 ;
44957 char * kwnames[] = {
44958 (char *) "self",(char *) "event", NULL
44959 };
44960
44961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
44962 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44963 if (!SWIG_IsOK(res1)) {
44964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
44965 }
44966 arg1 = reinterpret_cast< wxControl * >(argp1);
44967 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
44968 if (!SWIG_IsOK(res2)) {
44969 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
44970 }
44971 if (!argp2) {
44972 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
44973 }
44974 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
44975 {
44976 PyThreadState* __tstate = wxPyBeginAllowThreads();
44977 (arg1)->Command(*arg2);
44978 wxPyEndAllowThreads(__tstate);
44979 if (PyErr_Occurred()) SWIG_fail;
44980 }
44981 resultobj = SWIG_Py_Void();
44982 return resultobj;
44983 fail:
44984 return NULL;
44985 }
44986
44987
44988 SWIGINTERN PyObject *_wrap_Control_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44989 PyObject *resultobj = 0;
44990 wxControl *arg1 = (wxControl *) 0 ;
44991 wxString 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_wxControl, 0 | 0 );
44999 if (!SWIG_IsOK(res1)) {
45000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabel" "', expected argument " "1"" of type '" "wxControl *""'");
45001 }
45002 arg1 = reinterpret_cast< wxControl * >(argp1);
45003 {
45004 PyThreadState* __tstate = wxPyBeginAllowThreads();
45005 result = (arg1)->GetLabel();
45006 wxPyEndAllowThreads(__tstate);
45007 if (PyErr_Occurred()) SWIG_fail;
45008 }
45009 {
45010 #if wxUSE_UNICODE
45011 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45012 #else
45013 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45014 #endif
45015 }
45016 return resultobj;
45017 fail:
45018 return NULL;
45019 }
45020
45021
45022 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45023 PyObject *resultobj = 0;
45024 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
45025 SwigValueWrapper<wxVisualAttributes > result;
45026 int val1 ;
45027 int ecode1 = 0 ;
45028 PyObject * obj0 = 0 ;
45029 char * kwnames[] = {
45030 (char *) "variant", NULL
45031 };
45032
45033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
45034 if (obj0) {
45035 ecode1 = SWIG_AsVal_int(obj0, &val1);
45036 if (!SWIG_IsOK(ecode1)) {
45037 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
45038 }
45039 arg1 = static_cast< wxWindowVariant >(val1);
45040 }
45041 {
45042 if (!wxPyCheckForApp()) SWIG_fail;
45043 PyThreadState* __tstate = wxPyBeginAllowThreads();
45044 result = wxControl::GetClassDefaultAttributes(arg1);
45045 wxPyEndAllowThreads(__tstate);
45046 if (PyErr_Occurred()) SWIG_fail;
45047 }
45048 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
45049 return resultobj;
45050 fail:
45051 return NULL;
45052 }
45053
45054
45055 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45056 PyObject *obj;
45057 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45058 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
45059 return SWIG_Py_Void();
45060 }
45061
45062 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45063 return SWIG_Python_InitShadowInstance(args);
45064 }
45065
45066 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45067 PyObject *resultobj = 0;
45068 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45069 wxString *arg2 = 0 ;
45070 PyObject *arg3 = (PyObject *) NULL ;
45071 int result;
45072 void *argp1 = 0 ;
45073 int res1 = 0 ;
45074 bool temp2 = false ;
45075 PyObject * obj0 = 0 ;
45076 PyObject * obj1 = 0 ;
45077 PyObject * obj2 = 0 ;
45078 char * kwnames[] = {
45079 (char *) "self",(char *) "item",(char *) "clientData", NULL
45080 };
45081
45082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45083 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45084 if (!SWIG_IsOK(res1)) {
45085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45086 }
45087 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45088 {
45089 arg2 = wxString_in_helper(obj1);
45090 if (arg2 == NULL) SWIG_fail;
45091 temp2 = true;
45092 }
45093 if (obj2) {
45094 arg3 = obj2;
45095 }
45096 {
45097 PyThreadState* __tstate = wxPyBeginAllowThreads();
45098 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
45099 wxPyEndAllowThreads(__tstate);
45100 if (PyErr_Occurred()) SWIG_fail;
45101 }
45102 resultobj = SWIG_From_int(static_cast< int >(result));
45103 {
45104 if (temp2)
45105 delete arg2;
45106 }
45107 return resultobj;
45108 fail:
45109 {
45110 if (temp2)
45111 delete arg2;
45112 }
45113 return NULL;
45114 }
45115
45116
45117 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45118 PyObject *resultobj = 0;
45119 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45120 wxArrayString *arg2 = 0 ;
45121 void *argp1 = 0 ;
45122 int res1 = 0 ;
45123 bool temp2 = false ;
45124 PyObject * obj0 = 0 ;
45125 PyObject * obj1 = 0 ;
45126 char * kwnames[] = {
45127 (char *) "self",(char *) "strings", NULL
45128 };
45129
45130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
45131 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45132 if (!SWIG_IsOK(res1)) {
45133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45134 }
45135 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45136 {
45137 if (! PySequence_Check(obj1)) {
45138 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
45139 SWIG_fail;
45140 }
45141 arg2 = new wxArrayString;
45142 temp2 = true;
45143 int i, len=PySequence_Length(obj1);
45144 for (i=0; i<len; i++) {
45145 PyObject* item = PySequence_GetItem(obj1, i);
45146 wxString* s = wxString_in_helper(item);
45147 if (PyErr_Occurred()) SWIG_fail;
45148 arg2->Add(*s);
45149 delete s;
45150 Py_DECREF(item);
45151 }
45152 }
45153 {
45154 PyThreadState* __tstate = wxPyBeginAllowThreads();
45155 (arg1)->Append((wxArrayString const &)*arg2);
45156 wxPyEndAllowThreads(__tstate);
45157 if (PyErr_Occurred()) SWIG_fail;
45158 }
45159 resultobj = SWIG_Py_Void();
45160 {
45161 if (temp2) delete arg2;
45162 }
45163 return resultobj;
45164 fail:
45165 {
45166 if (temp2) delete arg2;
45167 }
45168 return NULL;
45169 }
45170
45171
45172 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45173 PyObject *resultobj = 0;
45174 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45175 wxString *arg2 = 0 ;
45176 unsigned int arg3 ;
45177 PyObject *arg4 = (PyObject *) NULL ;
45178 int result;
45179 void *argp1 = 0 ;
45180 int res1 = 0 ;
45181 bool temp2 = false ;
45182 unsigned int val3 ;
45183 int ecode3 = 0 ;
45184 PyObject * obj0 = 0 ;
45185 PyObject * obj1 = 0 ;
45186 PyObject * obj2 = 0 ;
45187 PyObject * obj3 = 0 ;
45188 char * kwnames[] = {
45189 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
45190 };
45191
45192 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
45193 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45194 if (!SWIG_IsOK(res1)) {
45195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45196 }
45197 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45198 {
45199 arg2 = wxString_in_helper(obj1);
45200 if (arg2 == NULL) SWIG_fail;
45201 temp2 = true;
45202 }
45203 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
45204 if (!SWIG_IsOK(ecode3)) {
45205 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "unsigned int""'");
45206 }
45207 arg3 = static_cast< unsigned int >(val3);
45208 if (obj3) {
45209 arg4 = obj3;
45210 }
45211 {
45212 PyThreadState* __tstate = wxPyBeginAllowThreads();
45213 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
45214 wxPyEndAllowThreads(__tstate);
45215 if (PyErr_Occurred()) SWIG_fail;
45216 }
45217 resultobj = SWIG_From_int(static_cast< int >(result));
45218 {
45219 if (temp2)
45220 delete arg2;
45221 }
45222 return resultobj;
45223 fail:
45224 {
45225 if (temp2)
45226 delete arg2;
45227 }
45228 return NULL;
45229 }
45230
45231
45232 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45233 PyObject *resultobj = 0;
45234 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45235 void *argp1 = 0 ;
45236 int res1 = 0 ;
45237 PyObject *swig_obj[1] ;
45238
45239 if (!args) SWIG_fail;
45240 swig_obj[0] = args;
45241 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45242 if (!SWIG_IsOK(res1)) {
45243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45244 }
45245 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45246 {
45247 PyThreadState* __tstate = wxPyBeginAllowThreads();
45248 (arg1)->Clear();
45249 wxPyEndAllowThreads(__tstate);
45250 if (PyErr_Occurred()) SWIG_fail;
45251 }
45252 resultobj = SWIG_Py_Void();
45253 return resultobj;
45254 fail:
45255 return NULL;
45256 }
45257
45258
45259 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45260 PyObject *resultobj = 0;
45261 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45262 unsigned int arg2 ;
45263 void *argp1 = 0 ;
45264 int res1 = 0 ;
45265 unsigned int val2 ;
45266 int ecode2 = 0 ;
45267 PyObject * obj0 = 0 ;
45268 PyObject * obj1 = 0 ;
45269 char * kwnames[] = {
45270 (char *) "self",(char *) "n", NULL
45271 };
45272
45273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
45274 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45275 if (!SWIG_IsOK(res1)) {
45276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45277 }
45278 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45279 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45280 if (!SWIG_IsOK(ecode2)) {
45281 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "unsigned int""'");
45282 }
45283 arg2 = static_cast< unsigned int >(val2);
45284 {
45285 PyThreadState* __tstate = wxPyBeginAllowThreads();
45286 (arg1)->Delete(arg2);
45287 wxPyEndAllowThreads(__tstate);
45288 if (PyErr_Occurred()) SWIG_fail;
45289 }
45290 resultobj = SWIG_Py_Void();
45291 return resultobj;
45292 fail:
45293 return NULL;
45294 }
45295
45296
45297 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45298 PyObject *resultobj = 0;
45299 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45300 unsigned int arg2 ;
45301 PyObject *result = 0 ;
45302 void *argp1 = 0 ;
45303 int res1 = 0 ;
45304 unsigned int val2 ;
45305 int ecode2 = 0 ;
45306 PyObject * obj0 = 0 ;
45307 PyObject * obj1 = 0 ;
45308 char * kwnames[] = {
45309 (char *) "self",(char *) "n", NULL
45310 };
45311
45312 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
45313 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45314 if (!SWIG_IsOK(res1)) {
45315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45316 }
45317 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45318 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45319 if (!SWIG_IsOK(ecode2)) {
45320 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
45321 }
45322 arg2 = static_cast< unsigned int >(val2);
45323 {
45324 PyThreadState* __tstate = wxPyBeginAllowThreads();
45325 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
45326 wxPyEndAllowThreads(__tstate);
45327 if (PyErr_Occurred()) SWIG_fail;
45328 }
45329 resultobj = result;
45330 return resultobj;
45331 fail:
45332 return NULL;
45333 }
45334
45335
45336 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45337 PyObject *resultobj = 0;
45338 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45339 unsigned int arg2 ;
45340 PyObject *arg3 = (PyObject *) 0 ;
45341 void *argp1 = 0 ;
45342 int res1 = 0 ;
45343 unsigned int val2 ;
45344 int ecode2 = 0 ;
45345 PyObject * obj0 = 0 ;
45346 PyObject * obj1 = 0 ;
45347 PyObject * obj2 = 0 ;
45348 char * kwnames[] = {
45349 (char *) "self",(char *) "n",(char *) "clientData", NULL
45350 };
45351
45352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45353 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45354 if (!SWIG_IsOK(res1)) {
45355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45356 }
45357 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45358 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45359 if (!SWIG_IsOK(ecode2)) {
45360 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
45361 }
45362 arg2 = static_cast< unsigned int >(val2);
45363 arg3 = obj2;
45364 {
45365 PyThreadState* __tstate = wxPyBeginAllowThreads();
45366 wxItemContainer_SetClientData(arg1,arg2,arg3);
45367 wxPyEndAllowThreads(__tstate);
45368 if (PyErr_Occurred()) SWIG_fail;
45369 }
45370 resultobj = SWIG_Py_Void();
45371 return resultobj;
45372 fail:
45373 return NULL;
45374 }
45375
45376
45377 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45378 PyObject *resultobj = 0;
45379 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45380 unsigned int result;
45381 void *argp1 = 0 ;
45382 int res1 = 0 ;
45383 PyObject *swig_obj[1] ;
45384
45385 if (!args) SWIG_fail;
45386 swig_obj[0] = args;
45387 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45388 if (!SWIG_IsOK(res1)) {
45389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45390 }
45391 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45392 {
45393 PyThreadState* __tstate = wxPyBeginAllowThreads();
45394 result = (unsigned int)((wxItemContainer const *)arg1)->GetCount();
45395 wxPyEndAllowThreads(__tstate);
45396 if (PyErr_Occurred()) SWIG_fail;
45397 }
45398 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
45399 return resultobj;
45400 fail:
45401 return NULL;
45402 }
45403
45404
45405 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45406 PyObject *resultobj = 0;
45407 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45408 bool result;
45409 void *argp1 = 0 ;
45410 int res1 = 0 ;
45411 PyObject *swig_obj[1] ;
45412
45413 if (!args) SWIG_fail;
45414 swig_obj[0] = args;
45415 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45416 if (!SWIG_IsOK(res1)) {
45417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45418 }
45419 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45420 {
45421 PyThreadState* __tstate = wxPyBeginAllowThreads();
45422 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
45423 wxPyEndAllowThreads(__tstate);
45424 if (PyErr_Occurred()) SWIG_fail;
45425 }
45426 {
45427 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45428 }
45429 return resultobj;
45430 fail:
45431 return NULL;
45432 }
45433
45434
45435 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45436 PyObject *resultobj = 0;
45437 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45438 unsigned int arg2 ;
45439 wxString result;
45440 void *argp1 = 0 ;
45441 int res1 = 0 ;
45442 unsigned int val2 ;
45443 int ecode2 = 0 ;
45444 PyObject * obj0 = 0 ;
45445 PyObject * obj1 = 0 ;
45446 char * kwnames[] = {
45447 (char *) "self",(char *) "n", NULL
45448 };
45449
45450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
45451 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45452 if (!SWIG_IsOK(res1)) {
45453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45454 }
45455 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45456 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45457 if (!SWIG_IsOK(ecode2)) {
45458 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "unsigned int""'");
45459 }
45460 arg2 = static_cast< unsigned int >(val2);
45461 {
45462 PyThreadState* __tstate = wxPyBeginAllowThreads();
45463 result = ((wxItemContainer const *)arg1)->GetString(arg2);
45464 wxPyEndAllowThreads(__tstate);
45465 if (PyErr_Occurred()) SWIG_fail;
45466 }
45467 {
45468 #if wxUSE_UNICODE
45469 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45470 #else
45471 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45472 #endif
45473 }
45474 return resultobj;
45475 fail:
45476 return NULL;
45477 }
45478
45479
45480 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45481 PyObject *resultobj = 0;
45482 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45483 wxArrayString result;
45484 void *argp1 = 0 ;
45485 int res1 = 0 ;
45486 PyObject *swig_obj[1] ;
45487
45488 if (!args) SWIG_fail;
45489 swig_obj[0] = args;
45490 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45491 if (!SWIG_IsOK(res1)) {
45492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45493 }
45494 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45495 {
45496 PyThreadState* __tstate = wxPyBeginAllowThreads();
45497 result = ((wxItemContainer const *)arg1)->GetStrings();
45498 wxPyEndAllowThreads(__tstate);
45499 if (PyErr_Occurred()) SWIG_fail;
45500 }
45501 {
45502 resultobj = wxArrayString2PyList_helper(result);
45503 }
45504 return resultobj;
45505 fail:
45506 return NULL;
45507 }
45508
45509
45510 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45511 PyObject *resultobj = 0;
45512 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45513 unsigned int arg2 ;
45514 wxString *arg3 = 0 ;
45515 void *argp1 = 0 ;
45516 int res1 = 0 ;
45517 unsigned int val2 ;
45518 int ecode2 = 0 ;
45519 bool temp3 = false ;
45520 PyObject * obj0 = 0 ;
45521 PyObject * obj1 = 0 ;
45522 PyObject * obj2 = 0 ;
45523 char * kwnames[] = {
45524 (char *) "self",(char *) "n",(char *) "s", NULL
45525 };
45526
45527 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45528 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45529 if (!SWIG_IsOK(res1)) {
45530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45531 }
45532 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45533 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45534 if (!SWIG_IsOK(ecode2)) {
45535 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "unsigned int""'");
45536 }
45537 arg2 = static_cast< unsigned int >(val2);
45538 {
45539 arg3 = wxString_in_helper(obj2);
45540 if (arg3 == NULL) SWIG_fail;
45541 temp3 = true;
45542 }
45543 {
45544 PyThreadState* __tstate = wxPyBeginAllowThreads();
45545 (arg1)->SetString(arg2,(wxString const &)*arg3);
45546 wxPyEndAllowThreads(__tstate);
45547 if (PyErr_Occurred()) SWIG_fail;
45548 }
45549 resultobj = SWIG_Py_Void();
45550 {
45551 if (temp3)
45552 delete arg3;
45553 }
45554 return resultobj;
45555 fail:
45556 {
45557 if (temp3)
45558 delete arg3;
45559 }
45560 return NULL;
45561 }
45562
45563
45564 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45565 PyObject *resultobj = 0;
45566 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45567 wxString *arg2 = 0 ;
45568 int result;
45569 void *argp1 = 0 ;
45570 int res1 = 0 ;
45571 bool temp2 = false ;
45572 PyObject * obj0 = 0 ;
45573 PyObject * obj1 = 0 ;
45574 char * kwnames[] = {
45575 (char *) "self",(char *) "s", NULL
45576 };
45577
45578 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
45579 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45580 if (!SWIG_IsOK(res1)) {
45581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45582 }
45583 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45584 {
45585 arg2 = wxString_in_helper(obj1);
45586 if (arg2 == NULL) SWIG_fail;
45587 temp2 = true;
45588 }
45589 {
45590 PyThreadState* __tstate = wxPyBeginAllowThreads();
45591 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
45592 wxPyEndAllowThreads(__tstate);
45593 if (PyErr_Occurred()) SWIG_fail;
45594 }
45595 resultobj = SWIG_From_int(static_cast< int >(result));
45596 {
45597 if (temp2)
45598 delete arg2;
45599 }
45600 return resultobj;
45601 fail:
45602 {
45603 if (temp2)
45604 delete arg2;
45605 }
45606 return NULL;
45607 }
45608
45609
45610 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45611 PyObject *resultobj = 0;
45612 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45613 int arg2 ;
45614 void *argp1 = 0 ;
45615 int res1 = 0 ;
45616 int val2 ;
45617 int ecode2 = 0 ;
45618 PyObject * obj0 = 0 ;
45619 PyObject * obj1 = 0 ;
45620 char * kwnames[] = {
45621 (char *) "self",(char *) "n", NULL
45622 };
45623
45624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
45625 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45626 if (!SWIG_IsOK(res1)) {
45627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45628 }
45629 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45630 ecode2 = SWIG_AsVal_int(obj1, &val2);
45631 if (!SWIG_IsOK(ecode2)) {
45632 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
45633 }
45634 arg2 = static_cast< int >(val2);
45635 {
45636 PyThreadState* __tstate = wxPyBeginAllowThreads();
45637 (arg1)->SetSelection(arg2);
45638 wxPyEndAllowThreads(__tstate);
45639 if (PyErr_Occurred()) SWIG_fail;
45640 }
45641 resultobj = SWIG_Py_Void();
45642 return resultobj;
45643 fail:
45644 return NULL;
45645 }
45646
45647
45648 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45649 PyObject *resultobj = 0;
45650 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45651 int result;
45652 void *argp1 = 0 ;
45653 int res1 = 0 ;
45654 PyObject *swig_obj[1] ;
45655
45656 if (!args) SWIG_fail;
45657 swig_obj[0] = args;
45658 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45659 if (!SWIG_IsOK(res1)) {
45660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45661 }
45662 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45663 {
45664 PyThreadState* __tstate = wxPyBeginAllowThreads();
45665 result = (int)((wxItemContainer const *)arg1)->GetSelection();
45666 wxPyEndAllowThreads(__tstate);
45667 if (PyErr_Occurred()) SWIG_fail;
45668 }
45669 resultobj = SWIG_From_int(static_cast< int >(result));
45670 return resultobj;
45671 fail:
45672 return NULL;
45673 }
45674
45675
45676 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45677 PyObject *resultobj = 0;
45678 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45679 wxString *arg2 = 0 ;
45680 bool result;
45681 void *argp1 = 0 ;
45682 int res1 = 0 ;
45683 bool temp2 = false ;
45684 PyObject * obj0 = 0 ;
45685 PyObject * obj1 = 0 ;
45686 char * kwnames[] = {
45687 (char *) "self",(char *) "s", NULL
45688 };
45689
45690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
45691 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45692 if (!SWIG_IsOK(res1)) {
45693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45694 }
45695 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45696 {
45697 arg2 = wxString_in_helper(obj1);
45698 if (arg2 == NULL) SWIG_fail;
45699 temp2 = true;
45700 }
45701 {
45702 PyThreadState* __tstate = wxPyBeginAllowThreads();
45703 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
45704 wxPyEndAllowThreads(__tstate);
45705 if (PyErr_Occurred()) SWIG_fail;
45706 }
45707 {
45708 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45709 }
45710 {
45711 if (temp2)
45712 delete arg2;
45713 }
45714 return resultobj;
45715 fail:
45716 {
45717 if (temp2)
45718 delete arg2;
45719 }
45720 return NULL;
45721 }
45722
45723
45724 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45725 PyObject *resultobj = 0;
45726 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45727 wxString result;
45728 void *argp1 = 0 ;
45729 int res1 = 0 ;
45730 PyObject *swig_obj[1] ;
45731
45732 if (!args) SWIG_fail;
45733 swig_obj[0] = args;
45734 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45735 if (!SWIG_IsOK(res1)) {
45736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45737 }
45738 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45739 {
45740 PyThreadState* __tstate = wxPyBeginAllowThreads();
45741 result = ((wxItemContainer const *)arg1)->GetStringSelection();
45742 wxPyEndAllowThreads(__tstate);
45743 if (PyErr_Occurred()) SWIG_fail;
45744 }
45745 {
45746 #if wxUSE_UNICODE
45747 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45748 #else
45749 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45750 #endif
45751 }
45752 return resultobj;
45753 fail:
45754 return NULL;
45755 }
45756
45757
45758 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45759 PyObject *resultobj = 0;
45760 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45761 int arg2 ;
45762 void *argp1 = 0 ;
45763 int res1 = 0 ;
45764 int val2 ;
45765 int ecode2 = 0 ;
45766 PyObject * obj0 = 0 ;
45767 PyObject * obj1 = 0 ;
45768 char * kwnames[] = {
45769 (char *) "self",(char *) "n", NULL
45770 };
45771
45772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
45773 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45774 if (!SWIG_IsOK(res1)) {
45775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45776 }
45777 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45778 ecode2 = SWIG_AsVal_int(obj1, &val2);
45779 if (!SWIG_IsOK(ecode2)) {
45780 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
45781 }
45782 arg2 = static_cast< int >(val2);
45783 {
45784 PyThreadState* __tstate = wxPyBeginAllowThreads();
45785 (arg1)->Select(arg2);
45786 wxPyEndAllowThreads(__tstate);
45787 if (PyErr_Occurred()) SWIG_fail;
45788 }
45789 resultobj = SWIG_Py_Void();
45790 return resultobj;
45791 fail:
45792 return NULL;
45793 }
45794
45795
45796 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45797 PyObject *obj;
45798 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45799 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
45800 return SWIG_Py_Void();
45801 }
45802
45803 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45804 PyObject *obj;
45805 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45806 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
45807 return SWIG_Py_Void();
45808 }
45809
45810 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45811 PyObject *resultobj = 0;
45812 wxSizerItem *result = 0 ;
45813
45814 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
45815 {
45816 PyThreadState* __tstate = wxPyBeginAllowThreads();
45817 result = (wxSizerItem *)new wxSizerItem();
45818 wxPyEndAllowThreads(__tstate);
45819 if (PyErr_Occurred()) SWIG_fail;
45820 }
45821 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
45822 return resultobj;
45823 fail:
45824 return NULL;
45825 }
45826
45827
45828 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45829 PyObject *resultobj = 0;
45830 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45831 void *argp1 = 0 ;
45832 int res1 = 0 ;
45833 PyObject *swig_obj[1] ;
45834
45835 if (!args) SWIG_fail;
45836 swig_obj[0] = args;
45837 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
45838 if (!SWIG_IsOK(res1)) {
45839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45840 }
45841 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45842 {
45843 PyThreadState* __tstate = wxPyBeginAllowThreads();
45844 delete arg1;
45845
45846 wxPyEndAllowThreads(__tstate);
45847 if (PyErr_Occurred()) SWIG_fail;
45848 }
45849 resultobj = SWIG_Py_Void();
45850 return resultobj;
45851 fail:
45852 return NULL;
45853 }
45854
45855
45856 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45857 PyObject *resultobj = 0;
45858 wxWindow *arg1 = (wxWindow *) 0 ;
45859 int arg2 ;
45860 int arg3 ;
45861 int arg4 ;
45862 PyObject *arg5 = (PyObject *) NULL ;
45863 wxSizerItem *result = 0 ;
45864 void *argp1 = 0 ;
45865 int res1 = 0 ;
45866 int val2 ;
45867 int ecode2 = 0 ;
45868 int val3 ;
45869 int ecode3 = 0 ;
45870 int val4 ;
45871 int ecode4 = 0 ;
45872 PyObject * obj0 = 0 ;
45873 PyObject * obj1 = 0 ;
45874 PyObject * obj2 = 0 ;
45875 PyObject * obj3 = 0 ;
45876 PyObject * obj4 = 0 ;
45877 char * kwnames[] = {
45878 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45879 };
45880
45881 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
45882 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
45883 if (!SWIG_IsOK(res1)) {
45884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
45885 }
45886 arg1 = reinterpret_cast< wxWindow * >(argp1);
45887 ecode2 = SWIG_AsVal_int(obj1, &val2);
45888 if (!SWIG_IsOK(ecode2)) {
45889 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
45890 }
45891 arg2 = static_cast< int >(val2);
45892 ecode3 = SWIG_AsVal_int(obj2, &val3);
45893 if (!SWIG_IsOK(ecode3)) {
45894 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
45895 }
45896 arg3 = static_cast< int >(val3);
45897 ecode4 = SWIG_AsVal_int(obj3, &val4);
45898 if (!SWIG_IsOK(ecode4)) {
45899 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
45900 }
45901 arg4 = static_cast< int >(val4);
45902 if (obj4) {
45903 arg5 = obj4;
45904 }
45905 {
45906 PyThreadState* __tstate = wxPyBeginAllowThreads();
45907 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
45908 wxPyEndAllowThreads(__tstate);
45909 if (PyErr_Occurred()) SWIG_fail;
45910 }
45911 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45912 return resultobj;
45913 fail:
45914 return NULL;
45915 }
45916
45917
45918 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45919 PyObject *resultobj = 0;
45920 int arg1 ;
45921 int arg2 ;
45922 int arg3 ;
45923 int arg4 ;
45924 int arg5 ;
45925 PyObject *arg6 = (PyObject *) NULL ;
45926 wxSizerItem *result = 0 ;
45927 int val1 ;
45928 int ecode1 = 0 ;
45929 int val2 ;
45930 int ecode2 = 0 ;
45931 int val3 ;
45932 int ecode3 = 0 ;
45933 int val4 ;
45934 int ecode4 = 0 ;
45935 int val5 ;
45936 int ecode5 = 0 ;
45937 PyObject * obj0 = 0 ;
45938 PyObject * obj1 = 0 ;
45939 PyObject * obj2 = 0 ;
45940 PyObject * obj3 = 0 ;
45941 PyObject * obj4 = 0 ;
45942 PyObject * obj5 = 0 ;
45943 char * kwnames[] = {
45944 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45945 };
45946
45947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
45948 ecode1 = SWIG_AsVal_int(obj0, &val1);
45949 if (!SWIG_IsOK(ecode1)) {
45950 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
45951 }
45952 arg1 = static_cast< int >(val1);
45953 ecode2 = SWIG_AsVal_int(obj1, &val2);
45954 if (!SWIG_IsOK(ecode2)) {
45955 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
45956 }
45957 arg2 = static_cast< int >(val2);
45958 ecode3 = SWIG_AsVal_int(obj2, &val3);
45959 if (!SWIG_IsOK(ecode3)) {
45960 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
45961 }
45962 arg3 = static_cast< int >(val3);
45963 ecode4 = SWIG_AsVal_int(obj3, &val4);
45964 if (!SWIG_IsOK(ecode4)) {
45965 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
45966 }
45967 arg4 = static_cast< int >(val4);
45968 ecode5 = SWIG_AsVal_int(obj4, &val5);
45969 if (!SWIG_IsOK(ecode5)) {
45970 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
45971 }
45972 arg5 = static_cast< int >(val5);
45973 if (obj5) {
45974 arg6 = obj5;
45975 }
45976 {
45977 PyThreadState* __tstate = wxPyBeginAllowThreads();
45978 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
45979 wxPyEndAllowThreads(__tstate);
45980 if (PyErr_Occurred()) SWIG_fail;
45981 }
45982 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45983 return resultobj;
45984 fail:
45985 return NULL;
45986 }
45987
45988
45989 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45990 PyObject *resultobj = 0;
45991 wxSizer *arg1 = (wxSizer *) 0 ;
45992 int arg2 ;
45993 int arg3 ;
45994 int arg4 ;
45995 PyObject *arg5 = (PyObject *) NULL ;
45996 wxSizerItem *result = 0 ;
45997 int res1 = 0 ;
45998 int val2 ;
45999 int ecode2 = 0 ;
46000 int val3 ;
46001 int ecode3 = 0 ;
46002 int val4 ;
46003 int ecode4 = 0 ;
46004 PyObject * obj0 = 0 ;
46005 PyObject * obj1 = 0 ;
46006 PyObject * obj2 = 0 ;
46007 PyObject * obj3 = 0 ;
46008 PyObject * obj4 = 0 ;
46009 char * kwnames[] = {
46010 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46011 };
46012
46013 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
46014 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46015 if (!SWIG_IsOK(res1)) {
46016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
46017 }
46018 ecode2 = SWIG_AsVal_int(obj1, &val2);
46019 if (!SWIG_IsOK(ecode2)) {
46020 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
46021 }
46022 arg2 = static_cast< int >(val2);
46023 ecode3 = SWIG_AsVal_int(obj2, &val3);
46024 if (!SWIG_IsOK(ecode3)) {
46025 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
46026 }
46027 arg3 = static_cast< int >(val3);
46028 ecode4 = SWIG_AsVal_int(obj3, &val4);
46029 if (!SWIG_IsOK(ecode4)) {
46030 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
46031 }
46032 arg4 = static_cast< int >(val4);
46033 if (obj4) {
46034 arg5 = obj4;
46035 }
46036 {
46037 PyThreadState* __tstate = wxPyBeginAllowThreads();
46038 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
46039 wxPyEndAllowThreads(__tstate);
46040 if (PyErr_Occurred()) SWIG_fail;
46041 }
46042 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
46043 return resultobj;
46044 fail:
46045 return NULL;
46046 }
46047
46048
46049 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46050 PyObject *resultobj = 0;
46051 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46052 void *argp1 = 0 ;
46053 int res1 = 0 ;
46054 PyObject *swig_obj[1] ;
46055
46056 if (!args) SWIG_fail;
46057 swig_obj[0] = args;
46058 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46059 if (!SWIG_IsOK(res1)) {
46060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46061 }
46062 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46063 {
46064 PyThreadState* __tstate = wxPyBeginAllowThreads();
46065 (arg1)->DeleteWindows();
46066 wxPyEndAllowThreads(__tstate);
46067 if (PyErr_Occurred()) SWIG_fail;
46068 }
46069 resultobj = SWIG_Py_Void();
46070 return resultobj;
46071 fail:
46072 return NULL;
46073 }
46074
46075
46076 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46077 PyObject *resultobj = 0;
46078 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46079 void *argp1 = 0 ;
46080 int res1 = 0 ;
46081 PyObject *swig_obj[1] ;
46082
46083 if (!args) SWIG_fail;
46084 swig_obj[0] = args;
46085 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46086 if (!SWIG_IsOK(res1)) {
46087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46088 }
46089 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46090 {
46091 PyThreadState* __tstate = wxPyBeginAllowThreads();
46092 (arg1)->DetachSizer();
46093 wxPyEndAllowThreads(__tstate);
46094 if (PyErr_Occurred()) SWIG_fail;
46095 }
46096 resultobj = SWIG_Py_Void();
46097 return resultobj;
46098 fail:
46099 return NULL;
46100 }
46101
46102
46103 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46104 PyObject *resultobj = 0;
46105 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46106 wxSize result;
46107 void *argp1 = 0 ;
46108 int res1 = 0 ;
46109 PyObject *swig_obj[1] ;
46110
46111 if (!args) SWIG_fail;
46112 swig_obj[0] = args;
46113 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46114 if (!SWIG_IsOK(res1)) {
46115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46116 }
46117 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46118 {
46119 PyThreadState* __tstate = wxPyBeginAllowThreads();
46120 result = (arg1)->GetSize();
46121 wxPyEndAllowThreads(__tstate);
46122 if (PyErr_Occurred()) SWIG_fail;
46123 }
46124 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46125 return resultobj;
46126 fail:
46127 return NULL;
46128 }
46129
46130
46131 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46132 PyObject *resultobj = 0;
46133 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46134 wxSize result;
46135 void *argp1 = 0 ;
46136 int res1 = 0 ;
46137 PyObject *swig_obj[1] ;
46138
46139 if (!args) SWIG_fail;
46140 swig_obj[0] = args;
46141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46142 if (!SWIG_IsOK(res1)) {
46143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46144 }
46145 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46146 {
46147 PyThreadState* __tstate = wxPyBeginAllowThreads();
46148 result = (arg1)->CalcMin();
46149 wxPyEndAllowThreads(__tstate);
46150 if (PyErr_Occurred()) SWIG_fail;
46151 }
46152 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46153 return resultobj;
46154 fail:
46155 return NULL;
46156 }
46157
46158
46159 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46160 PyObject *resultobj = 0;
46161 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46162 wxPoint *arg2 = 0 ;
46163 wxSize *arg3 = 0 ;
46164 void *argp1 = 0 ;
46165 int res1 = 0 ;
46166 wxPoint temp2 ;
46167 wxSize temp3 ;
46168 PyObject * obj0 = 0 ;
46169 PyObject * obj1 = 0 ;
46170 PyObject * obj2 = 0 ;
46171 char * kwnames[] = {
46172 (char *) "self",(char *) "pos",(char *) "size", NULL
46173 };
46174
46175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46177 if (!SWIG_IsOK(res1)) {
46178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46179 }
46180 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46181 {
46182 arg2 = &temp2;
46183 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
46184 }
46185 {
46186 arg3 = &temp3;
46187 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
46188 }
46189 {
46190 PyThreadState* __tstate = wxPyBeginAllowThreads();
46191 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
46192 wxPyEndAllowThreads(__tstate);
46193 if (PyErr_Occurred()) SWIG_fail;
46194 }
46195 resultobj = SWIG_Py_Void();
46196 return resultobj;
46197 fail:
46198 return NULL;
46199 }
46200
46201
46202 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46203 PyObject *resultobj = 0;
46204 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46205 wxSize result;
46206 void *argp1 = 0 ;
46207 int res1 = 0 ;
46208 PyObject *swig_obj[1] ;
46209
46210 if (!args) SWIG_fail;
46211 swig_obj[0] = args;
46212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46213 if (!SWIG_IsOK(res1)) {
46214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46215 }
46216 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46217 {
46218 PyThreadState* __tstate = wxPyBeginAllowThreads();
46219 result = (arg1)->GetMinSize();
46220 wxPyEndAllowThreads(__tstate);
46221 if (PyErr_Occurred()) SWIG_fail;
46222 }
46223 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46224 return resultobj;
46225 fail:
46226 return NULL;
46227 }
46228
46229
46230 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46231 PyObject *resultobj = 0;
46232 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46233 wxSize result;
46234 void *argp1 = 0 ;
46235 int res1 = 0 ;
46236 PyObject *swig_obj[1] ;
46237
46238 if (!args) SWIG_fail;
46239 swig_obj[0] = args;
46240 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46241 if (!SWIG_IsOK(res1)) {
46242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
46243 }
46244 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46245 {
46246 PyThreadState* __tstate = wxPyBeginAllowThreads();
46247 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
46248 wxPyEndAllowThreads(__tstate);
46249 if (PyErr_Occurred()) SWIG_fail;
46250 }
46251 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46252 return resultobj;
46253 fail:
46254 return NULL;
46255 }
46256
46257
46258 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46259 PyObject *resultobj = 0;
46260 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46261 int arg2 ;
46262 int arg3 ;
46263 void *argp1 = 0 ;
46264 int res1 = 0 ;
46265 int val2 ;
46266 int ecode2 = 0 ;
46267 int val3 ;
46268 int ecode3 = 0 ;
46269 PyObject * obj0 = 0 ;
46270 PyObject * obj1 = 0 ;
46271 PyObject * obj2 = 0 ;
46272 char * kwnames[] = {
46273 (char *) "self",(char *) "x",(char *) "y", NULL
46274 };
46275
46276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46277 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46278 if (!SWIG_IsOK(res1)) {
46279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46280 }
46281 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46282 ecode2 = SWIG_AsVal_int(obj1, &val2);
46283 if (!SWIG_IsOK(ecode2)) {
46284 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
46285 }
46286 arg2 = static_cast< int >(val2);
46287 ecode3 = SWIG_AsVal_int(obj2, &val3);
46288 if (!SWIG_IsOK(ecode3)) {
46289 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
46290 }
46291 arg3 = static_cast< int >(val3);
46292 {
46293 PyThreadState* __tstate = wxPyBeginAllowThreads();
46294 (arg1)->SetInitSize(arg2,arg3);
46295 wxPyEndAllowThreads(__tstate);
46296 if (PyErr_Occurred()) SWIG_fail;
46297 }
46298 resultobj = SWIG_Py_Void();
46299 return resultobj;
46300 fail:
46301 return NULL;
46302 }
46303
46304
46305 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46306 PyObject *resultobj = 0;
46307 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46308 int arg2 ;
46309 int arg3 ;
46310 void *argp1 = 0 ;
46311 int res1 = 0 ;
46312 int val2 ;
46313 int ecode2 = 0 ;
46314 int val3 ;
46315 int ecode3 = 0 ;
46316 PyObject * obj0 = 0 ;
46317 PyObject * obj1 = 0 ;
46318 PyObject * obj2 = 0 ;
46319 char * kwnames[] = {
46320 (char *) "self",(char *) "width",(char *) "height", NULL
46321 };
46322
46323 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46324 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46325 if (!SWIG_IsOK(res1)) {
46326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46327 }
46328 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46329 ecode2 = SWIG_AsVal_int(obj1, &val2);
46330 if (!SWIG_IsOK(ecode2)) {
46331 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
46332 }
46333 arg2 = static_cast< int >(val2);
46334 ecode3 = SWIG_AsVal_int(obj2, &val3);
46335 if (!SWIG_IsOK(ecode3)) {
46336 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
46337 }
46338 arg3 = static_cast< int >(val3);
46339 {
46340 PyThreadState* __tstate = wxPyBeginAllowThreads();
46341 (arg1)->SetRatio(arg2,arg3);
46342 wxPyEndAllowThreads(__tstate);
46343 if (PyErr_Occurred()) SWIG_fail;
46344 }
46345 resultobj = SWIG_Py_Void();
46346 return resultobj;
46347 fail:
46348 return NULL;
46349 }
46350
46351
46352 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46353 PyObject *resultobj = 0;
46354 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46355 wxSize *arg2 = 0 ;
46356 void *argp1 = 0 ;
46357 int res1 = 0 ;
46358 wxSize temp2 ;
46359 PyObject * obj0 = 0 ;
46360 PyObject * obj1 = 0 ;
46361 char * kwnames[] = {
46362 (char *) "self",(char *) "size", NULL
46363 };
46364
46365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
46366 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46367 if (!SWIG_IsOK(res1)) {
46368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46369 }
46370 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46371 {
46372 arg2 = &temp2;
46373 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46374 }
46375 {
46376 PyThreadState* __tstate = wxPyBeginAllowThreads();
46377 (arg1)->SetRatio((wxSize const &)*arg2);
46378 wxPyEndAllowThreads(__tstate);
46379 if (PyErr_Occurred()) SWIG_fail;
46380 }
46381 resultobj = SWIG_Py_Void();
46382 return resultobj;
46383 fail:
46384 return NULL;
46385 }
46386
46387
46388 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46389 PyObject *resultobj = 0;
46390 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46391 float arg2 ;
46392 void *argp1 = 0 ;
46393 int res1 = 0 ;
46394 float val2 ;
46395 int ecode2 = 0 ;
46396 PyObject * obj0 = 0 ;
46397 PyObject * obj1 = 0 ;
46398 char * kwnames[] = {
46399 (char *) "self",(char *) "ratio", NULL
46400 };
46401
46402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
46403 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46404 if (!SWIG_IsOK(res1)) {
46405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46406 }
46407 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46408 ecode2 = SWIG_AsVal_float(obj1, &val2);
46409 if (!SWIG_IsOK(ecode2)) {
46410 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
46411 }
46412 arg2 = static_cast< float >(val2);
46413 {
46414 PyThreadState* __tstate = wxPyBeginAllowThreads();
46415 (arg1)->SetRatio(arg2);
46416 wxPyEndAllowThreads(__tstate);
46417 if (PyErr_Occurred()) SWIG_fail;
46418 }
46419 resultobj = SWIG_Py_Void();
46420 return resultobj;
46421 fail:
46422 return NULL;
46423 }
46424
46425
46426 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46427 PyObject *resultobj = 0;
46428 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46429 float result;
46430 void *argp1 = 0 ;
46431 int res1 = 0 ;
46432 PyObject *swig_obj[1] ;
46433
46434 if (!args) SWIG_fail;
46435 swig_obj[0] = args;
46436 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46437 if (!SWIG_IsOK(res1)) {
46438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46439 }
46440 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46441 {
46442 PyThreadState* __tstate = wxPyBeginAllowThreads();
46443 result = (float)(arg1)->GetRatio();
46444 wxPyEndAllowThreads(__tstate);
46445 if (PyErr_Occurred()) SWIG_fail;
46446 }
46447 resultobj = SWIG_From_float(static_cast< float >(result));
46448 return resultobj;
46449 fail:
46450 return NULL;
46451 }
46452
46453
46454 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46455 PyObject *resultobj = 0;
46456 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46457 wxRect result;
46458 void *argp1 = 0 ;
46459 int res1 = 0 ;
46460 PyObject *swig_obj[1] ;
46461
46462 if (!args) SWIG_fail;
46463 swig_obj[0] = args;
46464 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46465 if (!SWIG_IsOK(res1)) {
46466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46467 }
46468 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46469 {
46470 PyThreadState* __tstate = wxPyBeginAllowThreads();
46471 result = (arg1)->GetRect();
46472 wxPyEndAllowThreads(__tstate);
46473 if (PyErr_Occurred()) SWIG_fail;
46474 }
46475 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
46476 return resultobj;
46477 fail:
46478 return NULL;
46479 }
46480
46481
46482 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46483 PyObject *resultobj = 0;
46484 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46485 bool result;
46486 void *argp1 = 0 ;
46487 int res1 = 0 ;
46488 PyObject *swig_obj[1] ;
46489
46490 if (!args) SWIG_fail;
46491 swig_obj[0] = args;
46492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46493 if (!SWIG_IsOK(res1)) {
46494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46495 }
46496 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46497 {
46498 PyThreadState* __tstate = wxPyBeginAllowThreads();
46499 result = (bool)(arg1)->IsWindow();
46500 wxPyEndAllowThreads(__tstate);
46501 if (PyErr_Occurred()) SWIG_fail;
46502 }
46503 {
46504 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46505 }
46506 return resultobj;
46507 fail:
46508 return NULL;
46509 }
46510
46511
46512 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46513 PyObject *resultobj = 0;
46514 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46515 bool result;
46516 void *argp1 = 0 ;
46517 int res1 = 0 ;
46518 PyObject *swig_obj[1] ;
46519
46520 if (!args) SWIG_fail;
46521 swig_obj[0] = args;
46522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46523 if (!SWIG_IsOK(res1)) {
46524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46525 }
46526 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46527 {
46528 PyThreadState* __tstate = wxPyBeginAllowThreads();
46529 result = (bool)(arg1)->IsSizer();
46530 wxPyEndAllowThreads(__tstate);
46531 if (PyErr_Occurred()) SWIG_fail;
46532 }
46533 {
46534 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46535 }
46536 return resultobj;
46537 fail:
46538 return NULL;
46539 }
46540
46541
46542 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46543 PyObject *resultobj = 0;
46544 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46545 bool result;
46546 void *argp1 = 0 ;
46547 int res1 = 0 ;
46548 PyObject *swig_obj[1] ;
46549
46550 if (!args) SWIG_fail;
46551 swig_obj[0] = args;
46552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46553 if (!SWIG_IsOK(res1)) {
46554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46555 }
46556 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46557 {
46558 PyThreadState* __tstate = wxPyBeginAllowThreads();
46559 result = (bool)(arg1)->IsSpacer();
46560 wxPyEndAllowThreads(__tstate);
46561 if (PyErr_Occurred()) SWIG_fail;
46562 }
46563 {
46564 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46565 }
46566 return resultobj;
46567 fail:
46568 return NULL;
46569 }
46570
46571
46572 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46573 PyObject *resultobj = 0;
46574 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46575 int arg2 ;
46576 void *argp1 = 0 ;
46577 int res1 = 0 ;
46578 int val2 ;
46579 int ecode2 = 0 ;
46580 PyObject * obj0 = 0 ;
46581 PyObject * obj1 = 0 ;
46582 char * kwnames[] = {
46583 (char *) "self",(char *) "proportion", NULL
46584 };
46585
46586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
46587 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46588 if (!SWIG_IsOK(res1)) {
46589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46590 }
46591 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46592 ecode2 = SWIG_AsVal_int(obj1, &val2);
46593 if (!SWIG_IsOK(ecode2)) {
46594 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
46595 }
46596 arg2 = static_cast< int >(val2);
46597 {
46598 PyThreadState* __tstate = wxPyBeginAllowThreads();
46599 (arg1)->SetProportion(arg2);
46600 wxPyEndAllowThreads(__tstate);
46601 if (PyErr_Occurred()) SWIG_fail;
46602 }
46603 resultobj = SWIG_Py_Void();
46604 return resultobj;
46605 fail:
46606 return NULL;
46607 }
46608
46609
46610 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46611 PyObject *resultobj = 0;
46612 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46613 int result;
46614 void *argp1 = 0 ;
46615 int res1 = 0 ;
46616 PyObject *swig_obj[1] ;
46617
46618 if (!args) SWIG_fail;
46619 swig_obj[0] = args;
46620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46621 if (!SWIG_IsOK(res1)) {
46622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46623 }
46624 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46625 {
46626 PyThreadState* __tstate = wxPyBeginAllowThreads();
46627 result = (int)(arg1)->GetProportion();
46628 wxPyEndAllowThreads(__tstate);
46629 if (PyErr_Occurred()) SWIG_fail;
46630 }
46631 resultobj = SWIG_From_int(static_cast< int >(result));
46632 return resultobj;
46633 fail:
46634 return NULL;
46635 }
46636
46637
46638 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46639 PyObject *resultobj = 0;
46640 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46641 int arg2 ;
46642 void *argp1 = 0 ;
46643 int res1 = 0 ;
46644 int val2 ;
46645 int ecode2 = 0 ;
46646 PyObject * obj0 = 0 ;
46647 PyObject * obj1 = 0 ;
46648 char * kwnames[] = {
46649 (char *) "self",(char *) "flag", NULL
46650 };
46651
46652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
46653 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46654 if (!SWIG_IsOK(res1)) {
46655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46656 }
46657 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46658 ecode2 = SWIG_AsVal_int(obj1, &val2);
46659 if (!SWIG_IsOK(ecode2)) {
46660 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
46661 }
46662 arg2 = static_cast< int >(val2);
46663 {
46664 PyThreadState* __tstate = wxPyBeginAllowThreads();
46665 (arg1)->SetFlag(arg2);
46666 wxPyEndAllowThreads(__tstate);
46667 if (PyErr_Occurred()) SWIG_fail;
46668 }
46669 resultobj = SWIG_Py_Void();
46670 return resultobj;
46671 fail:
46672 return NULL;
46673 }
46674
46675
46676 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46677 PyObject *resultobj = 0;
46678 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46679 int result;
46680 void *argp1 = 0 ;
46681 int res1 = 0 ;
46682 PyObject *swig_obj[1] ;
46683
46684 if (!args) SWIG_fail;
46685 swig_obj[0] = args;
46686 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46687 if (!SWIG_IsOK(res1)) {
46688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46689 }
46690 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46691 {
46692 PyThreadState* __tstate = wxPyBeginAllowThreads();
46693 result = (int)(arg1)->GetFlag();
46694 wxPyEndAllowThreads(__tstate);
46695 if (PyErr_Occurred()) SWIG_fail;
46696 }
46697 resultobj = SWIG_From_int(static_cast< int >(result));
46698 return resultobj;
46699 fail:
46700 return NULL;
46701 }
46702
46703
46704 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46705 PyObject *resultobj = 0;
46706 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46707 int arg2 ;
46708 void *argp1 = 0 ;
46709 int res1 = 0 ;
46710 int val2 ;
46711 int ecode2 = 0 ;
46712 PyObject * obj0 = 0 ;
46713 PyObject * obj1 = 0 ;
46714 char * kwnames[] = {
46715 (char *) "self",(char *) "border", NULL
46716 };
46717
46718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
46719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46720 if (!SWIG_IsOK(res1)) {
46721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46722 }
46723 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46724 ecode2 = SWIG_AsVal_int(obj1, &val2);
46725 if (!SWIG_IsOK(ecode2)) {
46726 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
46727 }
46728 arg2 = static_cast< int >(val2);
46729 {
46730 PyThreadState* __tstate = wxPyBeginAllowThreads();
46731 (arg1)->SetBorder(arg2);
46732 wxPyEndAllowThreads(__tstate);
46733 if (PyErr_Occurred()) SWIG_fail;
46734 }
46735 resultobj = SWIG_Py_Void();
46736 return resultobj;
46737 fail:
46738 return NULL;
46739 }
46740
46741
46742 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46743 PyObject *resultobj = 0;
46744 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46745 int result;
46746 void *argp1 = 0 ;
46747 int res1 = 0 ;
46748 PyObject *swig_obj[1] ;
46749
46750 if (!args) SWIG_fail;
46751 swig_obj[0] = args;
46752 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46753 if (!SWIG_IsOK(res1)) {
46754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46755 }
46756 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46757 {
46758 PyThreadState* __tstate = wxPyBeginAllowThreads();
46759 result = (int)(arg1)->GetBorder();
46760 wxPyEndAllowThreads(__tstate);
46761 if (PyErr_Occurred()) SWIG_fail;
46762 }
46763 resultobj = SWIG_From_int(static_cast< int >(result));
46764 return resultobj;
46765 fail:
46766 return NULL;
46767 }
46768
46769
46770 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46771 PyObject *resultobj = 0;
46772 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46773 wxWindow *result = 0 ;
46774 void *argp1 = 0 ;
46775 int res1 = 0 ;
46776 PyObject *swig_obj[1] ;
46777
46778 if (!args) SWIG_fail;
46779 swig_obj[0] = args;
46780 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46781 if (!SWIG_IsOK(res1)) {
46782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46783 }
46784 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46785 {
46786 PyThreadState* __tstate = wxPyBeginAllowThreads();
46787 result = (wxWindow *)(arg1)->GetWindow();
46788 wxPyEndAllowThreads(__tstate);
46789 if (PyErr_Occurred()) SWIG_fail;
46790 }
46791 {
46792 resultobj = wxPyMake_wxObject(result, 0);
46793 }
46794 return resultobj;
46795 fail:
46796 return NULL;
46797 }
46798
46799
46800 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46801 PyObject *resultobj = 0;
46802 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46803 wxWindow *arg2 = (wxWindow *) 0 ;
46804 void *argp1 = 0 ;
46805 int res1 = 0 ;
46806 void *argp2 = 0 ;
46807 int res2 = 0 ;
46808 PyObject * obj0 = 0 ;
46809 PyObject * obj1 = 0 ;
46810 char * kwnames[] = {
46811 (char *) "self",(char *) "window", NULL
46812 };
46813
46814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
46815 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46816 if (!SWIG_IsOK(res1)) {
46817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46818 }
46819 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46820 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46821 if (!SWIG_IsOK(res2)) {
46822 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
46823 }
46824 arg2 = reinterpret_cast< wxWindow * >(argp2);
46825 {
46826 PyThreadState* __tstate = wxPyBeginAllowThreads();
46827 (arg1)->SetWindow(arg2);
46828 wxPyEndAllowThreads(__tstate);
46829 if (PyErr_Occurred()) SWIG_fail;
46830 }
46831 resultobj = SWIG_Py_Void();
46832 return resultobj;
46833 fail:
46834 return NULL;
46835 }
46836
46837
46838 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46839 PyObject *resultobj = 0;
46840 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46841 wxSizer *result = 0 ;
46842 void *argp1 = 0 ;
46843 int res1 = 0 ;
46844 PyObject *swig_obj[1] ;
46845
46846 if (!args) SWIG_fail;
46847 swig_obj[0] = args;
46848 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46849 if (!SWIG_IsOK(res1)) {
46850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46851 }
46852 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46853 {
46854 PyThreadState* __tstate = wxPyBeginAllowThreads();
46855 result = (wxSizer *)(arg1)->GetSizer();
46856 wxPyEndAllowThreads(__tstate);
46857 if (PyErr_Occurred()) SWIG_fail;
46858 }
46859 {
46860 resultobj = wxPyMake_wxObject(result, (bool)0);
46861 }
46862 return resultobj;
46863 fail:
46864 return NULL;
46865 }
46866
46867
46868 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46869 PyObject *resultobj = 0;
46870 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46871 wxSizer *arg2 = (wxSizer *) 0 ;
46872 void *argp1 = 0 ;
46873 int res1 = 0 ;
46874 int res2 = 0 ;
46875 PyObject * obj0 = 0 ;
46876 PyObject * obj1 = 0 ;
46877 char * kwnames[] = {
46878 (char *) "self",(char *) "sizer", NULL
46879 };
46880
46881 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
46882 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46883 if (!SWIG_IsOK(res1)) {
46884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46885 }
46886 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46887 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46888 if (!SWIG_IsOK(res2)) {
46889 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
46890 }
46891 {
46892 PyThreadState* __tstate = wxPyBeginAllowThreads();
46893 (arg1)->SetSizer(arg2);
46894 wxPyEndAllowThreads(__tstate);
46895 if (PyErr_Occurred()) SWIG_fail;
46896 }
46897 resultobj = SWIG_Py_Void();
46898 return resultobj;
46899 fail:
46900 return NULL;
46901 }
46902
46903
46904 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46905 PyObject *resultobj = 0;
46906 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46907 wxSize *result = 0 ;
46908 void *argp1 = 0 ;
46909 int res1 = 0 ;
46910 PyObject *swig_obj[1] ;
46911
46912 if (!args) SWIG_fail;
46913 swig_obj[0] = args;
46914 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46915 if (!SWIG_IsOK(res1)) {
46916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46917 }
46918 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46919 {
46920 PyThreadState* __tstate = wxPyBeginAllowThreads();
46921 {
46922 wxSize const &_result_ref = (arg1)->GetSpacer();
46923 result = (wxSize *) &_result_ref;
46924 }
46925 wxPyEndAllowThreads(__tstate);
46926 if (PyErr_Occurred()) SWIG_fail;
46927 }
46928 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
46929 return resultobj;
46930 fail:
46931 return NULL;
46932 }
46933
46934
46935 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46936 PyObject *resultobj = 0;
46937 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46938 wxSize *arg2 = 0 ;
46939 void *argp1 = 0 ;
46940 int res1 = 0 ;
46941 wxSize temp2 ;
46942 PyObject * obj0 = 0 ;
46943 PyObject * obj1 = 0 ;
46944 char * kwnames[] = {
46945 (char *) "self",(char *) "size", NULL
46946 };
46947
46948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
46949 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46950 if (!SWIG_IsOK(res1)) {
46951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46952 }
46953 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46954 {
46955 arg2 = &temp2;
46956 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46957 }
46958 {
46959 PyThreadState* __tstate = wxPyBeginAllowThreads();
46960 (arg1)->SetSpacer((wxSize const &)*arg2);
46961 wxPyEndAllowThreads(__tstate);
46962 if (PyErr_Occurred()) SWIG_fail;
46963 }
46964 resultobj = SWIG_Py_Void();
46965 return resultobj;
46966 fail:
46967 return NULL;
46968 }
46969
46970
46971 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46972 PyObject *resultobj = 0;
46973 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46974 bool arg2 ;
46975 void *argp1 = 0 ;
46976 int res1 = 0 ;
46977 bool val2 ;
46978 int ecode2 = 0 ;
46979 PyObject * obj0 = 0 ;
46980 PyObject * obj1 = 0 ;
46981 char * kwnames[] = {
46982 (char *) "self",(char *) "show", NULL
46983 };
46984
46985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
46986 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46987 if (!SWIG_IsOK(res1)) {
46988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46989 }
46990 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46991 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46992 if (!SWIG_IsOK(ecode2)) {
46993 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
46994 }
46995 arg2 = static_cast< bool >(val2);
46996 {
46997 PyThreadState* __tstate = wxPyBeginAllowThreads();
46998 (arg1)->Show(arg2);
46999 wxPyEndAllowThreads(__tstate);
47000 if (PyErr_Occurred()) SWIG_fail;
47001 }
47002 resultobj = SWIG_Py_Void();
47003 return resultobj;
47004 fail:
47005 return NULL;
47006 }
47007
47008
47009 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47010 PyObject *resultobj = 0;
47011 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47012 bool result;
47013 void *argp1 = 0 ;
47014 int res1 = 0 ;
47015 PyObject *swig_obj[1] ;
47016
47017 if (!args) SWIG_fail;
47018 swig_obj[0] = args;
47019 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47020 if (!SWIG_IsOK(res1)) {
47021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47022 }
47023 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47024 {
47025 PyThreadState* __tstate = wxPyBeginAllowThreads();
47026 result = (bool)(arg1)->IsShown();
47027 wxPyEndAllowThreads(__tstate);
47028 if (PyErr_Occurred()) SWIG_fail;
47029 }
47030 {
47031 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47032 }
47033 return resultobj;
47034 fail:
47035 return NULL;
47036 }
47037
47038
47039 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47040 PyObject *resultobj = 0;
47041 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47042 wxPoint result;
47043 void *argp1 = 0 ;
47044 int res1 = 0 ;
47045 PyObject *swig_obj[1] ;
47046
47047 if (!args) SWIG_fail;
47048 swig_obj[0] = args;
47049 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47050 if (!SWIG_IsOK(res1)) {
47051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47052 }
47053 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47054 {
47055 PyThreadState* __tstate = wxPyBeginAllowThreads();
47056 result = (arg1)->GetPosition();
47057 wxPyEndAllowThreads(__tstate);
47058 if (PyErr_Occurred()) SWIG_fail;
47059 }
47060 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
47061 return resultobj;
47062 fail:
47063 return NULL;
47064 }
47065
47066
47067 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47068 PyObject *resultobj = 0;
47069 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47070 PyObject *result = 0 ;
47071 void *argp1 = 0 ;
47072 int res1 = 0 ;
47073 PyObject *swig_obj[1] ;
47074
47075 if (!args) SWIG_fail;
47076 swig_obj[0] = args;
47077 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47078 if (!SWIG_IsOK(res1)) {
47079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47080 }
47081 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47082 {
47083 PyThreadState* __tstate = wxPyBeginAllowThreads();
47084 result = (PyObject *)wxSizerItem_GetUserData(arg1);
47085 wxPyEndAllowThreads(__tstate);
47086 if (PyErr_Occurred()) SWIG_fail;
47087 }
47088 resultobj = result;
47089 return resultobj;
47090 fail:
47091 return NULL;
47092 }
47093
47094
47095 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47096 PyObject *resultobj = 0;
47097 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47098 PyObject *arg2 = (PyObject *) 0 ;
47099 void *argp1 = 0 ;
47100 int res1 = 0 ;
47101 PyObject * obj0 = 0 ;
47102 PyObject * obj1 = 0 ;
47103 char * kwnames[] = {
47104 (char *) "self",(char *) "userData", NULL
47105 };
47106
47107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
47108 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47109 if (!SWIG_IsOK(res1)) {
47110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47111 }
47112 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47113 arg2 = obj1;
47114 {
47115 PyThreadState* __tstate = wxPyBeginAllowThreads();
47116 wxSizerItem_SetUserData(arg1,arg2);
47117 wxPyEndAllowThreads(__tstate);
47118 if (PyErr_Occurred()) SWIG_fail;
47119 }
47120 resultobj = SWIG_Py_Void();
47121 return resultobj;
47122 fail:
47123 return NULL;
47124 }
47125
47126
47127 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47128 PyObject *obj;
47129 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47130 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
47131 return SWIG_Py_Void();
47132 }
47133
47134 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47135 return SWIG_Python_InitShadowInstance(args);
47136 }
47137
47138 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47139 PyObject *resultobj = 0;
47140 wxSizer *arg1 = (wxSizer *) 0 ;
47141 void *argp1 = 0 ;
47142 int res1 = 0 ;
47143 PyObject *swig_obj[1] ;
47144
47145 if (!args) SWIG_fail;
47146 swig_obj[0] = args;
47147 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
47148 if (!SWIG_IsOK(res1)) {
47149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
47150 }
47151 arg1 = reinterpret_cast< wxSizer * >(argp1);
47152 {
47153 PyThreadState* __tstate = wxPyBeginAllowThreads();
47154 delete arg1;
47155
47156 wxPyEndAllowThreads(__tstate);
47157 if (PyErr_Occurred()) SWIG_fail;
47158 }
47159 resultobj = SWIG_Py_Void();
47160 return resultobj;
47161 fail:
47162 return NULL;
47163 }
47164
47165
47166 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47167 PyObject *resultobj = 0;
47168 wxSizer *arg1 = (wxSizer *) 0 ;
47169 PyObject *arg2 = (PyObject *) 0 ;
47170 void *argp1 = 0 ;
47171 int res1 = 0 ;
47172 PyObject * obj0 = 0 ;
47173 PyObject * obj1 = 0 ;
47174 char * kwnames[] = {
47175 (char *) "self",(char *) "_self", NULL
47176 };
47177
47178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
47179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47180 if (!SWIG_IsOK(res1)) {
47181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
47182 }
47183 arg1 = reinterpret_cast< wxSizer * >(argp1);
47184 arg2 = obj1;
47185 {
47186 PyThreadState* __tstate = wxPyBeginAllowThreads();
47187 wxSizer__setOORInfo(arg1,arg2);
47188 wxPyEndAllowThreads(__tstate);
47189 if (PyErr_Occurred()) SWIG_fail;
47190 }
47191 resultobj = SWIG_Py_Void();
47192 return resultobj;
47193 fail:
47194 return NULL;
47195 }
47196
47197
47198 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47199 PyObject *resultobj = 0;
47200 wxSizer *arg1 = (wxSizer *) 0 ;
47201 PyObject *arg2 = (PyObject *) 0 ;
47202 int arg3 = (int) 0 ;
47203 int arg4 = (int) 0 ;
47204 int arg5 = (int) 0 ;
47205 PyObject *arg6 = (PyObject *) NULL ;
47206 wxSizerItem *result = 0 ;
47207 void *argp1 = 0 ;
47208 int res1 = 0 ;
47209 int val3 ;
47210 int ecode3 = 0 ;
47211 int val4 ;
47212 int ecode4 = 0 ;
47213 int val5 ;
47214 int ecode5 = 0 ;
47215 PyObject * obj0 = 0 ;
47216 PyObject * obj1 = 0 ;
47217 PyObject * obj2 = 0 ;
47218 PyObject * obj3 = 0 ;
47219 PyObject * obj4 = 0 ;
47220 PyObject * obj5 = 0 ;
47221 char * kwnames[] = {
47222 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
47223 };
47224
47225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
47226 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47227 if (!SWIG_IsOK(res1)) {
47228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
47229 }
47230 arg1 = reinterpret_cast< wxSizer * >(argp1);
47231 arg2 = obj1;
47232 if (obj2) {
47233 ecode3 = SWIG_AsVal_int(obj2, &val3);
47234 if (!SWIG_IsOK(ecode3)) {
47235 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
47236 }
47237 arg3 = static_cast< int >(val3);
47238 }
47239 if (obj3) {
47240 ecode4 = SWIG_AsVal_int(obj3, &val4);
47241 if (!SWIG_IsOK(ecode4)) {
47242 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
47243 }
47244 arg4 = static_cast< int >(val4);
47245 }
47246 if (obj4) {
47247 ecode5 = SWIG_AsVal_int(obj4, &val5);
47248 if (!SWIG_IsOK(ecode5)) {
47249 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
47250 }
47251 arg5 = static_cast< int >(val5);
47252 }
47253 if (obj5) {
47254 arg6 = obj5;
47255 }
47256 {
47257 PyThreadState* __tstate = wxPyBeginAllowThreads();
47258 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
47259 wxPyEndAllowThreads(__tstate);
47260 if (PyErr_Occurred()) SWIG_fail;
47261 }
47262 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47263 return resultobj;
47264 fail:
47265 return NULL;
47266 }
47267
47268
47269 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47270 PyObject *resultobj = 0;
47271 wxSizer *arg1 = (wxSizer *) 0 ;
47272 int arg2 ;
47273 PyObject *arg3 = (PyObject *) 0 ;
47274 int arg4 = (int) 0 ;
47275 int arg5 = (int) 0 ;
47276 int arg6 = (int) 0 ;
47277 PyObject *arg7 = (PyObject *) NULL ;
47278 wxSizerItem *result = 0 ;
47279 void *argp1 = 0 ;
47280 int res1 = 0 ;
47281 int val2 ;
47282 int ecode2 = 0 ;
47283 int val4 ;
47284 int ecode4 = 0 ;
47285 int val5 ;
47286 int ecode5 = 0 ;
47287 int val6 ;
47288 int ecode6 = 0 ;
47289 PyObject * obj0 = 0 ;
47290 PyObject * obj1 = 0 ;
47291 PyObject * obj2 = 0 ;
47292 PyObject * obj3 = 0 ;
47293 PyObject * obj4 = 0 ;
47294 PyObject * obj5 = 0 ;
47295 PyObject * obj6 = 0 ;
47296 char * kwnames[] = {
47297 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
47298 };
47299
47300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
47301 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47302 if (!SWIG_IsOK(res1)) {
47303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
47304 }
47305 arg1 = reinterpret_cast< wxSizer * >(argp1);
47306 ecode2 = SWIG_AsVal_int(obj1, &val2);
47307 if (!SWIG_IsOK(ecode2)) {
47308 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
47309 }
47310 arg2 = static_cast< int >(val2);
47311 arg3 = obj2;
47312 if (obj3) {
47313 ecode4 = SWIG_AsVal_int(obj3, &val4);
47314 if (!SWIG_IsOK(ecode4)) {
47315 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
47316 }
47317 arg4 = static_cast< int >(val4);
47318 }
47319 if (obj4) {
47320 ecode5 = SWIG_AsVal_int(obj4, &val5);
47321 if (!SWIG_IsOK(ecode5)) {
47322 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
47323 }
47324 arg5 = static_cast< int >(val5);
47325 }
47326 if (obj5) {
47327 ecode6 = SWIG_AsVal_int(obj5, &val6);
47328 if (!SWIG_IsOK(ecode6)) {
47329 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
47330 }
47331 arg6 = static_cast< int >(val6);
47332 }
47333 if (obj6) {
47334 arg7 = obj6;
47335 }
47336 {
47337 PyThreadState* __tstate = wxPyBeginAllowThreads();
47338 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
47339 wxPyEndAllowThreads(__tstate);
47340 if (PyErr_Occurred()) SWIG_fail;
47341 }
47342 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47343 return resultobj;
47344 fail:
47345 return NULL;
47346 }
47347
47348
47349 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47350 PyObject *resultobj = 0;
47351 wxSizer *arg1 = (wxSizer *) 0 ;
47352 PyObject *arg2 = (PyObject *) 0 ;
47353 int arg3 = (int) 0 ;
47354 int arg4 = (int) 0 ;
47355 int arg5 = (int) 0 ;
47356 PyObject *arg6 = (PyObject *) NULL ;
47357 wxSizerItem *result = 0 ;
47358 void *argp1 = 0 ;
47359 int res1 = 0 ;
47360 int val3 ;
47361 int ecode3 = 0 ;
47362 int val4 ;
47363 int ecode4 = 0 ;
47364 int val5 ;
47365 int ecode5 = 0 ;
47366 PyObject * obj0 = 0 ;
47367 PyObject * obj1 = 0 ;
47368 PyObject * obj2 = 0 ;
47369 PyObject * obj3 = 0 ;
47370 PyObject * obj4 = 0 ;
47371 PyObject * obj5 = 0 ;
47372 char * kwnames[] = {
47373 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
47374 };
47375
47376 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
47377 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47378 if (!SWIG_IsOK(res1)) {
47379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
47380 }
47381 arg1 = reinterpret_cast< wxSizer * >(argp1);
47382 arg2 = obj1;
47383 if (obj2) {
47384 ecode3 = SWIG_AsVal_int(obj2, &val3);
47385 if (!SWIG_IsOK(ecode3)) {
47386 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
47387 }
47388 arg3 = static_cast< int >(val3);
47389 }
47390 if (obj3) {
47391 ecode4 = SWIG_AsVal_int(obj3, &val4);
47392 if (!SWIG_IsOK(ecode4)) {
47393 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
47394 }
47395 arg4 = static_cast< int >(val4);
47396 }
47397 if (obj4) {
47398 ecode5 = SWIG_AsVal_int(obj4, &val5);
47399 if (!SWIG_IsOK(ecode5)) {
47400 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
47401 }
47402 arg5 = static_cast< int >(val5);
47403 }
47404 if (obj5) {
47405 arg6 = obj5;
47406 }
47407 {
47408 PyThreadState* __tstate = wxPyBeginAllowThreads();
47409 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
47410 wxPyEndAllowThreads(__tstate);
47411 if (PyErr_Occurred()) SWIG_fail;
47412 }
47413 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47414 return resultobj;
47415 fail:
47416 return NULL;
47417 }
47418
47419
47420 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47421 PyObject *resultobj = 0;
47422 wxSizer *arg1 = (wxSizer *) 0 ;
47423 PyObject *arg2 = (PyObject *) 0 ;
47424 bool result;
47425 void *argp1 = 0 ;
47426 int res1 = 0 ;
47427 PyObject * obj0 = 0 ;
47428 PyObject * obj1 = 0 ;
47429 char * kwnames[] = {
47430 (char *) "self",(char *) "item", NULL
47431 };
47432
47433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
47434 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47435 if (!SWIG_IsOK(res1)) {
47436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
47437 }
47438 arg1 = reinterpret_cast< wxSizer * >(argp1);
47439 arg2 = obj1;
47440 {
47441 PyThreadState* __tstate = wxPyBeginAllowThreads();
47442 result = (bool)wxSizer_Remove(arg1,arg2);
47443 wxPyEndAllowThreads(__tstate);
47444 if (PyErr_Occurred()) SWIG_fail;
47445 }
47446 {
47447 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47448 }
47449 return resultobj;
47450 fail:
47451 return NULL;
47452 }
47453
47454
47455 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47456 PyObject *resultobj = 0;
47457 wxSizer *arg1 = (wxSizer *) 0 ;
47458 PyObject *arg2 = (PyObject *) 0 ;
47459 bool result;
47460 void *argp1 = 0 ;
47461 int res1 = 0 ;
47462 PyObject * obj0 = 0 ;
47463 PyObject * obj1 = 0 ;
47464 char * kwnames[] = {
47465 (char *) "self",(char *) "item", NULL
47466 };
47467
47468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
47469 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47470 if (!SWIG_IsOK(res1)) {
47471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
47472 }
47473 arg1 = reinterpret_cast< wxSizer * >(argp1);
47474 arg2 = obj1;
47475 {
47476 PyThreadState* __tstate = wxPyBeginAllowThreads();
47477 result = (bool)wxSizer_Detach(arg1,arg2);
47478 wxPyEndAllowThreads(__tstate);
47479 if (PyErr_Occurred()) SWIG_fail;
47480 }
47481 {
47482 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47483 }
47484 return resultobj;
47485 fail:
47486 return NULL;
47487 }
47488
47489
47490 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47491 PyObject *resultobj = 0;
47492 wxSizer *arg1 = (wxSizer *) 0 ;
47493 PyObject *arg2 = (PyObject *) 0 ;
47494 wxSizerItem *result = 0 ;
47495 void *argp1 = 0 ;
47496 int res1 = 0 ;
47497 PyObject * obj0 = 0 ;
47498 PyObject * obj1 = 0 ;
47499 char * kwnames[] = {
47500 (char *) "self",(char *) "item", NULL
47501 };
47502
47503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
47504 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47505 if (!SWIG_IsOK(res1)) {
47506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47507 }
47508 arg1 = reinterpret_cast< wxSizer * >(argp1);
47509 arg2 = obj1;
47510 {
47511 PyThreadState* __tstate = wxPyBeginAllowThreads();
47512 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
47513 wxPyEndAllowThreads(__tstate);
47514 if (PyErr_Occurred()) SWIG_fail;
47515 }
47516 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47517 return resultobj;
47518 fail:
47519 return NULL;
47520 }
47521
47522
47523 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47524 PyObject *resultobj = 0;
47525 wxSizer *arg1 = (wxSizer *) 0 ;
47526 PyObject *arg2 = (PyObject *) 0 ;
47527 wxSize *arg3 = 0 ;
47528 void *argp1 = 0 ;
47529 int res1 = 0 ;
47530 wxSize temp3 ;
47531 PyObject * obj0 = 0 ;
47532 PyObject * obj1 = 0 ;
47533 PyObject * obj2 = 0 ;
47534 char * kwnames[] = {
47535 (char *) "self",(char *) "item",(char *) "size", NULL
47536 };
47537
47538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47539 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47540 if (!SWIG_IsOK(res1)) {
47541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47542 }
47543 arg1 = reinterpret_cast< wxSizer * >(argp1);
47544 arg2 = obj1;
47545 {
47546 arg3 = &temp3;
47547 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
47548 }
47549 {
47550 PyThreadState* __tstate = wxPyBeginAllowThreads();
47551 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
47552 wxPyEndAllowThreads(__tstate);
47553 if (PyErr_Occurred()) SWIG_fail;
47554 }
47555 resultobj = SWIG_Py_Void();
47556 return resultobj;
47557 fail:
47558 return NULL;
47559 }
47560
47561
47562 SWIGINTERN PyObject *_wrap_Sizer__ReplaceWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47563 PyObject *resultobj = 0;
47564 wxSizer *arg1 = (wxSizer *) 0 ;
47565 wxWindow *arg2 = (wxWindow *) 0 ;
47566 wxWindow *arg3 = (wxWindow *) 0 ;
47567 bool arg4 = (bool) false ;
47568 bool result;
47569 void *argp1 = 0 ;
47570 int res1 = 0 ;
47571 void *argp2 = 0 ;
47572 int res2 = 0 ;
47573 void *argp3 = 0 ;
47574 int res3 = 0 ;
47575 bool val4 ;
47576 int ecode4 = 0 ;
47577 PyObject * obj0 = 0 ;
47578 PyObject * obj1 = 0 ;
47579 PyObject * obj2 = 0 ;
47580 PyObject * obj3 = 0 ;
47581 char * kwnames[] = {
47582 (char *) "self",(char *) "oldwin",(char *) "newwin",(char *) "recursive", NULL
47583 };
47584
47585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceWin",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47586 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47587 if (!SWIG_IsOK(res1)) {
47588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceWin" "', expected argument " "1"" of type '" "wxSizer *""'");
47589 }
47590 arg1 = reinterpret_cast< wxSizer * >(argp1);
47591 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47592 if (!SWIG_IsOK(res2)) {
47593 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceWin" "', expected argument " "2"" of type '" "wxWindow *""'");
47594 }
47595 arg2 = reinterpret_cast< wxWindow * >(argp2);
47596 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
47597 if (!SWIG_IsOK(res3)) {
47598 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceWin" "', expected argument " "3"" of type '" "wxWindow *""'");
47599 }
47600 arg3 = reinterpret_cast< wxWindow * >(argp3);
47601 if (obj3) {
47602 ecode4 = SWIG_AsVal_bool(obj3, &val4);
47603 if (!SWIG_IsOK(ecode4)) {
47604 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceWin" "', expected argument " "4"" of type '" "bool""'");
47605 }
47606 arg4 = static_cast< bool >(val4);
47607 }
47608 {
47609 PyThreadState* __tstate = wxPyBeginAllowThreads();
47610 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
47611 wxPyEndAllowThreads(__tstate);
47612 if (PyErr_Occurred()) SWIG_fail;
47613 }
47614 {
47615 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47616 }
47617 return resultobj;
47618 fail:
47619 return NULL;
47620 }
47621
47622
47623 SWIGINTERN PyObject *_wrap_Sizer__ReplaceSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47624 PyObject *resultobj = 0;
47625 wxSizer *arg1 = (wxSizer *) 0 ;
47626 wxSizer *arg2 = (wxSizer *) 0 ;
47627 wxSizer *arg3 = (wxSizer *) 0 ;
47628 bool arg4 = (bool) false ;
47629 bool result;
47630 void *argp1 = 0 ;
47631 int res1 = 0 ;
47632 void *argp2 = 0 ;
47633 int res2 = 0 ;
47634 void *argp3 = 0 ;
47635 int res3 = 0 ;
47636 bool val4 ;
47637 int ecode4 = 0 ;
47638 PyObject * obj0 = 0 ;
47639 PyObject * obj1 = 0 ;
47640 PyObject * obj2 = 0 ;
47641 PyObject * obj3 = 0 ;
47642 char * kwnames[] = {
47643 (char *) "self",(char *) "oldsz",(char *) "newsz",(char *) "recursive", NULL
47644 };
47645
47646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47648 if (!SWIG_IsOK(res1)) {
47649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
47650 }
47651 arg1 = reinterpret_cast< wxSizer * >(argp1);
47652 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
47653 if (!SWIG_IsOK(res2)) {
47654 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
47655 }
47656 arg2 = reinterpret_cast< wxSizer * >(argp2);
47657 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizer, 0 | 0 );
47658 if (!SWIG_IsOK(res3)) {
47659 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceSizer" "', expected argument " "3"" of type '" "wxSizer *""'");
47660 }
47661 arg3 = reinterpret_cast< wxSizer * >(argp3);
47662 if (obj3) {
47663 ecode4 = SWIG_AsVal_bool(obj3, &val4);
47664 if (!SWIG_IsOK(ecode4)) {
47665 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceSizer" "', expected argument " "4"" of type '" "bool""'");
47666 }
47667 arg4 = static_cast< bool >(val4);
47668 }
47669 {
47670 PyThreadState* __tstate = wxPyBeginAllowThreads();
47671 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
47672 wxPyEndAllowThreads(__tstate);
47673 if (PyErr_Occurred()) SWIG_fail;
47674 }
47675 {
47676 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47677 }
47678 return resultobj;
47679 fail:
47680 return NULL;
47681 }
47682
47683
47684 SWIGINTERN PyObject *_wrap_Sizer__ReplaceItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47685 PyObject *resultobj = 0;
47686 wxSizer *arg1 = (wxSizer *) 0 ;
47687 size_t arg2 ;
47688 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
47689 bool result;
47690 void *argp1 = 0 ;
47691 int res1 = 0 ;
47692 size_t val2 ;
47693 int ecode2 = 0 ;
47694 void *argp3 = 0 ;
47695 int res3 = 0 ;
47696 PyObject * obj0 = 0 ;
47697 PyObject * obj1 = 0 ;
47698 PyObject * obj2 = 0 ;
47699 char * kwnames[] = {
47700 (char *) "self",(char *) "index",(char *) "newitem", NULL
47701 };
47702
47703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__ReplaceItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47705 if (!SWIG_IsOK(res1)) {
47706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47707 }
47708 arg1 = reinterpret_cast< wxSizer * >(argp1);
47709 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47710 if (!SWIG_IsOK(ecode2)) {
47711 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer__ReplaceItem" "', expected argument " "2"" of type '" "size_t""'");
47712 }
47713 arg2 = static_cast< size_t >(val2);
47714 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47715 if (!SWIG_IsOK(res3)) {
47716 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
47717 }
47718 arg3 = reinterpret_cast< wxSizerItem * >(argp3);
47719 {
47720 PyThreadState* __tstate = wxPyBeginAllowThreads();
47721 result = (bool)(arg1)->Replace(arg2,arg3);
47722 wxPyEndAllowThreads(__tstate);
47723 if (PyErr_Occurred()) SWIG_fail;
47724 }
47725 {
47726 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47727 }
47728 return resultobj;
47729 fail:
47730 return NULL;
47731 }
47732
47733
47734 SWIGINTERN PyObject *_wrap_Sizer_SetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47735 PyObject *resultobj = 0;
47736 wxSizer *arg1 = (wxSizer *) 0 ;
47737 wxWindow *arg2 = (wxWindow *) 0 ;
47738 void *argp1 = 0 ;
47739 int res1 = 0 ;
47740 void *argp2 = 0 ;
47741 int res2 = 0 ;
47742 PyObject * obj0 = 0 ;
47743 PyObject * obj1 = 0 ;
47744 char * kwnames[] = {
47745 (char *) "self",(char *) "window", NULL
47746 };
47747
47748 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetContainingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
47749 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47750 if (!SWIG_IsOK(res1)) {
47751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetContainingWindow" "', expected argument " "1"" of type '" "wxSizer *""'");
47752 }
47753 arg1 = reinterpret_cast< wxSizer * >(argp1);
47754 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47755 if (!SWIG_IsOK(res2)) {
47756 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetContainingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
47757 }
47758 arg2 = reinterpret_cast< wxWindow * >(argp2);
47759 {
47760 PyThreadState* __tstate = wxPyBeginAllowThreads();
47761 (arg1)->SetContainingWindow(arg2);
47762 wxPyEndAllowThreads(__tstate);
47763 if (PyErr_Occurred()) SWIG_fail;
47764 }
47765 resultobj = SWIG_Py_Void();
47766 return resultobj;
47767 fail:
47768 return NULL;
47769 }
47770
47771
47772 SWIGINTERN PyObject *_wrap_Sizer_GetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47773 PyObject *resultobj = 0;
47774 wxSizer *arg1 = (wxSizer *) 0 ;
47775 wxWindow *result = 0 ;
47776 void *argp1 = 0 ;
47777 int res1 = 0 ;
47778 PyObject *swig_obj[1] ;
47779
47780 if (!args) SWIG_fail;
47781 swig_obj[0] = args;
47782 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47783 if (!SWIG_IsOK(res1)) {
47784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetContainingWindow" "', expected argument " "1"" of type '" "wxSizer const *""'");
47785 }
47786 arg1 = reinterpret_cast< wxSizer * >(argp1);
47787 {
47788 PyThreadState* __tstate = wxPyBeginAllowThreads();
47789 result = (wxWindow *)((wxSizer const *)arg1)->GetContainingWindow();
47790 wxPyEndAllowThreads(__tstate);
47791 if (PyErr_Occurred()) SWIG_fail;
47792 }
47793 {
47794 resultobj = wxPyMake_wxObject(result, 0);
47795 }
47796 return resultobj;
47797 fail:
47798 return NULL;
47799 }
47800
47801
47802 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47803 PyObject *resultobj = 0;
47804 wxSizer *arg1 = (wxSizer *) 0 ;
47805 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
47806 wxSizerItem *result = 0 ;
47807 void *argp1 = 0 ;
47808 int res1 = 0 ;
47809 int res2 = 0 ;
47810 PyObject * obj0 = 0 ;
47811 PyObject * obj1 = 0 ;
47812 char * kwnames[] = {
47813 (char *) "self",(char *) "item", NULL
47814 };
47815
47816 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
47817 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47818 if (!SWIG_IsOK(res1)) {
47819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47820 }
47821 arg1 = reinterpret_cast< wxSizer * >(argp1);
47822 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
47823 if (!SWIG_IsOK(res2)) {
47824 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
47825 }
47826 {
47827 PyThreadState* __tstate = wxPyBeginAllowThreads();
47828 result = (wxSizerItem *)(arg1)->Add(arg2);
47829 wxPyEndAllowThreads(__tstate);
47830 if (PyErr_Occurred()) SWIG_fail;
47831 }
47832 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47833 return resultobj;
47834 fail:
47835 return NULL;
47836 }
47837
47838
47839 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47840 PyObject *resultobj = 0;
47841 wxSizer *arg1 = (wxSizer *) 0 ;
47842 size_t arg2 ;
47843 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
47844 wxSizerItem *result = 0 ;
47845 void *argp1 = 0 ;
47846 int res1 = 0 ;
47847 size_t val2 ;
47848 int ecode2 = 0 ;
47849 int res3 = 0 ;
47850 PyObject * obj0 = 0 ;
47851 PyObject * obj1 = 0 ;
47852 PyObject * obj2 = 0 ;
47853 char * kwnames[] = {
47854 (char *) "self",(char *) "index",(char *) "item", NULL
47855 };
47856
47857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47859 if (!SWIG_IsOK(res1)) {
47860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47861 }
47862 arg1 = reinterpret_cast< wxSizer * >(argp1);
47863 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47864 if (!SWIG_IsOK(ecode2)) {
47865 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
47866 }
47867 arg2 = static_cast< size_t >(val2);
47868 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
47869 if (!SWIG_IsOK(res3)) {
47870 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
47871 }
47872 {
47873 PyThreadState* __tstate = wxPyBeginAllowThreads();
47874 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
47875 wxPyEndAllowThreads(__tstate);
47876 if (PyErr_Occurred()) SWIG_fail;
47877 }
47878 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47879 return resultobj;
47880 fail:
47881 return NULL;
47882 }
47883
47884
47885 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47886 PyObject *resultobj = 0;
47887 wxSizer *arg1 = (wxSizer *) 0 ;
47888 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
47889 wxSizerItem *result = 0 ;
47890 void *argp1 = 0 ;
47891 int res1 = 0 ;
47892 int res2 = 0 ;
47893 PyObject * obj0 = 0 ;
47894 PyObject * obj1 = 0 ;
47895 char * kwnames[] = {
47896 (char *) "self",(char *) "item", NULL
47897 };
47898
47899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
47900 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47901 if (!SWIG_IsOK(res1)) {
47902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47903 }
47904 arg1 = reinterpret_cast< wxSizer * >(argp1);
47905 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
47906 if (!SWIG_IsOK(res2)) {
47907 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
47908 }
47909 {
47910 PyThreadState* __tstate = wxPyBeginAllowThreads();
47911 result = (wxSizerItem *)(arg1)->Prepend(arg2);
47912 wxPyEndAllowThreads(__tstate);
47913 if (PyErr_Occurred()) SWIG_fail;
47914 }
47915 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47916 return resultobj;
47917 fail:
47918 return NULL;
47919 }
47920
47921
47922 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47923 PyObject *resultobj = 0;
47924 wxSizer *arg1 = (wxSizer *) 0 ;
47925 int arg2 ;
47926 int arg3 ;
47927 int arg4 ;
47928 int arg5 ;
47929 void *argp1 = 0 ;
47930 int res1 = 0 ;
47931 int val2 ;
47932 int ecode2 = 0 ;
47933 int val3 ;
47934 int ecode3 = 0 ;
47935 int val4 ;
47936 int ecode4 = 0 ;
47937 int val5 ;
47938 int ecode5 = 0 ;
47939 PyObject * obj0 = 0 ;
47940 PyObject * obj1 = 0 ;
47941 PyObject * obj2 = 0 ;
47942 PyObject * obj3 = 0 ;
47943 PyObject * obj4 = 0 ;
47944 char * kwnames[] = {
47945 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
47946 };
47947
47948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
47949 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47950 if (!SWIG_IsOK(res1)) {
47951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
47952 }
47953 arg1 = reinterpret_cast< wxSizer * >(argp1);
47954 ecode2 = SWIG_AsVal_int(obj1, &val2);
47955 if (!SWIG_IsOK(ecode2)) {
47956 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
47957 }
47958 arg2 = static_cast< int >(val2);
47959 ecode3 = SWIG_AsVal_int(obj2, &val3);
47960 if (!SWIG_IsOK(ecode3)) {
47961 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
47962 }
47963 arg3 = static_cast< int >(val3);
47964 ecode4 = SWIG_AsVal_int(obj3, &val4);
47965 if (!SWIG_IsOK(ecode4)) {
47966 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
47967 }
47968 arg4 = static_cast< int >(val4);
47969 ecode5 = SWIG_AsVal_int(obj4, &val5);
47970 if (!SWIG_IsOK(ecode5)) {
47971 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
47972 }
47973 arg5 = static_cast< int >(val5);
47974 {
47975 PyThreadState* __tstate = wxPyBeginAllowThreads();
47976 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
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_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47988 PyObject *resultobj = 0;
47989 wxSizer *arg1 = (wxSizer *) 0 ;
47990 wxSize *arg2 = 0 ;
47991 void *argp1 = 0 ;
47992 int res1 = 0 ;
47993 wxSize temp2 ;
47994 PyObject * obj0 = 0 ;
47995 PyObject * obj1 = 0 ;
47996 char * kwnames[] = {
47997 (char *) "self",(char *) "size", NULL
47998 };
47999
48000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
48001 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48002 if (!SWIG_IsOK(res1)) {
48003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
48004 }
48005 arg1 = reinterpret_cast< wxSizer * >(argp1);
48006 {
48007 arg2 = &temp2;
48008 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
48009 }
48010 {
48011 PyThreadState* __tstate = wxPyBeginAllowThreads();
48012 (arg1)->SetMinSize((wxSize const &)*arg2);
48013 wxPyEndAllowThreads(__tstate);
48014 if (PyErr_Occurred()) SWIG_fail;
48015 }
48016 resultobj = SWIG_Py_Void();
48017 return resultobj;
48018 fail:
48019 return NULL;
48020 }
48021
48022
48023 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48024 PyObject *resultobj = 0;
48025 wxSizer *arg1 = (wxSizer *) 0 ;
48026 wxSize result;
48027 void *argp1 = 0 ;
48028 int res1 = 0 ;
48029 PyObject *swig_obj[1] ;
48030
48031 if (!args) SWIG_fail;
48032 swig_obj[0] = args;
48033 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48034 if (!SWIG_IsOK(res1)) {
48035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
48036 }
48037 arg1 = reinterpret_cast< wxSizer * >(argp1);
48038 {
48039 PyThreadState* __tstate = wxPyBeginAllowThreads();
48040 result = (arg1)->GetSize();
48041 wxPyEndAllowThreads(__tstate);
48042 if (PyErr_Occurred()) SWIG_fail;
48043 }
48044 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48045 return resultobj;
48046 fail:
48047 return NULL;
48048 }
48049
48050
48051 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48052 PyObject *resultobj = 0;
48053 wxSizer *arg1 = (wxSizer *) 0 ;
48054 wxPoint result;
48055 void *argp1 = 0 ;
48056 int res1 = 0 ;
48057 PyObject *swig_obj[1] ;
48058
48059 if (!args) SWIG_fail;
48060 swig_obj[0] = args;
48061 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48062 if (!SWIG_IsOK(res1)) {
48063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
48064 }
48065 arg1 = reinterpret_cast< wxSizer * >(argp1);
48066 {
48067 PyThreadState* __tstate = wxPyBeginAllowThreads();
48068 result = (arg1)->GetPosition();
48069 wxPyEndAllowThreads(__tstate);
48070 if (PyErr_Occurred()) SWIG_fail;
48071 }
48072 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
48073 return resultobj;
48074 fail:
48075 return NULL;
48076 }
48077
48078
48079 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48080 PyObject *resultobj = 0;
48081 wxSizer *arg1 = (wxSizer *) 0 ;
48082 wxSize result;
48083 void *argp1 = 0 ;
48084 int res1 = 0 ;
48085 PyObject *swig_obj[1] ;
48086
48087 if (!args) SWIG_fail;
48088 swig_obj[0] = args;
48089 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48090 if (!SWIG_IsOK(res1)) {
48091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
48092 }
48093 arg1 = reinterpret_cast< wxSizer * >(argp1);
48094 {
48095 PyThreadState* __tstate = wxPyBeginAllowThreads();
48096 result = (arg1)->GetMinSize();
48097 wxPyEndAllowThreads(__tstate);
48098 if (PyErr_Occurred()) SWIG_fail;
48099 }
48100 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48101 return resultobj;
48102 fail:
48103 return NULL;
48104 }
48105
48106
48107 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48108 PyObject *resultobj = 0;
48109 wxSizer *arg1 = (wxSizer *) 0 ;
48110 void *argp1 = 0 ;
48111 int res1 = 0 ;
48112 PyObject *swig_obj[1] ;
48113
48114 if (!args) SWIG_fail;
48115 swig_obj[0] = args;
48116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48117 if (!SWIG_IsOK(res1)) {
48118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
48119 }
48120 arg1 = reinterpret_cast< wxSizer * >(argp1);
48121 {
48122 PyThreadState* __tstate = wxPyBeginAllowThreads();
48123 (arg1)->RecalcSizes();
48124 wxPyEndAllowThreads(__tstate);
48125 if (PyErr_Occurred()) SWIG_fail;
48126 }
48127 resultobj = SWIG_Py_Void();
48128 return resultobj;
48129 fail:
48130 return NULL;
48131 }
48132
48133
48134 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48135 PyObject *resultobj = 0;
48136 wxSizer *arg1 = (wxSizer *) 0 ;
48137 wxSize result;
48138 void *argp1 = 0 ;
48139 int res1 = 0 ;
48140 PyObject *swig_obj[1] ;
48141
48142 if (!args) SWIG_fail;
48143 swig_obj[0] = args;
48144 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48145 if (!SWIG_IsOK(res1)) {
48146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
48147 }
48148 arg1 = reinterpret_cast< wxSizer * >(argp1);
48149 {
48150 PyThreadState* __tstate = wxPyBeginAllowThreads();
48151 result = (arg1)->CalcMin();
48152 wxPyEndAllowThreads(__tstate);
48153 if (PyErr_Occurred()) SWIG_fail;
48154 }
48155 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48156 return resultobj;
48157 fail:
48158 return NULL;
48159 }
48160
48161
48162 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48163 PyObject *resultobj = 0;
48164 wxSizer *arg1 = (wxSizer *) 0 ;
48165 void *argp1 = 0 ;
48166 int res1 = 0 ;
48167 PyObject *swig_obj[1] ;
48168
48169 if (!args) SWIG_fail;
48170 swig_obj[0] = args;
48171 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48172 if (!SWIG_IsOK(res1)) {
48173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
48174 }
48175 arg1 = reinterpret_cast< wxSizer * >(argp1);
48176 {
48177 PyThreadState* __tstate = wxPyBeginAllowThreads();
48178 (arg1)->Layout();
48179 wxPyEndAllowThreads(__tstate);
48180 if (PyErr_Occurred()) SWIG_fail;
48181 }
48182 resultobj = SWIG_Py_Void();
48183 return resultobj;
48184 fail:
48185 return NULL;
48186 }
48187
48188
48189 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48190 PyObject *resultobj = 0;
48191 wxSizer *arg1 = (wxSizer *) 0 ;
48192 wxWindow *arg2 = (wxWindow *) 0 ;
48193 wxSize result;
48194 void *argp1 = 0 ;
48195 int res1 = 0 ;
48196 void *argp2 = 0 ;
48197 int res2 = 0 ;
48198 PyObject * obj0 = 0 ;
48199 PyObject * obj1 = 0 ;
48200 char * kwnames[] = {
48201 (char *) "self",(char *) "window", NULL
48202 };
48203
48204 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
48205 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48206 if (!SWIG_IsOK(res1)) {
48207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
48208 }
48209 arg1 = reinterpret_cast< wxSizer * >(argp1);
48210 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48211 if (!SWIG_IsOK(res2)) {
48212 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
48213 }
48214 arg2 = reinterpret_cast< wxWindow * >(argp2);
48215 {
48216 PyThreadState* __tstate = wxPyBeginAllowThreads();
48217 result = (arg1)->Fit(arg2);
48218 wxPyEndAllowThreads(__tstate);
48219 if (PyErr_Occurred()) SWIG_fail;
48220 }
48221 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48222 return resultobj;
48223 fail:
48224 return NULL;
48225 }
48226
48227
48228 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48229 PyObject *resultobj = 0;
48230 wxSizer *arg1 = (wxSizer *) 0 ;
48231 wxWindow *arg2 = (wxWindow *) 0 ;
48232 void *argp1 = 0 ;
48233 int res1 = 0 ;
48234 void *argp2 = 0 ;
48235 int res2 = 0 ;
48236 PyObject * obj0 = 0 ;
48237 PyObject * obj1 = 0 ;
48238 char * kwnames[] = {
48239 (char *) "self",(char *) "window", NULL
48240 };
48241
48242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
48243 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48244 if (!SWIG_IsOK(res1)) {
48245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
48246 }
48247 arg1 = reinterpret_cast< wxSizer * >(argp1);
48248 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48249 if (!SWIG_IsOK(res2)) {
48250 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
48251 }
48252 arg2 = reinterpret_cast< wxWindow * >(argp2);
48253 {
48254 PyThreadState* __tstate = wxPyBeginAllowThreads();
48255 (arg1)->FitInside(arg2);
48256 wxPyEndAllowThreads(__tstate);
48257 if (PyErr_Occurred()) SWIG_fail;
48258 }
48259 resultobj = SWIG_Py_Void();
48260 return resultobj;
48261 fail:
48262 return NULL;
48263 }
48264
48265
48266 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48267 PyObject *resultobj = 0;
48268 wxSizer *arg1 = (wxSizer *) 0 ;
48269 wxWindow *arg2 = (wxWindow *) 0 ;
48270 void *argp1 = 0 ;
48271 int res1 = 0 ;
48272 void *argp2 = 0 ;
48273 int res2 = 0 ;
48274 PyObject * obj0 = 0 ;
48275 PyObject * obj1 = 0 ;
48276 char * kwnames[] = {
48277 (char *) "self",(char *) "window", NULL
48278 };
48279
48280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
48281 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48282 if (!SWIG_IsOK(res1)) {
48283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
48284 }
48285 arg1 = reinterpret_cast< wxSizer * >(argp1);
48286 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48287 if (!SWIG_IsOK(res2)) {
48288 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
48289 }
48290 arg2 = reinterpret_cast< wxWindow * >(argp2);
48291 {
48292 PyThreadState* __tstate = wxPyBeginAllowThreads();
48293 (arg1)->SetSizeHints(arg2);
48294 wxPyEndAllowThreads(__tstate);
48295 if (PyErr_Occurred()) SWIG_fail;
48296 }
48297 resultobj = SWIG_Py_Void();
48298 return resultobj;
48299 fail:
48300 return NULL;
48301 }
48302
48303
48304 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48305 PyObject *resultobj = 0;
48306 wxSizer *arg1 = (wxSizer *) 0 ;
48307 wxWindow *arg2 = (wxWindow *) 0 ;
48308 void *argp1 = 0 ;
48309 int res1 = 0 ;
48310 void *argp2 = 0 ;
48311 int res2 = 0 ;
48312 PyObject * obj0 = 0 ;
48313 PyObject * obj1 = 0 ;
48314 char * kwnames[] = {
48315 (char *) "self",(char *) "window", NULL
48316 };
48317
48318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
48319 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48320 if (!SWIG_IsOK(res1)) {
48321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
48322 }
48323 arg1 = reinterpret_cast< wxSizer * >(argp1);
48324 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48325 if (!SWIG_IsOK(res2)) {
48326 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
48327 }
48328 arg2 = reinterpret_cast< wxWindow * >(argp2);
48329 {
48330 PyThreadState* __tstate = wxPyBeginAllowThreads();
48331 (arg1)->SetVirtualSizeHints(arg2);
48332 wxPyEndAllowThreads(__tstate);
48333 if (PyErr_Occurred()) SWIG_fail;
48334 }
48335 resultobj = SWIG_Py_Void();
48336 return resultobj;
48337 fail:
48338 return NULL;
48339 }
48340
48341
48342 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48343 PyObject *resultobj = 0;
48344 wxSizer *arg1 = (wxSizer *) 0 ;
48345 bool arg2 = (bool) false ;
48346 void *argp1 = 0 ;
48347 int res1 = 0 ;
48348 bool val2 ;
48349 int ecode2 = 0 ;
48350 PyObject * obj0 = 0 ;
48351 PyObject * obj1 = 0 ;
48352 char * kwnames[] = {
48353 (char *) "self",(char *) "deleteWindows", NULL
48354 };
48355
48356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
48357 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48358 if (!SWIG_IsOK(res1)) {
48359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
48360 }
48361 arg1 = reinterpret_cast< wxSizer * >(argp1);
48362 if (obj1) {
48363 ecode2 = SWIG_AsVal_bool(obj1, &val2);
48364 if (!SWIG_IsOK(ecode2)) {
48365 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
48366 }
48367 arg2 = static_cast< bool >(val2);
48368 }
48369 {
48370 PyThreadState* __tstate = wxPyBeginAllowThreads();
48371 (arg1)->Clear(arg2);
48372 wxPyEndAllowThreads(__tstate);
48373 if (PyErr_Occurred()) SWIG_fail;
48374 }
48375 resultobj = SWIG_Py_Void();
48376 return resultobj;
48377 fail:
48378 return NULL;
48379 }
48380
48381
48382 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48383 PyObject *resultobj = 0;
48384 wxSizer *arg1 = (wxSizer *) 0 ;
48385 void *argp1 = 0 ;
48386 int res1 = 0 ;
48387 PyObject *swig_obj[1] ;
48388
48389 if (!args) SWIG_fail;
48390 swig_obj[0] = args;
48391 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48392 if (!SWIG_IsOK(res1)) {
48393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
48394 }
48395 arg1 = reinterpret_cast< wxSizer * >(argp1);
48396 {
48397 PyThreadState* __tstate = wxPyBeginAllowThreads();
48398 (arg1)->DeleteWindows();
48399 wxPyEndAllowThreads(__tstate);
48400 if (PyErr_Occurred()) SWIG_fail;
48401 }
48402 resultobj = SWIG_Py_Void();
48403 return resultobj;
48404 fail:
48405 return NULL;
48406 }
48407
48408
48409 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48410 PyObject *resultobj = 0;
48411 wxSizer *arg1 = (wxSizer *) 0 ;
48412 PyObject *result = 0 ;
48413 void *argp1 = 0 ;
48414 int res1 = 0 ;
48415 PyObject *swig_obj[1] ;
48416
48417 if (!args) SWIG_fail;
48418 swig_obj[0] = args;
48419 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48420 if (!SWIG_IsOK(res1)) {
48421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
48422 }
48423 arg1 = reinterpret_cast< wxSizer * >(argp1);
48424 {
48425 PyThreadState* __tstate = wxPyBeginAllowThreads();
48426 result = (PyObject *)wxSizer_GetChildren(arg1);
48427 wxPyEndAllowThreads(__tstate);
48428 if (PyErr_Occurred()) SWIG_fail;
48429 }
48430 resultobj = result;
48431 return resultobj;
48432 fail:
48433 return NULL;
48434 }
48435
48436
48437 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48438 PyObject *resultobj = 0;
48439 wxSizer *arg1 = (wxSizer *) 0 ;
48440 PyObject *arg2 = (PyObject *) 0 ;
48441 bool arg3 = (bool) true ;
48442 bool arg4 = (bool) false ;
48443 bool result;
48444 void *argp1 = 0 ;
48445 int res1 = 0 ;
48446 bool val3 ;
48447 int ecode3 = 0 ;
48448 bool val4 ;
48449 int ecode4 = 0 ;
48450 PyObject * obj0 = 0 ;
48451 PyObject * obj1 = 0 ;
48452 PyObject * obj2 = 0 ;
48453 PyObject * obj3 = 0 ;
48454 char * kwnames[] = {
48455 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
48456 };
48457
48458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48460 if (!SWIG_IsOK(res1)) {
48461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
48462 }
48463 arg1 = reinterpret_cast< wxSizer * >(argp1);
48464 arg2 = obj1;
48465 if (obj2) {
48466 ecode3 = SWIG_AsVal_bool(obj2, &val3);
48467 if (!SWIG_IsOK(ecode3)) {
48468 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
48469 }
48470 arg3 = static_cast< bool >(val3);
48471 }
48472 if (obj3) {
48473 ecode4 = SWIG_AsVal_bool(obj3, &val4);
48474 if (!SWIG_IsOK(ecode4)) {
48475 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
48476 }
48477 arg4 = static_cast< bool >(val4);
48478 }
48479 {
48480 PyThreadState* __tstate = wxPyBeginAllowThreads();
48481 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
48482 wxPyEndAllowThreads(__tstate);
48483 if (PyErr_Occurred()) SWIG_fail;
48484 }
48485 {
48486 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48487 }
48488 return resultobj;
48489 fail:
48490 return NULL;
48491 }
48492
48493
48494 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48495 PyObject *resultobj = 0;
48496 wxSizer *arg1 = (wxSizer *) 0 ;
48497 PyObject *arg2 = (PyObject *) 0 ;
48498 bool result;
48499 void *argp1 = 0 ;
48500 int res1 = 0 ;
48501 PyObject * obj0 = 0 ;
48502 PyObject * obj1 = 0 ;
48503 char * kwnames[] = {
48504 (char *) "self",(char *) "item", NULL
48505 };
48506
48507 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
48508 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48509 if (!SWIG_IsOK(res1)) {
48510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
48511 }
48512 arg1 = reinterpret_cast< wxSizer * >(argp1);
48513 arg2 = obj1;
48514 {
48515 PyThreadState* __tstate = wxPyBeginAllowThreads();
48516 result = (bool)wxSizer_IsShown(arg1,arg2);
48517 wxPyEndAllowThreads(__tstate);
48518 if (PyErr_Occurred()) SWIG_fail;
48519 }
48520 {
48521 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48522 }
48523 return resultobj;
48524 fail:
48525 return NULL;
48526 }
48527
48528
48529 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48530 PyObject *resultobj = 0;
48531 wxSizer *arg1 = (wxSizer *) 0 ;
48532 bool arg2 ;
48533 void *argp1 = 0 ;
48534 int res1 = 0 ;
48535 bool val2 ;
48536 int ecode2 = 0 ;
48537 PyObject * obj0 = 0 ;
48538 PyObject * obj1 = 0 ;
48539 char * kwnames[] = {
48540 (char *) "self",(char *) "show", NULL
48541 };
48542
48543 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
48544 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48545 if (!SWIG_IsOK(res1)) {
48546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
48547 }
48548 arg1 = reinterpret_cast< wxSizer * >(argp1);
48549 ecode2 = SWIG_AsVal_bool(obj1, &val2);
48550 if (!SWIG_IsOK(ecode2)) {
48551 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
48552 }
48553 arg2 = static_cast< bool >(val2);
48554 {
48555 PyThreadState* __tstate = wxPyBeginAllowThreads();
48556 (arg1)->ShowItems(arg2);
48557 wxPyEndAllowThreads(__tstate);
48558 if (PyErr_Occurred()) SWIG_fail;
48559 }
48560 resultobj = SWIG_Py_Void();
48561 return resultobj;
48562 fail:
48563 return NULL;
48564 }
48565
48566
48567 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48568 PyObject *obj;
48569 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48570 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
48571 return SWIG_Py_Void();
48572 }
48573
48574 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48575 PyObject *resultobj = 0;
48576 wxPySizer *result = 0 ;
48577
48578 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
48579 {
48580 PyThreadState* __tstate = wxPyBeginAllowThreads();
48581 result = (wxPySizer *)new wxPySizer();
48582 wxPyEndAllowThreads(__tstate);
48583 if (PyErr_Occurred()) SWIG_fail;
48584 }
48585 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
48586 return resultobj;
48587 fail:
48588 return NULL;
48589 }
48590
48591
48592 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48593 PyObject *resultobj = 0;
48594 wxPySizer *arg1 = (wxPySizer *) 0 ;
48595 PyObject *arg2 = (PyObject *) 0 ;
48596 PyObject *arg3 = (PyObject *) 0 ;
48597 void *argp1 = 0 ;
48598 int res1 = 0 ;
48599 PyObject * obj0 = 0 ;
48600 PyObject * obj1 = 0 ;
48601 PyObject * obj2 = 0 ;
48602 char * kwnames[] = {
48603 (char *) "self",(char *) "self",(char *) "_class", NULL
48604 };
48605
48606 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48607 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
48608 if (!SWIG_IsOK(res1)) {
48609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
48610 }
48611 arg1 = reinterpret_cast< wxPySizer * >(argp1);
48612 arg2 = obj1;
48613 arg3 = obj2;
48614 {
48615 PyThreadState* __tstate = wxPyBeginAllowThreads();
48616 (arg1)->_setCallbackInfo(arg2,arg3);
48617 wxPyEndAllowThreads(__tstate);
48618 if (PyErr_Occurred()) SWIG_fail;
48619 }
48620 resultobj = SWIG_Py_Void();
48621 return resultobj;
48622 fail:
48623 return NULL;
48624 }
48625
48626
48627 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48628 PyObject *obj;
48629 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48630 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
48631 return SWIG_Py_Void();
48632 }
48633
48634 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48635 return SWIG_Python_InitShadowInstance(args);
48636 }
48637
48638 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48639 PyObject *resultobj = 0;
48640 int arg1 = (int) wxHORIZONTAL ;
48641 wxBoxSizer *result = 0 ;
48642 int val1 ;
48643 int ecode1 = 0 ;
48644 PyObject * obj0 = 0 ;
48645 char * kwnames[] = {
48646 (char *) "orient", NULL
48647 };
48648
48649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
48650 if (obj0) {
48651 ecode1 = SWIG_AsVal_int(obj0, &val1);
48652 if (!SWIG_IsOK(ecode1)) {
48653 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
48654 }
48655 arg1 = static_cast< int >(val1);
48656 }
48657 {
48658 PyThreadState* __tstate = wxPyBeginAllowThreads();
48659 result = (wxBoxSizer *)new wxBoxSizer(arg1);
48660 wxPyEndAllowThreads(__tstate);
48661 if (PyErr_Occurred()) SWIG_fail;
48662 }
48663 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
48664 return resultobj;
48665 fail:
48666 return NULL;
48667 }
48668
48669
48670 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48671 PyObject *resultobj = 0;
48672 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
48673 int result;
48674 void *argp1 = 0 ;
48675 int res1 = 0 ;
48676 PyObject *swig_obj[1] ;
48677
48678 if (!args) SWIG_fail;
48679 swig_obj[0] = args;
48680 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
48681 if (!SWIG_IsOK(res1)) {
48682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
48683 }
48684 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
48685 {
48686 PyThreadState* __tstate = wxPyBeginAllowThreads();
48687 result = (int)(arg1)->GetOrientation();
48688 wxPyEndAllowThreads(__tstate);
48689 if (PyErr_Occurred()) SWIG_fail;
48690 }
48691 resultobj = SWIG_From_int(static_cast< int >(result));
48692 return resultobj;
48693 fail:
48694 return NULL;
48695 }
48696
48697
48698 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48699 PyObject *resultobj = 0;
48700 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
48701 int arg2 ;
48702 void *argp1 = 0 ;
48703 int res1 = 0 ;
48704 int val2 ;
48705 int ecode2 = 0 ;
48706 PyObject * obj0 = 0 ;
48707 PyObject * obj1 = 0 ;
48708 char * kwnames[] = {
48709 (char *) "self",(char *) "orient", NULL
48710 };
48711
48712 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
48713 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
48714 if (!SWIG_IsOK(res1)) {
48715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
48716 }
48717 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
48718 ecode2 = SWIG_AsVal_int(obj1, &val2);
48719 if (!SWIG_IsOK(ecode2)) {
48720 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
48721 }
48722 arg2 = static_cast< int >(val2);
48723 {
48724 PyThreadState* __tstate = wxPyBeginAllowThreads();
48725 (arg1)->SetOrientation(arg2);
48726 wxPyEndAllowThreads(__tstate);
48727 if (PyErr_Occurred()) SWIG_fail;
48728 }
48729 resultobj = SWIG_Py_Void();
48730 return resultobj;
48731 fail:
48732 return NULL;
48733 }
48734
48735
48736 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48737 PyObject *obj;
48738 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48739 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
48740 return SWIG_Py_Void();
48741 }
48742
48743 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48744 return SWIG_Python_InitShadowInstance(args);
48745 }
48746
48747 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48748 PyObject *resultobj = 0;
48749 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
48750 int arg2 = (int) wxHORIZONTAL ;
48751 wxStaticBoxSizer *result = 0 ;
48752 void *argp1 = 0 ;
48753 int res1 = 0 ;
48754 int val2 ;
48755 int ecode2 = 0 ;
48756 PyObject * obj0 = 0 ;
48757 PyObject * obj1 = 0 ;
48758 char * kwnames[] = {
48759 (char *) "box",(char *) "orient", NULL
48760 };
48761
48762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
48763 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
48764 if (!SWIG_IsOK(res1)) {
48765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
48766 }
48767 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
48768 if (obj1) {
48769 ecode2 = SWIG_AsVal_int(obj1, &val2);
48770 if (!SWIG_IsOK(ecode2)) {
48771 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
48772 }
48773 arg2 = static_cast< int >(val2);
48774 }
48775 {
48776 PyThreadState* __tstate = wxPyBeginAllowThreads();
48777 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
48778 wxPyEndAllowThreads(__tstate);
48779 if (PyErr_Occurred()) SWIG_fail;
48780 }
48781 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
48782 return resultobj;
48783 fail:
48784 return NULL;
48785 }
48786
48787
48788 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48789 PyObject *resultobj = 0;
48790 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
48791 wxStaticBox *result = 0 ;
48792 void *argp1 = 0 ;
48793 int res1 = 0 ;
48794 PyObject *swig_obj[1] ;
48795
48796 if (!args) SWIG_fail;
48797 swig_obj[0] = args;
48798 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
48799 if (!SWIG_IsOK(res1)) {
48800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
48801 }
48802 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
48803 {
48804 PyThreadState* __tstate = wxPyBeginAllowThreads();
48805 result = (wxStaticBox *)(arg1)->GetStaticBox();
48806 wxPyEndAllowThreads(__tstate);
48807 if (PyErr_Occurred()) SWIG_fail;
48808 }
48809 {
48810 resultobj = wxPyMake_wxObject(result, (bool)0);
48811 }
48812 return resultobj;
48813 fail:
48814 return NULL;
48815 }
48816
48817
48818 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48819 PyObject *obj;
48820 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48821 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
48822 return SWIG_Py_Void();
48823 }
48824
48825 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48826 return SWIG_Python_InitShadowInstance(args);
48827 }
48828
48829 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48830 PyObject *resultobj = 0;
48831 int arg1 = (int) 1 ;
48832 int arg2 = (int) 0 ;
48833 int arg3 = (int) 0 ;
48834 int arg4 = (int) 0 ;
48835 wxGridSizer *result = 0 ;
48836 int val1 ;
48837 int ecode1 = 0 ;
48838 int val2 ;
48839 int ecode2 = 0 ;
48840 int val3 ;
48841 int ecode3 = 0 ;
48842 int val4 ;
48843 int ecode4 = 0 ;
48844 PyObject * obj0 = 0 ;
48845 PyObject * obj1 = 0 ;
48846 PyObject * obj2 = 0 ;
48847 PyObject * obj3 = 0 ;
48848 char * kwnames[] = {
48849 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
48850 };
48851
48852 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48853 if (obj0) {
48854 ecode1 = SWIG_AsVal_int(obj0, &val1);
48855 if (!SWIG_IsOK(ecode1)) {
48856 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
48857 }
48858 arg1 = static_cast< int >(val1);
48859 }
48860 if (obj1) {
48861 ecode2 = SWIG_AsVal_int(obj1, &val2);
48862 if (!SWIG_IsOK(ecode2)) {
48863 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
48864 }
48865 arg2 = static_cast< int >(val2);
48866 }
48867 if (obj2) {
48868 ecode3 = SWIG_AsVal_int(obj2, &val3);
48869 if (!SWIG_IsOK(ecode3)) {
48870 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
48871 }
48872 arg3 = static_cast< int >(val3);
48873 }
48874 if (obj3) {
48875 ecode4 = SWIG_AsVal_int(obj3, &val4);
48876 if (!SWIG_IsOK(ecode4)) {
48877 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
48878 }
48879 arg4 = static_cast< int >(val4);
48880 }
48881 {
48882 PyThreadState* __tstate = wxPyBeginAllowThreads();
48883 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
48884 wxPyEndAllowThreads(__tstate);
48885 if (PyErr_Occurred()) SWIG_fail;
48886 }
48887 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
48888 return resultobj;
48889 fail:
48890 return NULL;
48891 }
48892
48893
48894 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48895 PyObject *resultobj = 0;
48896 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48897 int arg2 ;
48898 void *argp1 = 0 ;
48899 int res1 = 0 ;
48900 int val2 ;
48901 int ecode2 = 0 ;
48902 PyObject * obj0 = 0 ;
48903 PyObject * obj1 = 0 ;
48904 char * kwnames[] = {
48905 (char *) "self",(char *) "cols", NULL
48906 };
48907
48908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
48909 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48910 if (!SWIG_IsOK(res1)) {
48911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48912 }
48913 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48914 ecode2 = SWIG_AsVal_int(obj1, &val2);
48915 if (!SWIG_IsOK(ecode2)) {
48916 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
48917 }
48918 arg2 = static_cast< int >(val2);
48919 {
48920 PyThreadState* __tstate = wxPyBeginAllowThreads();
48921 (arg1)->SetCols(arg2);
48922 wxPyEndAllowThreads(__tstate);
48923 if (PyErr_Occurred()) SWIG_fail;
48924 }
48925 resultobj = SWIG_Py_Void();
48926 return resultobj;
48927 fail:
48928 return NULL;
48929 }
48930
48931
48932 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48933 PyObject *resultobj = 0;
48934 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48935 int arg2 ;
48936 void *argp1 = 0 ;
48937 int res1 = 0 ;
48938 int val2 ;
48939 int ecode2 = 0 ;
48940 PyObject * obj0 = 0 ;
48941 PyObject * obj1 = 0 ;
48942 char * kwnames[] = {
48943 (char *) "self",(char *) "rows", NULL
48944 };
48945
48946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
48947 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48948 if (!SWIG_IsOK(res1)) {
48949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48950 }
48951 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48952 ecode2 = SWIG_AsVal_int(obj1, &val2);
48953 if (!SWIG_IsOK(ecode2)) {
48954 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
48955 }
48956 arg2 = static_cast< int >(val2);
48957 {
48958 PyThreadState* __tstate = wxPyBeginAllowThreads();
48959 (arg1)->SetRows(arg2);
48960 wxPyEndAllowThreads(__tstate);
48961 if (PyErr_Occurred()) SWIG_fail;
48962 }
48963 resultobj = SWIG_Py_Void();
48964 return resultobj;
48965 fail:
48966 return NULL;
48967 }
48968
48969
48970 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48971 PyObject *resultobj = 0;
48972 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48973 int arg2 ;
48974 void *argp1 = 0 ;
48975 int res1 = 0 ;
48976 int val2 ;
48977 int ecode2 = 0 ;
48978 PyObject * obj0 = 0 ;
48979 PyObject * obj1 = 0 ;
48980 char * kwnames[] = {
48981 (char *) "self",(char *) "gap", NULL
48982 };
48983
48984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
48985 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48986 if (!SWIG_IsOK(res1)) {
48987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48988 }
48989 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48990 ecode2 = SWIG_AsVal_int(obj1, &val2);
48991 if (!SWIG_IsOK(ecode2)) {
48992 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
48993 }
48994 arg2 = static_cast< int >(val2);
48995 {
48996 PyThreadState* __tstate = wxPyBeginAllowThreads();
48997 (arg1)->SetVGap(arg2);
48998 wxPyEndAllowThreads(__tstate);
48999 if (PyErr_Occurred()) SWIG_fail;
49000 }
49001 resultobj = SWIG_Py_Void();
49002 return resultobj;
49003 fail:
49004 return NULL;
49005 }
49006
49007
49008 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49009 PyObject *resultobj = 0;
49010 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49011 int arg2 ;
49012 void *argp1 = 0 ;
49013 int res1 = 0 ;
49014 int val2 ;
49015 int ecode2 = 0 ;
49016 PyObject * obj0 = 0 ;
49017 PyObject * obj1 = 0 ;
49018 char * kwnames[] = {
49019 (char *) "self",(char *) "gap", NULL
49020 };
49021
49022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
49023 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49024 if (!SWIG_IsOK(res1)) {
49025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49026 }
49027 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49028 ecode2 = SWIG_AsVal_int(obj1, &val2);
49029 if (!SWIG_IsOK(ecode2)) {
49030 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
49031 }
49032 arg2 = static_cast< int >(val2);
49033 {
49034 PyThreadState* __tstate = wxPyBeginAllowThreads();
49035 (arg1)->SetHGap(arg2);
49036 wxPyEndAllowThreads(__tstate);
49037 if (PyErr_Occurred()) SWIG_fail;
49038 }
49039 resultobj = SWIG_Py_Void();
49040 return resultobj;
49041 fail:
49042 return NULL;
49043 }
49044
49045
49046 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49047 PyObject *resultobj = 0;
49048 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49049 int result;
49050 void *argp1 = 0 ;
49051 int res1 = 0 ;
49052 PyObject *swig_obj[1] ;
49053
49054 if (!args) SWIG_fail;
49055 swig_obj[0] = args;
49056 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49057 if (!SWIG_IsOK(res1)) {
49058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49059 }
49060 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49061 {
49062 PyThreadState* __tstate = wxPyBeginAllowThreads();
49063 result = (int)(arg1)->GetCols();
49064 wxPyEndAllowThreads(__tstate);
49065 if (PyErr_Occurred()) SWIG_fail;
49066 }
49067 resultobj = SWIG_From_int(static_cast< int >(result));
49068 return resultobj;
49069 fail:
49070 return NULL;
49071 }
49072
49073
49074 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49075 PyObject *resultobj = 0;
49076 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49077 int result;
49078 void *argp1 = 0 ;
49079 int res1 = 0 ;
49080 PyObject *swig_obj[1] ;
49081
49082 if (!args) SWIG_fail;
49083 swig_obj[0] = args;
49084 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49085 if (!SWIG_IsOK(res1)) {
49086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49087 }
49088 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49089 {
49090 PyThreadState* __tstate = wxPyBeginAllowThreads();
49091 result = (int)(arg1)->GetRows();
49092 wxPyEndAllowThreads(__tstate);
49093 if (PyErr_Occurred()) SWIG_fail;
49094 }
49095 resultobj = SWIG_From_int(static_cast< int >(result));
49096 return resultobj;
49097 fail:
49098 return NULL;
49099 }
49100
49101
49102 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49103 PyObject *resultobj = 0;
49104 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49105 int result;
49106 void *argp1 = 0 ;
49107 int res1 = 0 ;
49108 PyObject *swig_obj[1] ;
49109
49110 if (!args) SWIG_fail;
49111 swig_obj[0] = args;
49112 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49113 if (!SWIG_IsOK(res1)) {
49114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49115 }
49116 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49117 {
49118 PyThreadState* __tstate = wxPyBeginAllowThreads();
49119 result = (int)(arg1)->GetVGap();
49120 wxPyEndAllowThreads(__tstate);
49121 if (PyErr_Occurred()) SWIG_fail;
49122 }
49123 resultobj = SWIG_From_int(static_cast< int >(result));
49124 return resultobj;
49125 fail:
49126 return NULL;
49127 }
49128
49129
49130 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49131 PyObject *resultobj = 0;
49132 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49133 int result;
49134 void *argp1 = 0 ;
49135 int res1 = 0 ;
49136 PyObject *swig_obj[1] ;
49137
49138 if (!args) SWIG_fail;
49139 swig_obj[0] = args;
49140 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49141 if (!SWIG_IsOK(res1)) {
49142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49143 }
49144 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49145 {
49146 PyThreadState* __tstate = wxPyBeginAllowThreads();
49147 result = (int)(arg1)->GetHGap();
49148 wxPyEndAllowThreads(__tstate);
49149 if (PyErr_Occurred()) SWIG_fail;
49150 }
49151 resultobj = SWIG_From_int(static_cast< int >(result));
49152 return resultobj;
49153 fail:
49154 return NULL;
49155 }
49156
49157
49158 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49159 PyObject *obj;
49160 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49161 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
49162 return SWIG_Py_Void();
49163 }
49164
49165 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49166 return SWIG_Python_InitShadowInstance(args);
49167 }
49168
49169 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49170 PyObject *resultobj = 0;
49171 int arg1 = (int) 1 ;
49172 int arg2 = (int) 0 ;
49173 int arg3 = (int) 0 ;
49174 int arg4 = (int) 0 ;
49175 wxFlexGridSizer *result = 0 ;
49176 int val1 ;
49177 int ecode1 = 0 ;
49178 int val2 ;
49179 int ecode2 = 0 ;
49180 int val3 ;
49181 int ecode3 = 0 ;
49182 int val4 ;
49183 int ecode4 = 0 ;
49184 PyObject * obj0 = 0 ;
49185 PyObject * obj1 = 0 ;
49186 PyObject * obj2 = 0 ;
49187 PyObject * obj3 = 0 ;
49188 char * kwnames[] = {
49189 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
49190 };
49191
49192 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
49193 if (obj0) {
49194 ecode1 = SWIG_AsVal_int(obj0, &val1);
49195 if (!SWIG_IsOK(ecode1)) {
49196 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
49197 }
49198 arg1 = static_cast< int >(val1);
49199 }
49200 if (obj1) {
49201 ecode2 = SWIG_AsVal_int(obj1, &val2);
49202 if (!SWIG_IsOK(ecode2)) {
49203 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
49204 }
49205 arg2 = static_cast< int >(val2);
49206 }
49207 if (obj2) {
49208 ecode3 = SWIG_AsVal_int(obj2, &val3);
49209 if (!SWIG_IsOK(ecode3)) {
49210 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
49211 }
49212 arg3 = static_cast< int >(val3);
49213 }
49214 if (obj3) {
49215 ecode4 = SWIG_AsVal_int(obj3, &val4);
49216 if (!SWIG_IsOK(ecode4)) {
49217 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
49218 }
49219 arg4 = static_cast< int >(val4);
49220 }
49221 {
49222 PyThreadState* __tstate = wxPyBeginAllowThreads();
49223 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
49224 wxPyEndAllowThreads(__tstate);
49225 if (PyErr_Occurred()) SWIG_fail;
49226 }
49227 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
49228 return resultobj;
49229 fail:
49230 return NULL;
49231 }
49232
49233
49234 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49235 PyObject *resultobj = 0;
49236 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49237 size_t arg2 ;
49238 int arg3 = (int) 0 ;
49239 void *argp1 = 0 ;
49240 int res1 = 0 ;
49241 size_t val2 ;
49242 int ecode2 = 0 ;
49243 int val3 ;
49244 int ecode3 = 0 ;
49245 PyObject * obj0 = 0 ;
49246 PyObject * obj1 = 0 ;
49247 PyObject * obj2 = 0 ;
49248 char * kwnames[] = {
49249 (char *) "self",(char *) "idx",(char *) "proportion", NULL
49250 };
49251
49252 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49253 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49254 if (!SWIG_IsOK(res1)) {
49255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49256 }
49257 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49258 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49259 if (!SWIG_IsOK(ecode2)) {
49260 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
49261 }
49262 arg2 = static_cast< size_t >(val2);
49263 if (obj2) {
49264 ecode3 = SWIG_AsVal_int(obj2, &val3);
49265 if (!SWIG_IsOK(ecode3)) {
49266 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
49267 }
49268 arg3 = static_cast< int >(val3);
49269 }
49270 {
49271 PyThreadState* __tstate = wxPyBeginAllowThreads();
49272 (arg1)->AddGrowableRow(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_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49284 PyObject *resultobj = 0;
49285 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49286 size_t arg2 ;
49287 void *argp1 = 0 ;
49288 int res1 = 0 ;
49289 size_t val2 ;
49290 int ecode2 = 0 ;
49291 PyObject * obj0 = 0 ;
49292 PyObject * obj1 = 0 ;
49293 char * kwnames[] = {
49294 (char *) "self",(char *) "idx", NULL
49295 };
49296
49297 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
49298 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49299 if (!SWIG_IsOK(res1)) {
49300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49301 }
49302 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49303 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49304 if (!SWIG_IsOK(ecode2)) {
49305 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
49306 }
49307 arg2 = static_cast< size_t >(val2);
49308 {
49309 PyThreadState* __tstate = wxPyBeginAllowThreads();
49310 (arg1)->RemoveGrowableRow(arg2);
49311 wxPyEndAllowThreads(__tstate);
49312 if (PyErr_Occurred()) SWIG_fail;
49313 }
49314 resultobj = SWIG_Py_Void();
49315 return resultobj;
49316 fail:
49317 return NULL;
49318 }
49319
49320
49321 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49322 PyObject *resultobj = 0;
49323 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49324 size_t arg2 ;
49325 int arg3 = (int) 0 ;
49326 void *argp1 = 0 ;
49327 int res1 = 0 ;
49328 size_t val2 ;
49329 int ecode2 = 0 ;
49330 int val3 ;
49331 int ecode3 = 0 ;
49332 PyObject * obj0 = 0 ;
49333 PyObject * obj1 = 0 ;
49334 PyObject * obj2 = 0 ;
49335 char * kwnames[] = {
49336 (char *) "self",(char *) "idx",(char *) "proportion", NULL
49337 };
49338
49339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49340 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49341 if (!SWIG_IsOK(res1)) {
49342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49343 }
49344 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49345 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49346 if (!SWIG_IsOK(ecode2)) {
49347 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
49348 }
49349 arg2 = static_cast< size_t >(val2);
49350 if (obj2) {
49351 ecode3 = SWIG_AsVal_int(obj2, &val3);
49352 if (!SWIG_IsOK(ecode3)) {
49353 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
49354 }
49355 arg3 = static_cast< int >(val3);
49356 }
49357 {
49358 PyThreadState* __tstate = wxPyBeginAllowThreads();
49359 (arg1)->AddGrowableCol(arg2,arg3);
49360 wxPyEndAllowThreads(__tstate);
49361 if (PyErr_Occurred()) SWIG_fail;
49362 }
49363 resultobj = SWIG_Py_Void();
49364 return resultobj;
49365 fail:
49366 return NULL;
49367 }
49368
49369
49370 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49371 PyObject *resultobj = 0;
49372 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49373 size_t arg2 ;
49374 void *argp1 = 0 ;
49375 int res1 = 0 ;
49376 size_t val2 ;
49377 int ecode2 = 0 ;
49378 PyObject * obj0 = 0 ;
49379 PyObject * obj1 = 0 ;
49380 char * kwnames[] = {
49381 (char *) "self",(char *) "idx", NULL
49382 };
49383
49384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
49385 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49386 if (!SWIG_IsOK(res1)) {
49387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49388 }
49389 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49390 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49391 if (!SWIG_IsOK(ecode2)) {
49392 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
49393 }
49394 arg2 = static_cast< size_t >(val2);
49395 {
49396 PyThreadState* __tstate = wxPyBeginAllowThreads();
49397 (arg1)->RemoveGrowableCol(arg2);
49398 wxPyEndAllowThreads(__tstate);
49399 if (PyErr_Occurred()) SWIG_fail;
49400 }
49401 resultobj = SWIG_Py_Void();
49402 return resultobj;
49403 fail:
49404 return NULL;
49405 }
49406
49407
49408 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49409 PyObject *resultobj = 0;
49410 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49411 int arg2 ;
49412 void *argp1 = 0 ;
49413 int res1 = 0 ;
49414 int val2 ;
49415 int ecode2 = 0 ;
49416 PyObject * obj0 = 0 ;
49417 PyObject * obj1 = 0 ;
49418 char * kwnames[] = {
49419 (char *) "self",(char *) "direction", NULL
49420 };
49421
49422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
49423 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49424 if (!SWIG_IsOK(res1)) {
49425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49426 }
49427 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49428 ecode2 = SWIG_AsVal_int(obj1, &val2);
49429 if (!SWIG_IsOK(ecode2)) {
49430 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
49431 }
49432 arg2 = static_cast< int >(val2);
49433 {
49434 PyThreadState* __tstate = wxPyBeginAllowThreads();
49435 (arg1)->SetFlexibleDirection(arg2);
49436 wxPyEndAllowThreads(__tstate);
49437 if (PyErr_Occurred()) SWIG_fail;
49438 }
49439 resultobj = SWIG_Py_Void();
49440 return resultobj;
49441 fail:
49442 return NULL;
49443 }
49444
49445
49446 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49447 PyObject *resultobj = 0;
49448 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49449 int result;
49450 void *argp1 = 0 ;
49451 int res1 = 0 ;
49452 PyObject *swig_obj[1] ;
49453
49454 if (!args) SWIG_fail;
49455 swig_obj[0] = args;
49456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49457 if (!SWIG_IsOK(res1)) {
49458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49459 }
49460 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49461 {
49462 PyThreadState* __tstate = wxPyBeginAllowThreads();
49463 result = (int)(arg1)->GetFlexibleDirection();
49464 wxPyEndAllowThreads(__tstate);
49465 if (PyErr_Occurred()) SWIG_fail;
49466 }
49467 resultobj = SWIG_From_int(static_cast< int >(result));
49468 return resultobj;
49469 fail:
49470 return NULL;
49471 }
49472
49473
49474 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49475 PyObject *resultobj = 0;
49476 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49477 wxFlexSizerGrowMode arg2 ;
49478 void *argp1 = 0 ;
49479 int res1 = 0 ;
49480 int val2 ;
49481 int ecode2 = 0 ;
49482 PyObject * obj0 = 0 ;
49483 PyObject * obj1 = 0 ;
49484 char * kwnames[] = {
49485 (char *) "self",(char *) "mode", NULL
49486 };
49487
49488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
49489 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49490 if (!SWIG_IsOK(res1)) {
49491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49492 }
49493 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49494 ecode2 = SWIG_AsVal_int(obj1, &val2);
49495 if (!SWIG_IsOK(ecode2)) {
49496 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
49497 }
49498 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
49499 {
49500 PyThreadState* __tstate = wxPyBeginAllowThreads();
49501 (arg1)->SetNonFlexibleGrowMode(arg2);
49502 wxPyEndAllowThreads(__tstate);
49503 if (PyErr_Occurred()) SWIG_fail;
49504 }
49505 resultobj = SWIG_Py_Void();
49506 return resultobj;
49507 fail:
49508 return NULL;
49509 }
49510
49511
49512 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49513 PyObject *resultobj = 0;
49514 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49515 wxFlexSizerGrowMode result;
49516 void *argp1 = 0 ;
49517 int res1 = 0 ;
49518 PyObject *swig_obj[1] ;
49519
49520 if (!args) SWIG_fail;
49521 swig_obj[0] = args;
49522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49523 if (!SWIG_IsOK(res1)) {
49524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49525 }
49526 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49527 {
49528 PyThreadState* __tstate = wxPyBeginAllowThreads();
49529 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
49530 wxPyEndAllowThreads(__tstate);
49531 if (PyErr_Occurred()) SWIG_fail;
49532 }
49533 resultobj = SWIG_From_int(static_cast< int >(result));
49534 return resultobj;
49535 fail:
49536 return NULL;
49537 }
49538
49539
49540 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49541 PyObject *resultobj = 0;
49542 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49543 wxArrayInt *result = 0 ;
49544 void *argp1 = 0 ;
49545 int res1 = 0 ;
49546 PyObject *swig_obj[1] ;
49547
49548 if (!args) SWIG_fail;
49549 swig_obj[0] = args;
49550 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49551 if (!SWIG_IsOK(res1)) {
49552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
49553 }
49554 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49555 {
49556 PyThreadState* __tstate = wxPyBeginAllowThreads();
49557 {
49558 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
49559 result = (wxArrayInt *) &_result_ref;
49560 }
49561 wxPyEndAllowThreads(__tstate);
49562 if (PyErr_Occurred()) SWIG_fail;
49563 }
49564 {
49565 resultobj = PyList_New(0);
49566 size_t idx;
49567 for (idx = 0; idx < result->GetCount(); idx += 1) {
49568 PyObject* val = PyInt_FromLong( result->Item(idx) );
49569 PyList_Append(resultobj, val);
49570 Py_DECREF(val);
49571 }
49572 }
49573 return resultobj;
49574 fail:
49575 return NULL;
49576 }
49577
49578
49579 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49580 PyObject *resultobj = 0;
49581 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49582 wxArrayInt *result = 0 ;
49583 void *argp1 = 0 ;
49584 int res1 = 0 ;
49585 PyObject *swig_obj[1] ;
49586
49587 if (!args) SWIG_fail;
49588 swig_obj[0] = args;
49589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49590 if (!SWIG_IsOK(res1)) {
49591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
49592 }
49593 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49594 {
49595 PyThreadState* __tstate = wxPyBeginAllowThreads();
49596 {
49597 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
49598 result = (wxArrayInt *) &_result_ref;
49599 }
49600 wxPyEndAllowThreads(__tstate);
49601 if (PyErr_Occurred()) SWIG_fail;
49602 }
49603 {
49604 resultobj = PyList_New(0);
49605 size_t idx;
49606 for (idx = 0; idx < result->GetCount(); idx += 1) {
49607 PyObject* val = PyInt_FromLong( result->Item(idx) );
49608 PyList_Append(resultobj, val);
49609 Py_DECREF(val);
49610 }
49611 }
49612 return resultobj;
49613 fail:
49614 return NULL;
49615 }
49616
49617
49618 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49619 PyObject *obj;
49620 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49621 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
49622 return SWIG_Py_Void();
49623 }
49624
49625 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49626 return SWIG_Python_InitShadowInstance(args);
49627 }
49628
49629 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49630 PyObject *resultobj = 0;
49631 wxStdDialogButtonSizer *result = 0 ;
49632
49633 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
49634 {
49635 PyThreadState* __tstate = wxPyBeginAllowThreads();
49636 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
49637 wxPyEndAllowThreads(__tstate);
49638 if (PyErr_Occurred()) SWIG_fail;
49639 }
49640 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
49641 return resultobj;
49642 fail:
49643 return NULL;
49644 }
49645
49646
49647 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49648 PyObject *resultobj = 0;
49649 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49650 wxButton *arg2 = (wxButton *) 0 ;
49651 void *argp1 = 0 ;
49652 int res1 = 0 ;
49653 void *argp2 = 0 ;
49654 int res2 = 0 ;
49655 PyObject * obj0 = 0 ;
49656 PyObject * obj1 = 0 ;
49657 char * kwnames[] = {
49658 (char *) "self",(char *) "button", NULL
49659 };
49660
49661 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
49662 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49663 if (!SWIG_IsOK(res1)) {
49664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
49665 }
49666 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49667 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
49668 if (!SWIG_IsOK(res2)) {
49669 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
49670 }
49671 arg2 = reinterpret_cast< wxButton * >(argp2);
49672 {
49673 PyThreadState* __tstate = wxPyBeginAllowThreads();
49674 (arg1)->AddButton(arg2);
49675 wxPyEndAllowThreads(__tstate);
49676 if (PyErr_Occurred()) SWIG_fail;
49677 }
49678 resultobj = SWIG_Py_Void();
49679 return resultobj;
49680 fail:
49681 return NULL;
49682 }
49683
49684
49685 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49686 PyObject *resultobj = 0;
49687 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49688 void *argp1 = 0 ;
49689 int res1 = 0 ;
49690 PyObject *swig_obj[1] ;
49691
49692 if (!args) SWIG_fail;
49693 swig_obj[0] = args;
49694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49695 if (!SWIG_IsOK(res1)) {
49696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
49697 }
49698 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49699 {
49700 PyThreadState* __tstate = wxPyBeginAllowThreads();
49701 (arg1)->Realize();
49702 wxPyEndAllowThreads(__tstate);
49703 if (PyErr_Occurred()) SWIG_fail;
49704 }
49705 resultobj = SWIG_Py_Void();
49706 return resultobj;
49707 fail:
49708 return NULL;
49709 }
49710
49711
49712 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49713 PyObject *resultobj = 0;
49714 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49715 wxButton *arg2 = (wxButton *) 0 ;
49716 void *argp1 = 0 ;
49717 int res1 = 0 ;
49718 void *argp2 = 0 ;
49719 int res2 = 0 ;
49720 PyObject * obj0 = 0 ;
49721 PyObject * obj1 = 0 ;
49722 char * kwnames[] = {
49723 (char *) "self",(char *) "button", NULL
49724 };
49725
49726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
49727 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49728 if (!SWIG_IsOK(res1)) {
49729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
49730 }
49731 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49732 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
49733 if (!SWIG_IsOK(res2)) {
49734 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
49735 }
49736 arg2 = reinterpret_cast< wxButton * >(argp2);
49737 {
49738 PyThreadState* __tstate = wxPyBeginAllowThreads();
49739 (arg1)->SetAffirmativeButton(arg2);
49740 wxPyEndAllowThreads(__tstate);
49741 if (PyErr_Occurred()) SWIG_fail;
49742 }
49743 resultobj = SWIG_Py_Void();
49744 return resultobj;
49745 fail:
49746 return NULL;
49747 }
49748
49749
49750 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49751 PyObject *resultobj = 0;
49752 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49753 wxButton *arg2 = (wxButton *) 0 ;
49754 void *argp1 = 0 ;
49755 int res1 = 0 ;
49756 void *argp2 = 0 ;
49757 int res2 = 0 ;
49758 PyObject * obj0 = 0 ;
49759 PyObject * obj1 = 0 ;
49760 char * kwnames[] = {
49761 (char *) "self",(char *) "button", NULL
49762 };
49763
49764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
49765 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49766 if (!SWIG_IsOK(res1)) {
49767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
49768 }
49769 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49770 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
49771 if (!SWIG_IsOK(res2)) {
49772 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
49773 }
49774 arg2 = reinterpret_cast< wxButton * >(argp2);
49775 {
49776 PyThreadState* __tstate = wxPyBeginAllowThreads();
49777 (arg1)->SetNegativeButton(arg2);
49778 wxPyEndAllowThreads(__tstate);
49779 if (PyErr_Occurred()) SWIG_fail;
49780 }
49781 resultobj = SWIG_Py_Void();
49782 return resultobj;
49783 fail:
49784 return NULL;
49785 }
49786
49787
49788 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49789 PyObject *resultobj = 0;
49790 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49791 wxButton *arg2 = (wxButton *) 0 ;
49792 void *argp1 = 0 ;
49793 int res1 = 0 ;
49794 void *argp2 = 0 ;
49795 int res2 = 0 ;
49796 PyObject * obj0 = 0 ;
49797 PyObject * obj1 = 0 ;
49798 char * kwnames[] = {
49799 (char *) "self",(char *) "button", NULL
49800 };
49801
49802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
49803 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49804 if (!SWIG_IsOK(res1)) {
49805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
49806 }
49807 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49808 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
49809 if (!SWIG_IsOK(res2)) {
49810 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
49811 }
49812 arg2 = reinterpret_cast< wxButton * >(argp2);
49813 {
49814 PyThreadState* __tstate = wxPyBeginAllowThreads();
49815 (arg1)->SetCancelButton(arg2);
49816 wxPyEndAllowThreads(__tstate);
49817 if (PyErr_Occurred()) SWIG_fail;
49818 }
49819 resultobj = SWIG_Py_Void();
49820 return resultobj;
49821 fail:
49822 return NULL;
49823 }
49824
49825
49826 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49827 PyObject *resultobj = 0;
49828 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49829 wxButton *result = 0 ;
49830 void *argp1 = 0 ;
49831 int res1 = 0 ;
49832 PyObject *swig_obj[1] ;
49833
49834 if (!args) SWIG_fail;
49835 swig_obj[0] = args;
49836 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49837 if (!SWIG_IsOK(res1)) {
49838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49839 }
49840 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49841 {
49842 PyThreadState* __tstate = wxPyBeginAllowThreads();
49843 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
49844 wxPyEndAllowThreads(__tstate);
49845 if (PyErr_Occurred()) SWIG_fail;
49846 }
49847 {
49848 resultobj = wxPyMake_wxObject(result, (bool)0);
49849 }
49850 return resultobj;
49851 fail:
49852 return NULL;
49853 }
49854
49855
49856 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49857 PyObject *resultobj = 0;
49858 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49859 wxButton *result = 0 ;
49860 void *argp1 = 0 ;
49861 int res1 = 0 ;
49862 PyObject *swig_obj[1] ;
49863
49864 if (!args) SWIG_fail;
49865 swig_obj[0] = args;
49866 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49867 if (!SWIG_IsOK(res1)) {
49868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49869 }
49870 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49871 {
49872 PyThreadState* __tstate = wxPyBeginAllowThreads();
49873 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
49874 wxPyEndAllowThreads(__tstate);
49875 if (PyErr_Occurred()) SWIG_fail;
49876 }
49877 {
49878 resultobj = wxPyMake_wxObject(result, (bool)0);
49879 }
49880 return resultobj;
49881 fail:
49882 return NULL;
49883 }
49884
49885
49886 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49887 PyObject *resultobj = 0;
49888 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49889 wxButton *result = 0 ;
49890 void *argp1 = 0 ;
49891 int res1 = 0 ;
49892 PyObject *swig_obj[1] ;
49893
49894 if (!args) SWIG_fail;
49895 swig_obj[0] = args;
49896 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49897 if (!SWIG_IsOK(res1)) {
49898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49899 }
49900 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49901 {
49902 PyThreadState* __tstate = wxPyBeginAllowThreads();
49903 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
49904 wxPyEndAllowThreads(__tstate);
49905 if (PyErr_Occurred()) SWIG_fail;
49906 }
49907 {
49908 resultobj = wxPyMake_wxObject(result, (bool)0);
49909 }
49910 return resultobj;
49911 fail:
49912 return NULL;
49913 }
49914
49915
49916 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49917 PyObject *resultobj = 0;
49918 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49919 wxButton *result = 0 ;
49920 void *argp1 = 0 ;
49921 int res1 = 0 ;
49922 PyObject *swig_obj[1] ;
49923
49924 if (!args) SWIG_fail;
49925 swig_obj[0] = args;
49926 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49927 if (!SWIG_IsOK(res1)) {
49928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49929 }
49930 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49931 {
49932 PyThreadState* __tstate = wxPyBeginAllowThreads();
49933 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
49934 wxPyEndAllowThreads(__tstate);
49935 if (PyErr_Occurred()) SWIG_fail;
49936 }
49937 {
49938 resultobj = wxPyMake_wxObject(result, (bool)0);
49939 }
49940 return resultobj;
49941 fail:
49942 return NULL;
49943 }
49944
49945
49946 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49947 PyObject *resultobj = 0;
49948 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49949 wxButton *result = 0 ;
49950 void *argp1 = 0 ;
49951 int res1 = 0 ;
49952 PyObject *swig_obj[1] ;
49953
49954 if (!args) SWIG_fail;
49955 swig_obj[0] = args;
49956 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49957 if (!SWIG_IsOK(res1)) {
49958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49959 }
49960 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49961 {
49962 PyThreadState* __tstate = wxPyBeginAllowThreads();
49963 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
49964 wxPyEndAllowThreads(__tstate);
49965 if (PyErr_Occurred()) SWIG_fail;
49966 }
49967 {
49968 resultobj = wxPyMake_wxObject(result, (bool)0);
49969 }
49970 return resultobj;
49971 fail:
49972 return NULL;
49973 }
49974
49975
49976 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49977 PyObject *obj;
49978 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49979 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
49980 return SWIG_Py_Void();
49981 }
49982
49983 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49984 return SWIG_Python_InitShadowInstance(args);
49985 }
49986
49987 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49988 PyObject *resultobj = 0;
49989 int arg1 = (int) 0 ;
49990 int arg2 = (int) 0 ;
49991 wxGBPosition *result = 0 ;
49992 int val1 ;
49993 int ecode1 = 0 ;
49994 int val2 ;
49995 int ecode2 = 0 ;
49996 PyObject * obj0 = 0 ;
49997 PyObject * obj1 = 0 ;
49998 char * kwnames[] = {
49999 (char *) "row",(char *) "col", NULL
50000 };
50001
50002 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
50003 if (obj0) {
50004 ecode1 = SWIG_AsVal_int(obj0, &val1);
50005 if (!SWIG_IsOK(ecode1)) {
50006 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
50007 }
50008 arg1 = static_cast< int >(val1);
50009 }
50010 if (obj1) {
50011 ecode2 = SWIG_AsVal_int(obj1, &val2);
50012 if (!SWIG_IsOK(ecode2)) {
50013 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
50014 }
50015 arg2 = static_cast< int >(val2);
50016 }
50017 {
50018 PyThreadState* __tstate = wxPyBeginAllowThreads();
50019 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
50020 wxPyEndAllowThreads(__tstate);
50021 if (PyErr_Occurred()) SWIG_fail;
50022 }
50023 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
50024 return resultobj;
50025 fail:
50026 return NULL;
50027 }
50028
50029
50030 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50031 PyObject *resultobj = 0;
50032 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50033 void *argp1 = 0 ;
50034 int res1 = 0 ;
50035 PyObject *swig_obj[1] ;
50036
50037 if (!args) SWIG_fail;
50038 swig_obj[0] = args;
50039 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
50040 if (!SWIG_IsOK(res1)) {
50041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50042 }
50043 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50044 {
50045 PyThreadState* __tstate = wxPyBeginAllowThreads();
50046 delete arg1;
50047
50048 wxPyEndAllowThreads(__tstate);
50049 if (PyErr_Occurred()) SWIG_fail;
50050 }
50051 resultobj = SWIG_Py_Void();
50052 return resultobj;
50053 fail:
50054 return NULL;
50055 }
50056
50057
50058 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50059 PyObject *resultobj = 0;
50060 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50061 int result;
50062 void *argp1 = 0 ;
50063 int res1 = 0 ;
50064 PyObject *swig_obj[1] ;
50065
50066 if (!args) SWIG_fail;
50067 swig_obj[0] = args;
50068 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50069 if (!SWIG_IsOK(res1)) {
50070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
50071 }
50072 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50073 {
50074 PyThreadState* __tstate = wxPyBeginAllowThreads();
50075 result = (int)((wxGBPosition const *)arg1)->GetRow();
50076 wxPyEndAllowThreads(__tstate);
50077 if (PyErr_Occurred()) SWIG_fail;
50078 }
50079 resultobj = SWIG_From_int(static_cast< int >(result));
50080 return resultobj;
50081 fail:
50082 return NULL;
50083 }
50084
50085
50086 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50087 PyObject *resultobj = 0;
50088 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50089 int result;
50090 void *argp1 = 0 ;
50091 int res1 = 0 ;
50092 PyObject *swig_obj[1] ;
50093
50094 if (!args) SWIG_fail;
50095 swig_obj[0] = args;
50096 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50097 if (!SWIG_IsOK(res1)) {
50098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
50099 }
50100 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50101 {
50102 PyThreadState* __tstate = wxPyBeginAllowThreads();
50103 result = (int)((wxGBPosition const *)arg1)->GetCol();
50104 wxPyEndAllowThreads(__tstate);
50105 if (PyErr_Occurred()) SWIG_fail;
50106 }
50107 resultobj = SWIG_From_int(static_cast< int >(result));
50108 return resultobj;
50109 fail:
50110 return NULL;
50111 }
50112
50113
50114 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50115 PyObject *resultobj = 0;
50116 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50117 int arg2 ;
50118 void *argp1 = 0 ;
50119 int res1 = 0 ;
50120 int val2 ;
50121 int ecode2 = 0 ;
50122 PyObject * obj0 = 0 ;
50123 PyObject * obj1 = 0 ;
50124 char * kwnames[] = {
50125 (char *) "self",(char *) "row", NULL
50126 };
50127
50128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
50129 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50130 if (!SWIG_IsOK(res1)) {
50131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50132 }
50133 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50134 ecode2 = SWIG_AsVal_int(obj1, &val2);
50135 if (!SWIG_IsOK(ecode2)) {
50136 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
50137 }
50138 arg2 = static_cast< int >(val2);
50139 {
50140 PyThreadState* __tstate = wxPyBeginAllowThreads();
50141 (arg1)->SetRow(arg2);
50142 wxPyEndAllowThreads(__tstate);
50143 if (PyErr_Occurred()) SWIG_fail;
50144 }
50145 resultobj = SWIG_Py_Void();
50146 return resultobj;
50147 fail:
50148 return NULL;
50149 }
50150
50151
50152 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50153 PyObject *resultobj = 0;
50154 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50155 int arg2 ;
50156 void *argp1 = 0 ;
50157 int res1 = 0 ;
50158 int val2 ;
50159 int ecode2 = 0 ;
50160 PyObject * obj0 = 0 ;
50161 PyObject * obj1 = 0 ;
50162 char * kwnames[] = {
50163 (char *) "self",(char *) "col", NULL
50164 };
50165
50166 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
50167 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50168 if (!SWIG_IsOK(res1)) {
50169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50170 }
50171 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50172 ecode2 = SWIG_AsVal_int(obj1, &val2);
50173 if (!SWIG_IsOK(ecode2)) {
50174 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
50175 }
50176 arg2 = static_cast< int >(val2);
50177 {
50178 PyThreadState* __tstate = wxPyBeginAllowThreads();
50179 (arg1)->SetCol(arg2);
50180 wxPyEndAllowThreads(__tstate);
50181 if (PyErr_Occurred()) SWIG_fail;
50182 }
50183 resultobj = SWIG_Py_Void();
50184 return resultobj;
50185 fail:
50186 return NULL;
50187 }
50188
50189
50190 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50191 PyObject *resultobj = 0;
50192 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50193 PyObject *arg2 = (PyObject *) 0 ;
50194 bool result;
50195 void *argp1 = 0 ;
50196 int res1 = 0 ;
50197 PyObject * obj0 = 0 ;
50198 PyObject * obj1 = 0 ;
50199 char * kwnames[] = {
50200 (char *) "self",(char *) "other", NULL
50201 };
50202
50203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
50204 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50205 if (!SWIG_IsOK(res1)) {
50206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50207 }
50208 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50209 arg2 = obj1;
50210 {
50211 result = (bool)wxGBPosition___eq__(arg1,arg2);
50212 if (PyErr_Occurred()) SWIG_fail;
50213 }
50214 {
50215 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50216 }
50217 return resultobj;
50218 fail:
50219 return NULL;
50220 }
50221
50222
50223 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50224 PyObject *resultobj = 0;
50225 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50226 PyObject *arg2 = (PyObject *) 0 ;
50227 bool result;
50228 void *argp1 = 0 ;
50229 int res1 = 0 ;
50230 PyObject * obj0 = 0 ;
50231 PyObject * obj1 = 0 ;
50232 char * kwnames[] = {
50233 (char *) "self",(char *) "other", NULL
50234 };
50235
50236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
50237 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50238 if (!SWIG_IsOK(res1)) {
50239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50240 }
50241 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50242 arg2 = obj1;
50243 {
50244 result = (bool)wxGBPosition___ne__(arg1,arg2);
50245 if (PyErr_Occurred()) SWIG_fail;
50246 }
50247 {
50248 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50249 }
50250 return resultobj;
50251 fail:
50252 return NULL;
50253 }
50254
50255
50256 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50257 PyObject *resultobj = 0;
50258 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50259 int arg2 = (int) 0 ;
50260 int arg3 = (int) 0 ;
50261 void *argp1 = 0 ;
50262 int res1 = 0 ;
50263 int val2 ;
50264 int ecode2 = 0 ;
50265 int val3 ;
50266 int ecode3 = 0 ;
50267 PyObject * obj0 = 0 ;
50268 PyObject * obj1 = 0 ;
50269 PyObject * obj2 = 0 ;
50270 char * kwnames[] = {
50271 (char *) "self",(char *) "row",(char *) "col", NULL
50272 };
50273
50274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50275 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50276 if (!SWIG_IsOK(res1)) {
50277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50278 }
50279 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50280 if (obj1) {
50281 ecode2 = SWIG_AsVal_int(obj1, &val2);
50282 if (!SWIG_IsOK(ecode2)) {
50283 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
50284 }
50285 arg2 = static_cast< int >(val2);
50286 }
50287 if (obj2) {
50288 ecode3 = SWIG_AsVal_int(obj2, &val3);
50289 if (!SWIG_IsOK(ecode3)) {
50290 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
50291 }
50292 arg3 = static_cast< int >(val3);
50293 }
50294 {
50295 PyThreadState* __tstate = wxPyBeginAllowThreads();
50296 wxGBPosition_Set(arg1,arg2,arg3);
50297 wxPyEndAllowThreads(__tstate);
50298 if (PyErr_Occurred()) SWIG_fail;
50299 }
50300 resultobj = SWIG_Py_Void();
50301 return resultobj;
50302 fail:
50303 return NULL;
50304 }
50305
50306
50307 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50308 PyObject *resultobj = 0;
50309 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50310 PyObject *result = 0 ;
50311 void *argp1 = 0 ;
50312 int res1 = 0 ;
50313 PyObject *swig_obj[1] ;
50314
50315 if (!args) SWIG_fail;
50316 swig_obj[0] = args;
50317 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50318 if (!SWIG_IsOK(res1)) {
50319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50320 }
50321 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50322 {
50323 PyThreadState* __tstate = wxPyBeginAllowThreads();
50324 result = (PyObject *)wxGBPosition_Get(arg1);
50325 wxPyEndAllowThreads(__tstate);
50326 if (PyErr_Occurred()) SWIG_fail;
50327 }
50328 resultobj = result;
50329 return resultobj;
50330 fail:
50331 return NULL;
50332 }
50333
50334
50335 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50336 PyObject *obj;
50337 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50338 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
50339 return SWIG_Py_Void();
50340 }
50341
50342 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50343 return SWIG_Python_InitShadowInstance(args);
50344 }
50345
50346 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50347 PyObject *resultobj = 0;
50348 int arg1 = (int) 1 ;
50349 int arg2 = (int) 1 ;
50350 wxGBSpan *result = 0 ;
50351 int val1 ;
50352 int ecode1 = 0 ;
50353 int val2 ;
50354 int ecode2 = 0 ;
50355 PyObject * obj0 = 0 ;
50356 PyObject * obj1 = 0 ;
50357 char * kwnames[] = {
50358 (char *) "rowspan",(char *) "colspan", NULL
50359 };
50360
50361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
50362 if (obj0) {
50363 ecode1 = SWIG_AsVal_int(obj0, &val1);
50364 if (!SWIG_IsOK(ecode1)) {
50365 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
50366 }
50367 arg1 = static_cast< int >(val1);
50368 }
50369 if (obj1) {
50370 ecode2 = SWIG_AsVal_int(obj1, &val2);
50371 if (!SWIG_IsOK(ecode2)) {
50372 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
50373 }
50374 arg2 = static_cast< int >(val2);
50375 }
50376 {
50377 PyThreadState* __tstate = wxPyBeginAllowThreads();
50378 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
50379 wxPyEndAllowThreads(__tstate);
50380 if (PyErr_Occurred()) SWIG_fail;
50381 }
50382 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
50383 return resultobj;
50384 fail:
50385 return NULL;
50386 }
50387
50388
50389 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50390 PyObject *resultobj = 0;
50391 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50392 void *argp1 = 0 ;
50393 int res1 = 0 ;
50394 PyObject *swig_obj[1] ;
50395
50396 if (!args) SWIG_fail;
50397 swig_obj[0] = args;
50398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
50399 if (!SWIG_IsOK(res1)) {
50400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50401 }
50402 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50403 {
50404 PyThreadState* __tstate = wxPyBeginAllowThreads();
50405 delete arg1;
50406
50407 wxPyEndAllowThreads(__tstate);
50408 if (PyErr_Occurred()) SWIG_fail;
50409 }
50410 resultobj = SWIG_Py_Void();
50411 return resultobj;
50412 fail:
50413 return NULL;
50414 }
50415
50416
50417 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50418 PyObject *resultobj = 0;
50419 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50420 int result;
50421 void *argp1 = 0 ;
50422 int res1 = 0 ;
50423 PyObject *swig_obj[1] ;
50424
50425 if (!args) SWIG_fail;
50426 swig_obj[0] = args;
50427 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50428 if (!SWIG_IsOK(res1)) {
50429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
50430 }
50431 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50432 {
50433 PyThreadState* __tstate = wxPyBeginAllowThreads();
50434 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
50435 wxPyEndAllowThreads(__tstate);
50436 if (PyErr_Occurred()) SWIG_fail;
50437 }
50438 resultobj = SWIG_From_int(static_cast< int >(result));
50439 return resultobj;
50440 fail:
50441 return NULL;
50442 }
50443
50444
50445 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50446 PyObject *resultobj = 0;
50447 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50448 int result;
50449 void *argp1 = 0 ;
50450 int res1 = 0 ;
50451 PyObject *swig_obj[1] ;
50452
50453 if (!args) SWIG_fail;
50454 swig_obj[0] = args;
50455 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50456 if (!SWIG_IsOK(res1)) {
50457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
50458 }
50459 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50460 {
50461 PyThreadState* __tstate = wxPyBeginAllowThreads();
50462 result = (int)((wxGBSpan const *)arg1)->GetColspan();
50463 wxPyEndAllowThreads(__tstate);
50464 if (PyErr_Occurred()) SWIG_fail;
50465 }
50466 resultobj = SWIG_From_int(static_cast< int >(result));
50467 return resultobj;
50468 fail:
50469 return NULL;
50470 }
50471
50472
50473 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50474 PyObject *resultobj = 0;
50475 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50476 int arg2 ;
50477 void *argp1 = 0 ;
50478 int res1 = 0 ;
50479 int val2 ;
50480 int ecode2 = 0 ;
50481 PyObject * obj0 = 0 ;
50482 PyObject * obj1 = 0 ;
50483 char * kwnames[] = {
50484 (char *) "self",(char *) "rowspan", NULL
50485 };
50486
50487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
50488 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50489 if (!SWIG_IsOK(res1)) {
50490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50491 }
50492 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50493 ecode2 = SWIG_AsVal_int(obj1, &val2);
50494 if (!SWIG_IsOK(ecode2)) {
50495 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
50496 }
50497 arg2 = static_cast< int >(val2);
50498 {
50499 PyThreadState* __tstate = wxPyBeginAllowThreads();
50500 (arg1)->SetRowspan(arg2);
50501 wxPyEndAllowThreads(__tstate);
50502 if (PyErr_Occurred()) SWIG_fail;
50503 }
50504 resultobj = SWIG_Py_Void();
50505 return resultobj;
50506 fail:
50507 return NULL;
50508 }
50509
50510
50511 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50512 PyObject *resultobj = 0;
50513 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50514 int arg2 ;
50515 void *argp1 = 0 ;
50516 int res1 = 0 ;
50517 int val2 ;
50518 int ecode2 = 0 ;
50519 PyObject * obj0 = 0 ;
50520 PyObject * obj1 = 0 ;
50521 char * kwnames[] = {
50522 (char *) "self",(char *) "colspan", NULL
50523 };
50524
50525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
50526 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50527 if (!SWIG_IsOK(res1)) {
50528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50529 }
50530 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50531 ecode2 = SWIG_AsVal_int(obj1, &val2);
50532 if (!SWIG_IsOK(ecode2)) {
50533 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
50534 }
50535 arg2 = static_cast< int >(val2);
50536 {
50537 PyThreadState* __tstate = wxPyBeginAllowThreads();
50538 (arg1)->SetColspan(arg2);
50539 wxPyEndAllowThreads(__tstate);
50540 if (PyErr_Occurred()) SWIG_fail;
50541 }
50542 resultobj = SWIG_Py_Void();
50543 return resultobj;
50544 fail:
50545 return NULL;
50546 }
50547
50548
50549 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50550 PyObject *resultobj = 0;
50551 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50552 PyObject *arg2 = (PyObject *) 0 ;
50553 bool result;
50554 void *argp1 = 0 ;
50555 int res1 = 0 ;
50556 PyObject * obj0 = 0 ;
50557 PyObject * obj1 = 0 ;
50558 char * kwnames[] = {
50559 (char *) "self",(char *) "other", NULL
50560 };
50561
50562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
50563 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50564 if (!SWIG_IsOK(res1)) {
50565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50566 }
50567 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50568 arg2 = obj1;
50569 {
50570 result = (bool)wxGBSpan___eq__(arg1,arg2);
50571 if (PyErr_Occurred()) SWIG_fail;
50572 }
50573 {
50574 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50575 }
50576 return resultobj;
50577 fail:
50578 return NULL;
50579 }
50580
50581
50582 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50583 PyObject *resultobj = 0;
50584 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50585 PyObject *arg2 = (PyObject *) 0 ;
50586 bool result;
50587 void *argp1 = 0 ;
50588 int res1 = 0 ;
50589 PyObject * obj0 = 0 ;
50590 PyObject * obj1 = 0 ;
50591 char * kwnames[] = {
50592 (char *) "self",(char *) "other", NULL
50593 };
50594
50595 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
50596 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50597 if (!SWIG_IsOK(res1)) {
50598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50599 }
50600 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50601 arg2 = obj1;
50602 {
50603 result = (bool)wxGBSpan___ne__(arg1,arg2);
50604 if (PyErr_Occurred()) SWIG_fail;
50605 }
50606 {
50607 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50608 }
50609 return resultobj;
50610 fail:
50611 return NULL;
50612 }
50613
50614
50615 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50616 PyObject *resultobj = 0;
50617 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50618 int arg2 = (int) 1 ;
50619 int arg3 = (int) 1 ;
50620 void *argp1 = 0 ;
50621 int res1 = 0 ;
50622 int val2 ;
50623 int ecode2 = 0 ;
50624 int val3 ;
50625 int ecode3 = 0 ;
50626 PyObject * obj0 = 0 ;
50627 PyObject * obj1 = 0 ;
50628 PyObject * obj2 = 0 ;
50629 char * kwnames[] = {
50630 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
50631 };
50632
50633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50634 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50635 if (!SWIG_IsOK(res1)) {
50636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50637 }
50638 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50639 if (obj1) {
50640 ecode2 = SWIG_AsVal_int(obj1, &val2);
50641 if (!SWIG_IsOK(ecode2)) {
50642 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
50643 }
50644 arg2 = static_cast< int >(val2);
50645 }
50646 if (obj2) {
50647 ecode3 = SWIG_AsVal_int(obj2, &val3);
50648 if (!SWIG_IsOK(ecode3)) {
50649 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
50650 }
50651 arg3 = static_cast< int >(val3);
50652 }
50653 {
50654 PyThreadState* __tstate = wxPyBeginAllowThreads();
50655 wxGBSpan_Set(arg1,arg2,arg3);
50656 wxPyEndAllowThreads(__tstate);
50657 if (PyErr_Occurred()) SWIG_fail;
50658 }
50659 resultobj = SWIG_Py_Void();
50660 return resultobj;
50661 fail:
50662 return NULL;
50663 }
50664
50665
50666 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50667 PyObject *resultobj = 0;
50668 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50669 PyObject *result = 0 ;
50670 void *argp1 = 0 ;
50671 int res1 = 0 ;
50672 PyObject *swig_obj[1] ;
50673
50674 if (!args) SWIG_fail;
50675 swig_obj[0] = args;
50676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50677 if (!SWIG_IsOK(res1)) {
50678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50679 }
50680 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50681 {
50682 PyThreadState* __tstate = wxPyBeginAllowThreads();
50683 result = (PyObject *)wxGBSpan_Get(arg1);
50684 wxPyEndAllowThreads(__tstate);
50685 if (PyErr_Occurred()) SWIG_fail;
50686 }
50687 resultobj = result;
50688 return resultobj;
50689 fail:
50690 return NULL;
50691 }
50692
50693
50694 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50695 PyObject *obj;
50696 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50697 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
50698 return SWIG_Py_Void();
50699 }
50700
50701 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50702 return SWIG_Python_InitShadowInstance(args);
50703 }
50704
50705 SWIGINTERN int DefaultSpan_set(PyObject *) {
50706 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
50707 return 1;
50708 }
50709
50710
50711 SWIGINTERN PyObject *DefaultSpan_get(void) {
50712 PyObject *pyobj = 0;
50713
50714 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
50715 return pyobj;
50716 }
50717
50718
50719 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50720 PyObject *resultobj = 0;
50721 wxGBSizerItem *result = 0 ;
50722
50723 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
50724 {
50725 PyThreadState* __tstate = wxPyBeginAllowThreads();
50726 result = (wxGBSizerItem *)new wxGBSizerItem();
50727 wxPyEndAllowThreads(__tstate);
50728 if (PyErr_Occurred()) SWIG_fail;
50729 }
50730 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
50731 return resultobj;
50732 fail:
50733 return NULL;
50734 }
50735
50736
50737 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50738 PyObject *resultobj = 0;
50739 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50740 void *argp1 = 0 ;
50741 int res1 = 0 ;
50742 PyObject *swig_obj[1] ;
50743
50744 if (!args) SWIG_fail;
50745 swig_obj[0] = args;
50746 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
50747 if (!SWIG_IsOK(res1)) {
50748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50749 }
50750 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50751 {
50752 PyThreadState* __tstate = wxPyBeginAllowThreads();
50753 delete arg1;
50754
50755 wxPyEndAllowThreads(__tstate);
50756 if (PyErr_Occurred()) SWIG_fail;
50757 }
50758 resultobj = SWIG_Py_Void();
50759 return resultobj;
50760 fail:
50761 return NULL;
50762 }
50763
50764
50765 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50766 PyObject *resultobj = 0;
50767 wxWindow *arg1 = (wxWindow *) 0 ;
50768 wxGBPosition *arg2 = 0 ;
50769 wxGBSpan *arg3 = 0 ;
50770 int arg4 ;
50771 int arg5 ;
50772 PyObject *arg6 = (PyObject *) NULL ;
50773 wxGBSizerItem *result = 0 ;
50774 void *argp1 = 0 ;
50775 int res1 = 0 ;
50776 wxGBPosition temp2 ;
50777 wxGBSpan temp3 ;
50778 int val4 ;
50779 int ecode4 = 0 ;
50780 int val5 ;
50781 int ecode5 = 0 ;
50782 PyObject * obj0 = 0 ;
50783 PyObject * obj1 = 0 ;
50784 PyObject * obj2 = 0 ;
50785 PyObject * obj3 = 0 ;
50786 PyObject * obj4 = 0 ;
50787 PyObject * obj5 = 0 ;
50788 char * kwnames[] = {
50789 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50790 };
50791
50792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
50793 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
50794 if (!SWIG_IsOK(res1)) {
50795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
50796 }
50797 arg1 = reinterpret_cast< wxWindow * >(argp1);
50798 {
50799 arg2 = &temp2;
50800 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50801 }
50802 {
50803 arg3 = &temp3;
50804 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
50805 }
50806 ecode4 = SWIG_AsVal_int(obj3, &val4);
50807 if (!SWIG_IsOK(ecode4)) {
50808 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
50809 }
50810 arg4 = static_cast< int >(val4);
50811 ecode5 = SWIG_AsVal_int(obj4, &val5);
50812 if (!SWIG_IsOK(ecode5)) {
50813 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
50814 }
50815 arg5 = static_cast< int >(val5);
50816 if (obj5) {
50817 arg6 = obj5;
50818 }
50819 {
50820 PyThreadState* __tstate = wxPyBeginAllowThreads();
50821 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
50822 wxPyEndAllowThreads(__tstate);
50823 if (PyErr_Occurred()) SWIG_fail;
50824 }
50825 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
50826 return resultobj;
50827 fail:
50828 return NULL;
50829 }
50830
50831
50832 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50833 PyObject *resultobj = 0;
50834 wxSizer *arg1 = (wxSizer *) 0 ;
50835 wxGBPosition *arg2 = 0 ;
50836 wxGBSpan *arg3 = 0 ;
50837 int arg4 ;
50838 int arg5 ;
50839 PyObject *arg6 = (PyObject *) NULL ;
50840 wxGBSizerItem *result = 0 ;
50841 int res1 = 0 ;
50842 wxGBPosition temp2 ;
50843 wxGBSpan temp3 ;
50844 int val4 ;
50845 int ecode4 = 0 ;
50846 int val5 ;
50847 int ecode5 = 0 ;
50848 PyObject * obj0 = 0 ;
50849 PyObject * obj1 = 0 ;
50850 PyObject * obj2 = 0 ;
50851 PyObject * obj3 = 0 ;
50852 PyObject * obj4 = 0 ;
50853 PyObject * obj5 = 0 ;
50854 char * kwnames[] = {
50855 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50856 };
50857
50858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
50859 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
50860 if (!SWIG_IsOK(res1)) {
50861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
50862 }
50863 {
50864 arg2 = &temp2;
50865 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50866 }
50867 {
50868 arg3 = &temp3;
50869 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
50870 }
50871 ecode4 = SWIG_AsVal_int(obj3, &val4);
50872 if (!SWIG_IsOK(ecode4)) {
50873 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
50874 }
50875 arg4 = static_cast< int >(val4);
50876 ecode5 = SWIG_AsVal_int(obj4, &val5);
50877 if (!SWIG_IsOK(ecode5)) {
50878 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
50879 }
50880 arg5 = static_cast< int >(val5);
50881 if (obj5) {
50882 arg6 = obj5;
50883 }
50884 {
50885 PyThreadState* __tstate = wxPyBeginAllowThreads();
50886 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
50887 wxPyEndAllowThreads(__tstate);
50888 if (PyErr_Occurred()) SWIG_fail;
50889 }
50890 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
50891 return resultobj;
50892 fail:
50893 return NULL;
50894 }
50895
50896
50897 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50898 PyObject *resultobj = 0;
50899 int arg1 ;
50900 int arg2 ;
50901 wxGBPosition *arg3 = 0 ;
50902 wxGBSpan *arg4 = 0 ;
50903 int arg5 ;
50904 int arg6 ;
50905 PyObject *arg7 = (PyObject *) NULL ;
50906 wxGBSizerItem *result = 0 ;
50907 int val1 ;
50908 int ecode1 = 0 ;
50909 int val2 ;
50910 int ecode2 = 0 ;
50911 wxGBPosition temp3 ;
50912 wxGBSpan temp4 ;
50913 int val5 ;
50914 int ecode5 = 0 ;
50915 int val6 ;
50916 int ecode6 = 0 ;
50917 PyObject * obj0 = 0 ;
50918 PyObject * obj1 = 0 ;
50919 PyObject * obj2 = 0 ;
50920 PyObject * obj3 = 0 ;
50921 PyObject * obj4 = 0 ;
50922 PyObject * obj5 = 0 ;
50923 PyObject * obj6 = 0 ;
50924 char * kwnames[] = {
50925 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50926 };
50927
50928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
50929 ecode1 = SWIG_AsVal_int(obj0, &val1);
50930 if (!SWIG_IsOK(ecode1)) {
50931 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
50932 }
50933 arg1 = static_cast< int >(val1);
50934 ecode2 = SWIG_AsVal_int(obj1, &val2);
50935 if (!SWIG_IsOK(ecode2)) {
50936 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
50937 }
50938 arg2 = static_cast< int >(val2);
50939 {
50940 arg3 = &temp3;
50941 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
50942 }
50943 {
50944 arg4 = &temp4;
50945 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
50946 }
50947 ecode5 = SWIG_AsVal_int(obj4, &val5);
50948 if (!SWIG_IsOK(ecode5)) {
50949 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
50950 }
50951 arg5 = static_cast< int >(val5);
50952 ecode6 = SWIG_AsVal_int(obj5, &val6);
50953 if (!SWIG_IsOK(ecode6)) {
50954 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
50955 }
50956 arg6 = static_cast< int >(val6);
50957 if (obj6) {
50958 arg7 = obj6;
50959 }
50960 {
50961 PyThreadState* __tstate = wxPyBeginAllowThreads();
50962 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
50963 wxPyEndAllowThreads(__tstate);
50964 if (PyErr_Occurred()) SWIG_fail;
50965 }
50966 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
50967 return resultobj;
50968 fail:
50969 return NULL;
50970 }
50971
50972
50973 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50974 PyObject *resultobj = 0;
50975 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50976 wxGBPosition result;
50977 void *argp1 = 0 ;
50978 int res1 = 0 ;
50979 PyObject *swig_obj[1] ;
50980
50981 if (!args) SWIG_fail;
50982 swig_obj[0] = args;
50983 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50984 if (!SWIG_IsOK(res1)) {
50985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
50986 }
50987 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50988 {
50989 PyThreadState* __tstate = wxPyBeginAllowThreads();
50990 result = ((wxGBSizerItem const *)arg1)->GetPos();
50991 wxPyEndAllowThreads(__tstate);
50992 if (PyErr_Occurred()) SWIG_fail;
50993 }
50994 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50995 return resultobj;
50996 fail:
50997 return NULL;
50998 }
50999
51000
51001 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51002 PyObject *resultobj = 0;
51003 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51004 wxGBSpan result;
51005 void *argp1 = 0 ;
51006 int res1 = 0 ;
51007 PyObject *swig_obj[1] ;
51008
51009 if (!args) SWIG_fail;
51010 swig_obj[0] = args;
51011 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51012 if (!SWIG_IsOK(res1)) {
51013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
51014 }
51015 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51016 {
51017 PyThreadState* __tstate = wxPyBeginAllowThreads();
51018 result = ((wxGBSizerItem const *)arg1)->GetSpan();
51019 wxPyEndAllowThreads(__tstate);
51020 if (PyErr_Occurred()) SWIG_fail;
51021 }
51022 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
51023 return resultobj;
51024 fail:
51025 return NULL;
51026 }
51027
51028
51029 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51030 PyObject *resultobj = 0;
51031 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51032 wxGBPosition *arg2 = 0 ;
51033 bool result;
51034 void *argp1 = 0 ;
51035 int res1 = 0 ;
51036 wxGBPosition temp2 ;
51037 PyObject * obj0 = 0 ;
51038 PyObject * obj1 = 0 ;
51039 char * kwnames[] = {
51040 (char *) "self",(char *) "pos", NULL
51041 };
51042
51043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
51044 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51045 if (!SWIG_IsOK(res1)) {
51046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51047 }
51048 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51049 {
51050 arg2 = &temp2;
51051 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51052 }
51053 {
51054 PyThreadState* __tstate = wxPyBeginAllowThreads();
51055 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
51056 wxPyEndAllowThreads(__tstate);
51057 if (PyErr_Occurred()) SWIG_fail;
51058 }
51059 {
51060 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51061 }
51062 return resultobj;
51063 fail:
51064 return NULL;
51065 }
51066
51067
51068 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51069 PyObject *resultobj = 0;
51070 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51071 wxGBSpan *arg2 = 0 ;
51072 bool result;
51073 void *argp1 = 0 ;
51074 int res1 = 0 ;
51075 wxGBSpan temp2 ;
51076 PyObject * obj0 = 0 ;
51077 PyObject * obj1 = 0 ;
51078 char * kwnames[] = {
51079 (char *) "self",(char *) "span", NULL
51080 };
51081
51082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
51083 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51084 if (!SWIG_IsOK(res1)) {
51085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51086 }
51087 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51088 {
51089 arg2 = &temp2;
51090 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
51091 }
51092 {
51093 PyThreadState* __tstate = wxPyBeginAllowThreads();
51094 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
51095 wxPyEndAllowThreads(__tstate);
51096 if (PyErr_Occurred()) SWIG_fail;
51097 }
51098 {
51099 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51100 }
51101 return resultobj;
51102 fail:
51103 return NULL;
51104 }
51105
51106
51107 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51108 PyObject *resultobj = 0;
51109 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51110 wxGBSizerItem *arg2 = 0 ;
51111 bool result;
51112 void *argp1 = 0 ;
51113 int res1 = 0 ;
51114 void *argp2 = 0 ;
51115 int res2 = 0 ;
51116 PyObject * obj0 = 0 ;
51117 PyObject * obj1 = 0 ;
51118 char * kwnames[] = {
51119 (char *) "self",(char *) "other", NULL
51120 };
51121
51122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
51123 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51124 if (!SWIG_IsOK(res1)) {
51125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51126 }
51127 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51128 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
51129 if (!SWIG_IsOK(res2)) {
51130 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
51131 }
51132 if (!argp2) {
51133 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
51134 }
51135 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
51136 {
51137 PyThreadState* __tstate = wxPyBeginAllowThreads();
51138 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
51139 wxPyEndAllowThreads(__tstate);
51140 if (PyErr_Occurred()) SWIG_fail;
51141 }
51142 {
51143 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51144 }
51145 return resultobj;
51146 fail:
51147 return NULL;
51148 }
51149
51150
51151 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51152 PyObject *resultobj = 0;
51153 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51154 wxGBPosition *arg2 = 0 ;
51155 wxGBSpan *arg3 = 0 ;
51156 bool result;
51157 void *argp1 = 0 ;
51158 int res1 = 0 ;
51159 wxGBPosition temp2 ;
51160 wxGBSpan temp3 ;
51161 PyObject * obj0 = 0 ;
51162 PyObject * obj1 = 0 ;
51163 PyObject * obj2 = 0 ;
51164 char * kwnames[] = {
51165 (char *) "self",(char *) "pos",(char *) "span", NULL
51166 };
51167
51168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51170 if (!SWIG_IsOK(res1)) {
51171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51172 }
51173 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51174 {
51175 arg2 = &temp2;
51176 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51177 }
51178 {
51179 arg3 = &temp3;
51180 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
51181 }
51182 {
51183 PyThreadState* __tstate = wxPyBeginAllowThreads();
51184 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
51185 wxPyEndAllowThreads(__tstate);
51186 if (PyErr_Occurred()) SWIG_fail;
51187 }
51188 {
51189 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51190 }
51191 return resultobj;
51192 fail:
51193 return NULL;
51194 }
51195
51196
51197 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51198 PyObject *resultobj = 0;
51199 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51200 wxGBPosition result;
51201 void *argp1 = 0 ;
51202 int res1 = 0 ;
51203 PyObject *swig_obj[1] ;
51204
51205 if (!args) SWIG_fail;
51206 swig_obj[0] = args;
51207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51208 if (!SWIG_IsOK(res1)) {
51209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51210 }
51211 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51212 {
51213 PyThreadState* __tstate = wxPyBeginAllowThreads();
51214 result = wxGBSizerItem_GetEndPos(arg1);
51215 wxPyEndAllowThreads(__tstate);
51216 if (PyErr_Occurred()) SWIG_fail;
51217 }
51218 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
51219 return resultobj;
51220 fail:
51221 return NULL;
51222 }
51223
51224
51225 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51226 PyObject *resultobj = 0;
51227 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51228 wxGridBagSizer *result = 0 ;
51229 void *argp1 = 0 ;
51230 int res1 = 0 ;
51231 PyObject *swig_obj[1] ;
51232
51233 if (!args) SWIG_fail;
51234 swig_obj[0] = args;
51235 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51236 if (!SWIG_IsOK(res1)) {
51237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
51238 }
51239 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51240 {
51241 PyThreadState* __tstate = wxPyBeginAllowThreads();
51242 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
51243 wxPyEndAllowThreads(__tstate);
51244 if (PyErr_Occurred()) SWIG_fail;
51245 }
51246 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51247 return resultobj;
51248 fail:
51249 return NULL;
51250 }
51251
51252
51253 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51254 PyObject *resultobj = 0;
51255 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51256 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
51257 void *argp1 = 0 ;
51258 int res1 = 0 ;
51259 void *argp2 = 0 ;
51260 int res2 = 0 ;
51261 PyObject * obj0 = 0 ;
51262 PyObject * obj1 = 0 ;
51263 char * kwnames[] = {
51264 (char *) "self",(char *) "sizer", NULL
51265 };
51266
51267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
51268 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51269 if (!SWIG_IsOK(res1)) {
51270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51271 }
51272 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51273 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51274 if (!SWIG_IsOK(res2)) {
51275 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
51276 }
51277 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
51278 {
51279 PyThreadState* __tstate = wxPyBeginAllowThreads();
51280 (arg1)->SetGBSizer(arg2);
51281 wxPyEndAllowThreads(__tstate);
51282 if (PyErr_Occurred()) SWIG_fail;
51283 }
51284 resultobj = SWIG_Py_Void();
51285 return resultobj;
51286 fail:
51287 return NULL;
51288 }
51289
51290
51291 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51292 PyObject *obj;
51293 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51294 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
51295 return SWIG_Py_Void();
51296 }
51297
51298 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51299 return SWIG_Python_InitShadowInstance(args);
51300 }
51301
51302 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51303 PyObject *resultobj = 0;
51304 int arg1 = (int) 0 ;
51305 int arg2 = (int) 0 ;
51306 wxGridBagSizer *result = 0 ;
51307 int val1 ;
51308 int ecode1 = 0 ;
51309 int val2 ;
51310 int ecode2 = 0 ;
51311 PyObject * obj0 = 0 ;
51312 PyObject * obj1 = 0 ;
51313 char * kwnames[] = {
51314 (char *) "vgap",(char *) "hgap", NULL
51315 };
51316
51317 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
51318 if (obj0) {
51319 ecode1 = SWIG_AsVal_int(obj0, &val1);
51320 if (!SWIG_IsOK(ecode1)) {
51321 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
51322 }
51323 arg1 = static_cast< int >(val1);
51324 }
51325 if (obj1) {
51326 ecode2 = SWIG_AsVal_int(obj1, &val2);
51327 if (!SWIG_IsOK(ecode2)) {
51328 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
51329 }
51330 arg2 = static_cast< int >(val2);
51331 }
51332 {
51333 PyThreadState* __tstate = wxPyBeginAllowThreads();
51334 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
51335 wxPyEndAllowThreads(__tstate);
51336 if (PyErr_Occurred()) SWIG_fail;
51337 }
51338 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
51339 return resultobj;
51340 fail:
51341 return NULL;
51342 }
51343
51344
51345 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51346 PyObject *resultobj = 0;
51347 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51348 PyObject *arg2 = (PyObject *) 0 ;
51349 wxGBPosition *arg3 = 0 ;
51350 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
51351 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
51352 int arg5 = (int) 0 ;
51353 int arg6 = (int) 0 ;
51354 PyObject *arg7 = (PyObject *) NULL ;
51355 wxGBSizerItem *result = 0 ;
51356 void *argp1 = 0 ;
51357 int res1 = 0 ;
51358 wxGBPosition temp3 ;
51359 wxGBSpan temp4 ;
51360 int val5 ;
51361 int ecode5 = 0 ;
51362 int val6 ;
51363 int ecode6 = 0 ;
51364 PyObject * obj0 = 0 ;
51365 PyObject * obj1 = 0 ;
51366 PyObject * obj2 = 0 ;
51367 PyObject * obj3 = 0 ;
51368 PyObject * obj4 = 0 ;
51369 PyObject * obj5 = 0 ;
51370 PyObject * obj6 = 0 ;
51371 char * kwnames[] = {
51372 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
51373 };
51374
51375 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
51376 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51377 if (!SWIG_IsOK(res1)) {
51378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51379 }
51380 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51381 arg2 = obj1;
51382 {
51383 arg3 = &temp3;
51384 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
51385 }
51386 if (obj3) {
51387 {
51388 arg4 = &temp4;
51389 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
51390 }
51391 }
51392 if (obj4) {
51393 ecode5 = SWIG_AsVal_int(obj4, &val5);
51394 if (!SWIG_IsOK(ecode5)) {
51395 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
51396 }
51397 arg5 = static_cast< int >(val5);
51398 }
51399 if (obj5) {
51400 ecode6 = SWIG_AsVal_int(obj5, &val6);
51401 if (!SWIG_IsOK(ecode6)) {
51402 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
51403 }
51404 arg6 = static_cast< int >(val6);
51405 }
51406 if (obj6) {
51407 arg7 = obj6;
51408 }
51409 {
51410 PyThreadState* __tstate = wxPyBeginAllowThreads();
51411 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
51412 wxPyEndAllowThreads(__tstate);
51413 if (PyErr_Occurred()) SWIG_fail;
51414 }
51415 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51416 return resultobj;
51417 fail:
51418 return NULL;
51419 }
51420
51421
51422 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51423 PyObject *resultobj = 0;
51424 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51425 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
51426 wxGBSizerItem *result = 0 ;
51427 void *argp1 = 0 ;
51428 int res1 = 0 ;
51429 int res2 = 0 ;
51430 PyObject * obj0 = 0 ;
51431 PyObject * obj1 = 0 ;
51432 char * kwnames[] = {
51433 (char *) "self",(char *) "item", NULL
51434 };
51435
51436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
51437 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51438 if (!SWIG_IsOK(res1)) {
51439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51440 }
51441 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51442 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
51443 if (!SWIG_IsOK(res2)) {
51444 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
51445 }
51446 {
51447 PyThreadState* __tstate = wxPyBeginAllowThreads();
51448 result = (wxGBSizerItem *)(arg1)->Add(arg2);
51449 wxPyEndAllowThreads(__tstate);
51450 if (PyErr_Occurred()) SWIG_fail;
51451 }
51452 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51453 return resultobj;
51454 fail:
51455 return NULL;
51456 }
51457
51458
51459 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51460 PyObject *resultobj = 0;
51461 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51462 int arg2 ;
51463 int arg3 ;
51464 wxSize result;
51465 void *argp1 = 0 ;
51466 int res1 = 0 ;
51467 int val2 ;
51468 int ecode2 = 0 ;
51469 int val3 ;
51470 int ecode3 = 0 ;
51471 PyObject * obj0 = 0 ;
51472 PyObject * obj1 = 0 ;
51473 PyObject * obj2 = 0 ;
51474 char * kwnames[] = {
51475 (char *) "self",(char *) "row",(char *) "col", NULL
51476 };
51477
51478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51479 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51480 if (!SWIG_IsOK(res1)) {
51481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
51482 }
51483 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51484 ecode2 = SWIG_AsVal_int(obj1, &val2);
51485 if (!SWIG_IsOK(ecode2)) {
51486 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
51487 }
51488 arg2 = static_cast< int >(val2);
51489 ecode3 = SWIG_AsVal_int(obj2, &val3);
51490 if (!SWIG_IsOK(ecode3)) {
51491 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
51492 }
51493 arg3 = static_cast< int >(val3);
51494 {
51495 PyThreadState* __tstate = wxPyBeginAllowThreads();
51496 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
51497 wxPyEndAllowThreads(__tstate);
51498 if (PyErr_Occurred()) SWIG_fail;
51499 }
51500 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
51501 return resultobj;
51502 fail:
51503 return NULL;
51504 }
51505
51506
51507 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51508 PyObject *resultobj = 0;
51509 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51510 wxSize result;
51511 void *argp1 = 0 ;
51512 int res1 = 0 ;
51513 PyObject *swig_obj[1] ;
51514
51515 if (!args) SWIG_fail;
51516 swig_obj[0] = args;
51517 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51518 if (!SWIG_IsOK(res1)) {
51519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
51520 }
51521 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51522 {
51523 PyThreadState* __tstate = wxPyBeginAllowThreads();
51524 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
51525 wxPyEndAllowThreads(__tstate);
51526 if (PyErr_Occurred()) SWIG_fail;
51527 }
51528 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
51529 return resultobj;
51530 fail:
51531 return NULL;
51532 }
51533
51534
51535 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51536 PyObject *resultobj = 0;
51537 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51538 wxSize *arg2 = 0 ;
51539 void *argp1 = 0 ;
51540 int res1 = 0 ;
51541 wxSize temp2 ;
51542 PyObject * obj0 = 0 ;
51543 PyObject * obj1 = 0 ;
51544 char * kwnames[] = {
51545 (char *) "self",(char *) "sz", NULL
51546 };
51547
51548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
51549 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51550 if (!SWIG_IsOK(res1)) {
51551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51552 }
51553 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51554 {
51555 arg2 = &temp2;
51556 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
51557 }
51558 {
51559 PyThreadState* __tstate = wxPyBeginAllowThreads();
51560 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
51561 wxPyEndAllowThreads(__tstate);
51562 if (PyErr_Occurred()) SWIG_fail;
51563 }
51564 resultobj = SWIG_Py_Void();
51565 return resultobj;
51566 fail:
51567 return NULL;
51568 }
51569
51570
51571 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51572 PyObject *resultobj = 0;
51573 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51574 wxWindow *arg2 = (wxWindow *) 0 ;
51575 wxGBPosition result;
51576 void *argp1 = 0 ;
51577 int res1 = 0 ;
51578 void *argp2 = 0 ;
51579 int res2 = 0 ;
51580
51581 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51582 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51583 if (!SWIG_IsOK(res1)) {
51584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51585 }
51586 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51587 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51588 if (!SWIG_IsOK(res2)) {
51589 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
51590 }
51591 arg2 = reinterpret_cast< wxWindow * >(argp2);
51592 {
51593 PyThreadState* __tstate = wxPyBeginAllowThreads();
51594 result = (arg1)->GetItemPosition(arg2);
51595 wxPyEndAllowThreads(__tstate);
51596 if (PyErr_Occurred()) SWIG_fail;
51597 }
51598 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
51599 return resultobj;
51600 fail:
51601 return NULL;
51602 }
51603
51604
51605 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51606 PyObject *resultobj = 0;
51607 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51608 wxSizer *arg2 = (wxSizer *) 0 ;
51609 wxGBPosition result;
51610 void *argp1 = 0 ;
51611 int res1 = 0 ;
51612 void *argp2 = 0 ;
51613 int res2 = 0 ;
51614
51615 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51617 if (!SWIG_IsOK(res1)) {
51618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51619 }
51620 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51621 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51622 if (!SWIG_IsOK(res2)) {
51623 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
51624 }
51625 arg2 = reinterpret_cast< wxSizer * >(argp2);
51626 {
51627 PyThreadState* __tstate = wxPyBeginAllowThreads();
51628 result = (arg1)->GetItemPosition(arg2);
51629 wxPyEndAllowThreads(__tstate);
51630 if (PyErr_Occurred()) SWIG_fail;
51631 }
51632 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
51633 return resultobj;
51634 fail:
51635 return NULL;
51636 }
51637
51638
51639 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51640 PyObject *resultobj = 0;
51641 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51642 size_t arg2 ;
51643 wxGBPosition result;
51644 void *argp1 = 0 ;
51645 int res1 = 0 ;
51646 size_t val2 ;
51647 int ecode2 = 0 ;
51648
51649 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51650 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51651 if (!SWIG_IsOK(res1)) {
51652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51653 }
51654 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51655 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
51656 if (!SWIG_IsOK(ecode2)) {
51657 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
51658 }
51659 arg2 = static_cast< size_t >(val2);
51660 {
51661 PyThreadState* __tstate = wxPyBeginAllowThreads();
51662 result = (arg1)->GetItemPosition(arg2);
51663 wxPyEndAllowThreads(__tstate);
51664 if (PyErr_Occurred()) SWIG_fail;
51665 }
51666 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
51667 return resultobj;
51668 fail:
51669 return NULL;
51670 }
51671
51672
51673 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
51674 int argc;
51675 PyObject *argv[3];
51676
51677 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
51678 --argc;
51679 if (argc == 2) {
51680 int _v = 0;
51681 {
51682 void *vptr = 0;
51683 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51684 _v = SWIG_CheckState(res);
51685 }
51686 if (!_v) goto check_1;
51687 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
51688 }
51689 check_1:
51690
51691 if (argc == 2) {
51692 int _v = 0;
51693 {
51694 void *vptr = 0;
51695 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
51696 _v = SWIG_CheckState(res);
51697 }
51698 if (!_v) goto check_2;
51699 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
51700 }
51701 check_2:
51702
51703 if (argc == 2) {
51704 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
51705 }
51706
51707 fail:
51708 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
51709 return NULL;
51710 }
51711
51712
51713 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51714 PyObject *resultobj = 0;
51715 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51716 wxWindow *arg2 = (wxWindow *) 0 ;
51717 wxGBPosition *arg3 = 0 ;
51718 bool result;
51719 void *argp1 = 0 ;
51720 int res1 = 0 ;
51721 void *argp2 = 0 ;
51722 int res2 = 0 ;
51723 wxGBPosition temp3 ;
51724
51725 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51726 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51727 if (!SWIG_IsOK(res1)) {
51728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51729 }
51730 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51731 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51732 if (!SWIG_IsOK(res2)) {
51733 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
51734 }
51735 arg2 = reinterpret_cast< wxWindow * >(argp2);
51736 {
51737 arg3 = &temp3;
51738 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
51739 }
51740 {
51741 PyThreadState* __tstate = wxPyBeginAllowThreads();
51742 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
51743 wxPyEndAllowThreads(__tstate);
51744 if (PyErr_Occurred()) SWIG_fail;
51745 }
51746 {
51747 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51748 }
51749 return resultobj;
51750 fail:
51751 return NULL;
51752 }
51753
51754
51755 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51756 PyObject *resultobj = 0;
51757 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51758 wxSizer *arg2 = (wxSizer *) 0 ;
51759 wxGBPosition *arg3 = 0 ;
51760 bool result;
51761 void *argp1 = 0 ;
51762 int res1 = 0 ;
51763 void *argp2 = 0 ;
51764 int res2 = 0 ;
51765 wxGBPosition temp3 ;
51766
51767 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51768 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51769 if (!SWIG_IsOK(res1)) {
51770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51771 }
51772 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51773 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51774 if (!SWIG_IsOK(res2)) {
51775 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
51776 }
51777 arg2 = reinterpret_cast< wxSizer * >(argp2);
51778 {
51779 arg3 = &temp3;
51780 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
51781 }
51782 {
51783 PyThreadState* __tstate = wxPyBeginAllowThreads();
51784 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
51785 wxPyEndAllowThreads(__tstate);
51786 if (PyErr_Occurred()) SWIG_fail;
51787 }
51788 {
51789 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51790 }
51791 return resultobj;
51792 fail:
51793 return NULL;
51794 }
51795
51796
51797 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51798 PyObject *resultobj = 0;
51799 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51800 size_t arg2 ;
51801 wxGBPosition *arg3 = 0 ;
51802 bool result;
51803 void *argp1 = 0 ;
51804 int res1 = 0 ;
51805 size_t val2 ;
51806 int ecode2 = 0 ;
51807 wxGBPosition temp3 ;
51808
51809 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51810 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51811 if (!SWIG_IsOK(res1)) {
51812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51813 }
51814 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51815 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
51816 if (!SWIG_IsOK(ecode2)) {
51817 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
51818 }
51819 arg2 = static_cast< size_t >(val2);
51820 {
51821 arg3 = &temp3;
51822 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
51823 }
51824 {
51825 PyThreadState* __tstate = wxPyBeginAllowThreads();
51826 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
51827 wxPyEndAllowThreads(__tstate);
51828 if (PyErr_Occurred()) SWIG_fail;
51829 }
51830 {
51831 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51832 }
51833 return resultobj;
51834 fail:
51835 return NULL;
51836 }
51837
51838
51839 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
51840 int argc;
51841 PyObject *argv[4];
51842
51843 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
51844 --argc;
51845 if (argc == 3) {
51846 int _v = 0;
51847 {
51848 void *vptr = 0;
51849 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51850 _v = SWIG_CheckState(res);
51851 }
51852 if (!_v) goto check_1;
51853 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
51854 }
51855 check_1:
51856
51857 if (argc == 3) {
51858 int _v = 0;
51859 {
51860 void *vptr = 0;
51861 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
51862 _v = SWIG_CheckState(res);
51863 }
51864 if (!_v) goto check_2;
51865 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
51866 }
51867 check_2:
51868
51869 if (argc == 3) {
51870 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
51871 }
51872
51873 fail:
51874 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
51875 return NULL;
51876 }
51877
51878
51879 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51880 PyObject *resultobj = 0;
51881 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51882 wxWindow *arg2 = (wxWindow *) 0 ;
51883 wxGBSpan result;
51884 void *argp1 = 0 ;
51885 int res1 = 0 ;
51886 void *argp2 = 0 ;
51887 int res2 = 0 ;
51888
51889 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51890 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51891 if (!SWIG_IsOK(res1)) {
51892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51893 }
51894 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51895 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51896 if (!SWIG_IsOK(res2)) {
51897 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
51898 }
51899 arg2 = reinterpret_cast< wxWindow * >(argp2);
51900 {
51901 PyThreadState* __tstate = wxPyBeginAllowThreads();
51902 result = (arg1)->GetItemSpan(arg2);
51903 wxPyEndAllowThreads(__tstate);
51904 if (PyErr_Occurred()) SWIG_fail;
51905 }
51906 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
51907 return resultobj;
51908 fail:
51909 return NULL;
51910 }
51911
51912
51913 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51914 PyObject *resultobj = 0;
51915 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51916 wxSizer *arg2 = (wxSizer *) 0 ;
51917 wxGBSpan result;
51918 void *argp1 = 0 ;
51919 int res1 = 0 ;
51920 void *argp2 = 0 ;
51921 int res2 = 0 ;
51922
51923 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51924 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51925 if (!SWIG_IsOK(res1)) {
51926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51927 }
51928 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51929 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51930 if (!SWIG_IsOK(res2)) {
51931 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
51932 }
51933 arg2 = reinterpret_cast< wxSizer * >(argp2);
51934 {
51935 PyThreadState* __tstate = wxPyBeginAllowThreads();
51936 result = (arg1)->GetItemSpan(arg2);
51937 wxPyEndAllowThreads(__tstate);
51938 if (PyErr_Occurred()) SWIG_fail;
51939 }
51940 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
51941 return resultobj;
51942 fail:
51943 return NULL;
51944 }
51945
51946
51947 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51948 PyObject *resultobj = 0;
51949 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51950 size_t arg2 ;
51951 wxGBSpan result;
51952 void *argp1 = 0 ;
51953 int res1 = 0 ;
51954 size_t val2 ;
51955 int ecode2 = 0 ;
51956
51957 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51958 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51959 if (!SWIG_IsOK(res1)) {
51960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51961 }
51962 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51963 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
51964 if (!SWIG_IsOK(ecode2)) {
51965 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
51966 }
51967 arg2 = static_cast< size_t >(val2);
51968 {
51969 PyThreadState* __tstate = wxPyBeginAllowThreads();
51970 result = (arg1)->GetItemSpan(arg2);
51971 wxPyEndAllowThreads(__tstate);
51972 if (PyErr_Occurred()) SWIG_fail;
51973 }
51974 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
51975 return resultobj;
51976 fail:
51977 return NULL;
51978 }
51979
51980
51981 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
51982 int argc;
51983 PyObject *argv[3];
51984
51985 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
51986 --argc;
51987 if (argc == 2) {
51988 int _v = 0;
51989 {
51990 void *vptr = 0;
51991 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51992 _v = SWIG_CheckState(res);
51993 }
51994 if (!_v) goto check_1;
51995 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
51996 }
51997 check_1:
51998
51999 if (argc == 2) {
52000 int _v = 0;
52001 {
52002 void *vptr = 0;
52003 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
52004 _v = SWIG_CheckState(res);
52005 }
52006 if (!_v) goto check_2;
52007 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
52008 }
52009 check_2:
52010
52011 if (argc == 2) {
52012 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
52013 }
52014
52015 fail:
52016 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
52017 return NULL;
52018 }
52019
52020
52021 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52022 PyObject *resultobj = 0;
52023 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52024 wxWindow *arg2 = (wxWindow *) 0 ;
52025 wxGBSpan *arg3 = 0 ;
52026 bool result;
52027 void *argp1 = 0 ;
52028 int res1 = 0 ;
52029 void *argp2 = 0 ;
52030 int res2 = 0 ;
52031 wxGBSpan temp3 ;
52032
52033 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
52034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52035 if (!SWIG_IsOK(res1)) {
52036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52037 }
52038 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52039 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52040 if (!SWIG_IsOK(res2)) {
52041 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
52042 }
52043 arg2 = reinterpret_cast< wxWindow * >(argp2);
52044 {
52045 arg3 = &temp3;
52046 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
52047 }
52048 {
52049 PyThreadState* __tstate = wxPyBeginAllowThreads();
52050 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
52051 wxPyEndAllowThreads(__tstate);
52052 if (PyErr_Occurred()) SWIG_fail;
52053 }
52054 {
52055 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52056 }
52057 return resultobj;
52058 fail:
52059 return NULL;
52060 }
52061
52062
52063 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52064 PyObject *resultobj = 0;
52065 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52066 wxSizer *arg2 = (wxSizer *) 0 ;
52067 wxGBSpan *arg3 = 0 ;
52068 bool result;
52069 void *argp1 = 0 ;
52070 int res1 = 0 ;
52071 void *argp2 = 0 ;
52072 int res2 = 0 ;
52073 wxGBSpan temp3 ;
52074
52075 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
52076 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52077 if (!SWIG_IsOK(res1)) {
52078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52079 }
52080 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52081 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
52082 if (!SWIG_IsOK(res2)) {
52083 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
52084 }
52085 arg2 = reinterpret_cast< wxSizer * >(argp2);
52086 {
52087 arg3 = &temp3;
52088 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
52089 }
52090 {
52091 PyThreadState* __tstate = wxPyBeginAllowThreads();
52092 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
52093 wxPyEndAllowThreads(__tstate);
52094 if (PyErr_Occurred()) SWIG_fail;
52095 }
52096 {
52097 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52098 }
52099 return resultobj;
52100 fail:
52101 return NULL;
52102 }
52103
52104
52105 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52106 PyObject *resultobj = 0;
52107 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52108 size_t arg2 ;
52109 wxGBSpan *arg3 = 0 ;
52110 bool result;
52111 void *argp1 = 0 ;
52112 int res1 = 0 ;
52113 size_t val2 ;
52114 int ecode2 = 0 ;
52115 wxGBSpan temp3 ;
52116
52117 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
52118 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52119 if (!SWIG_IsOK(res1)) {
52120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52121 }
52122 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52123 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
52124 if (!SWIG_IsOK(ecode2)) {
52125 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
52126 }
52127 arg2 = static_cast< size_t >(val2);
52128 {
52129 arg3 = &temp3;
52130 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
52131 }
52132 {
52133 PyThreadState* __tstate = wxPyBeginAllowThreads();
52134 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
52135 wxPyEndAllowThreads(__tstate);
52136 if (PyErr_Occurred()) SWIG_fail;
52137 }
52138 {
52139 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52140 }
52141 return resultobj;
52142 fail:
52143 return NULL;
52144 }
52145
52146
52147 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
52148 int argc;
52149 PyObject *argv[4];
52150
52151 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
52152 --argc;
52153 if (argc == 3) {
52154 int _v = 0;
52155 {
52156 void *vptr = 0;
52157 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
52158 _v = SWIG_CheckState(res);
52159 }
52160 if (!_v) goto check_1;
52161 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
52162 }
52163 check_1:
52164
52165 if (argc == 3) {
52166 int _v = 0;
52167 {
52168 void *vptr = 0;
52169 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
52170 _v = SWIG_CheckState(res);
52171 }
52172 if (!_v) goto check_2;
52173 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
52174 }
52175 check_2:
52176
52177 if (argc == 3) {
52178 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
52179 }
52180
52181 fail:
52182 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
52183 return NULL;
52184 }
52185
52186
52187 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52188 PyObject *resultobj = 0;
52189 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52190 wxWindow *arg2 = (wxWindow *) 0 ;
52191 wxGBSizerItem *result = 0 ;
52192 void *argp1 = 0 ;
52193 int res1 = 0 ;
52194 void *argp2 = 0 ;
52195 int res2 = 0 ;
52196
52197 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52198 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52199 if (!SWIG_IsOK(res1)) {
52200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52201 }
52202 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52203 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52204 if (!SWIG_IsOK(res2)) {
52205 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
52206 }
52207 arg2 = reinterpret_cast< wxWindow * >(argp2);
52208 {
52209 PyThreadState* __tstate = wxPyBeginAllowThreads();
52210 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
52211 wxPyEndAllowThreads(__tstate);
52212 if (PyErr_Occurred()) SWIG_fail;
52213 }
52214 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52215 return resultobj;
52216 fail:
52217 return NULL;
52218 }
52219
52220
52221 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52222 PyObject *resultobj = 0;
52223 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52224 wxSizer *arg2 = (wxSizer *) 0 ;
52225 wxGBSizerItem *result = 0 ;
52226 void *argp1 = 0 ;
52227 int res1 = 0 ;
52228 void *argp2 = 0 ;
52229 int res2 = 0 ;
52230
52231 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52232 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52233 if (!SWIG_IsOK(res1)) {
52234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52235 }
52236 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52237 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
52238 if (!SWIG_IsOK(res2)) {
52239 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
52240 }
52241 arg2 = reinterpret_cast< wxSizer * >(argp2);
52242 {
52243 PyThreadState* __tstate = wxPyBeginAllowThreads();
52244 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
52245 wxPyEndAllowThreads(__tstate);
52246 if (PyErr_Occurred()) SWIG_fail;
52247 }
52248 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52249 return resultobj;
52250 fail:
52251 return NULL;
52252 }
52253
52254
52255 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
52256 int argc;
52257 PyObject *argv[3];
52258
52259 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
52260 --argc;
52261 if (argc == 2) {
52262 int _v = 0;
52263 {
52264 void *vptr = 0;
52265 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
52266 _v = SWIG_CheckState(res);
52267 }
52268 if (!_v) goto check_1;
52269 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
52270 }
52271 check_1:
52272
52273 if (argc == 2) {
52274 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
52275 }
52276
52277 fail:
52278 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
52279 return NULL;
52280 }
52281
52282
52283 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52284 PyObject *resultobj = 0;
52285 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52286 wxGBPosition *arg2 = 0 ;
52287 wxGBSizerItem *result = 0 ;
52288 void *argp1 = 0 ;
52289 int res1 = 0 ;
52290 wxGBPosition temp2 ;
52291 PyObject * obj0 = 0 ;
52292 PyObject * obj1 = 0 ;
52293 char * kwnames[] = {
52294 (char *) "self",(char *) "pos", NULL
52295 };
52296
52297 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
52298 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52299 if (!SWIG_IsOK(res1)) {
52300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52301 }
52302 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52303 {
52304 arg2 = &temp2;
52305 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
52306 }
52307 {
52308 PyThreadState* __tstate = wxPyBeginAllowThreads();
52309 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
52310 wxPyEndAllowThreads(__tstate);
52311 if (PyErr_Occurred()) SWIG_fail;
52312 }
52313 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52314 return resultobj;
52315 fail:
52316 return NULL;
52317 }
52318
52319
52320 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52321 PyObject *resultobj = 0;
52322 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52323 wxPoint *arg2 = 0 ;
52324 wxGBSizerItem *result = 0 ;
52325 void *argp1 = 0 ;
52326 int res1 = 0 ;
52327 wxPoint temp2 ;
52328 PyObject * obj0 = 0 ;
52329 PyObject * obj1 = 0 ;
52330 char * kwnames[] = {
52331 (char *) "self",(char *) "pt", NULL
52332 };
52333
52334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
52335 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52336 if (!SWIG_IsOK(res1)) {
52337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52338 }
52339 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52340 {
52341 arg2 = &temp2;
52342 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
52343 }
52344 {
52345 PyThreadState* __tstate = wxPyBeginAllowThreads();
52346 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
52347 wxPyEndAllowThreads(__tstate);
52348 if (PyErr_Occurred()) SWIG_fail;
52349 }
52350 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52351 return resultobj;
52352 fail:
52353 return NULL;
52354 }
52355
52356
52357 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52358 PyObject *resultobj = 0;
52359 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52360 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
52361 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
52362 bool result;
52363 void *argp1 = 0 ;
52364 int res1 = 0 ;
52365 void *argp2 = 0 ;
52366 int res2 = 0 ;
52367 void *argp3 = 0 ;
52368 int res3 = 0 ;
52369 PyObject * obj0 = 0 ;
52370 PyObject * obj1 = 0 ;
52371 PyObject * obj2 = 0 ;
52372 char * kwnames[] = {
52373 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
52374 };
52375
52376 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52377 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52378 if (!SWIG_IsOK(res1)) {
52379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52380 }
52381 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52382 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52383 if (!SWIG_IsOK(res2)) {
52384 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
52385 }
52386 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
52387 if (obj2) {
52388 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52389 if (!SWIG_IsOK(res3)) {
52390 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
52391 }
52392 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
52393 }
52394 {
52395 PyThreadState* __tstate = wxPyBeginAllowThreads();
52396 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
52397 wxPyEndAllowThreads(__tstate);
52398 if (PyErr_Occurred()) SWIG_fail;
52399 }
52400 {
52401 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52402 }
52403 return resultobj;
52404 fail:
52405 return NULL;
52406 }
52407
52408
52409 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52410 PyObject *resultobj = 0;
52411 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52412 wxGBPosition *arg2 = 0 ;
52413 wxGBSpan *arg3 = 0 ;
52414 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
52415 bool result;
52416 void *argp1 = 0 ;
52417 int res1 = 0 ;
52418 wxGBPosition temp2 ;
52419 wxGBSpan temp3 ;
52420 void *argp4 = 0 ;
52421 int res4 = 0 ;
52422 PyObject * obj0 = 0 ;
52423 PyObject * obj1 = 0 ;
52424 PyObject * obj2 = 0 ;
52425 PyObject * obj3 = 0 ;
52426 char * kwnames[] = {
52427 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
52428 };
52429
52430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52431 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52432 if (!SWIG_IsOK(res1)) {
52433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52434 }
52435 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52436 {
52437 arg2 = &temp2;
52438 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
52439 }
52440 {
52441 arg3 = &temp3;
52442 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
52443 }
52444 if (obj3) {
52445 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52446 if (!SWIG_IsOK(res4)) {
52447 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
52448 }
52449 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
52450 }
52451 {
52452 PyThreadState* __tstate = wxPyBeginAllowThreads();
52453 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
52454 wxPyEndAllowThreads(__tstate);
52455 if (PyErr_Occurred()) SWIG_fail;
52456 }
52457 {
52458 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52459 }
52460 return resultobj;
52461 fail:
52462 return NULL;
52463 }
52464
52465
52466 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52467 PyObject *obj;
52468 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52469 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
52470 return SWIG_Py_Void();
52471 }
52472
52473 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52474 return SWIG_Python_InitShadowInstance(args);
52475 }
52476
52477 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52478 PyObject *resultobj = 0;
52479 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52480 wxRelationship arg2 ;
52481 wxWindow *arg3 = (wxWindow *) 0 ;
52482 wxEdge arg4 ;
52483 int arg5 = (int) 0 ;
52484 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
52485 void *argp1 = 0 ;
52486 int res1 = 0 ;
52487 int val2 ;
52488 int ecode2 = 0 ;
52489 void *argp3 = 0 ;
52490 int res3 = 0 ;
52491 int val4 ;
52492 int ecode4 = 0 ;
52493 int val5 ;
52494 int ecode5 = 0 ;
52495 int val6 ;
52496 int ecode6 = 0 ;
52497 PyObject * obj0 = 0 ;
52498 PyObject * obj1 = 0 ;
52499 PyObject * obj2 = 0 ;
52500 PyObject * obj3 = 0 ;
52501 PyObject * obj4 = 0 ;
52502 PyObject * obj5 = 0 ;
52503 char * kwnames[] = {
52504 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
52505 };
52506
52507 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
52508 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52509 if (!SWIG_IsOK(res1)) {
52510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52511 }
52512 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52513 ecode2 = SWIG_AsVal_int(obj1, &val2);
52514 if (!SWIG_IsOK(ecode2)) {
52515 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
52516 }
52517 arg2 = static_cast< wxRelationship >(val2);
52518 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52519 if (!SWIG_IsOK(res3)) {
52520 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
52521 }
52522 arg3 = reinterpret_cast< wxWindow * >(argp3);
52523 ecode4 = SWIG_AsVal_int(obj3, &val4);
52524 if (!SWIG_IsOK(ecode4)) {
52525 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
52526 }
52527 arg4 = static_cast< wxEdge >(val4);
52528 if (obj4) {
52529 ecode5 = SWIG_AsVal_int(obj4, &val5);
52530 if (!SWIG_IsOK(ecode5)) {
52531 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
52532 }
52533 arg5 = static_cast< int >(val5);
52534 }
52535 if (obj5) {
52536 ecode6 = SWIG_AsVal_int(obj5, &val6);
52537 if (!SWIG_IsOK(ecode6)) {
52538 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
52539 }
52540 arg6 = static_cast< int >(val6);
52541 }
52542 {
52543 PyThreadState* __tstate = wxPyBeginAllowThreads();
52544 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
52545 wxPyEndAllowThreads(__tstate);
52546 if (PyErr_Occurred()) SWIG_fail;
52547 }
52548 resultobj = SWIG_Py_Void();
52549 return resultobj;
52550 fail:
52551 return NULL;
52552 }
52553
52554
52555 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52556 PyObject *resultobj = 0;
52557 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52558 wxWindow *arg2 = (wxWindow *) 0 ;
52559 int arg3 = (int) 0 ;
52560 void *argp1 = 0 ;
52561 int res1 = 0 ;
52562 void *argp2 = 0 ;
52563 int res2 = 0 ;
52564 int val3 ;
52565 int ecode3 = 0 ;
52566 PyObject * obj0 = 0 ;
52567 PyObject * obj1 = 0 ;
52568 PyObject * obj2 = 0 ;
52569 char * kwnames[] = {
52570 (char *) "self",(char *) "sibling",(char *) "marg", NULL
52571 };
52572
52573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52575 if (!SWIG_IsOK(res1)) {
52576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52577 }
52578 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52579 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52580 if (!SWIG_IsOK(res2)) {
52581 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
52582 }
52583 arg2 = reinterpret_cast< wxWindow * >(argp2);
52584 if (obj2) {
52585 ecode3 = SWIG_AsVal_int(obj2, &val3);
52586 if (!SWIG_IsOK(ecode3)) {
52587 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
52588 }
52589 arg3 = static_cast< int >(val3);
52590 }
52591 {
52592 PyThreadState* __tstate = wxPyBeginAllowThreads();
52593 (arg1)->LeftOf(arg2,arg3);
52594 wxPyEndAllowThreads(__tstate);
52595 if (PyErr_Occurred()) SWIG_fail;
52596 }
52597 resultobj = SWIG_Py_Void();
52598 return resultobj;
52599 fail:
52600 return NULL;
52601 }
52602
52603
52604 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52605 PyObject *resultobj = 0;
52606 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52607 wxWindow *arg2 = (wxWindow *) 0 ;
52608 int arg3 = (int) 0 ;
52609 void *argp1 = 0 ;
52610 int res1 = 0 ;
52611 void *argp2 = 0 ;
52612 int res2 = 0 ;
52613 int val3 ;
52614 int ecode3 = 0 ;
52615 PyObject * obj0 = 0 ;
52616 PyObject * obj1 = 0 ;
52617 PyObject * obj2 = 0 ;
52618 char * kwnames[] = {
52619 (char *) "self",(char *) "sibling",(char *) "marg", NULL
52620 };
52621
52622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52623 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52624 if (!SWIG_IsOK(res1)) {
52625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52626 }
52627 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52628 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52629 if (!SWIG_IsOK(res2)) {
52630 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
52631 }
52632 arg2 = reinterpret_cast< wxWindow * >(argp2);
52633 if (obj2) {
52634 ecode3 = SWIG_AsVal_int(obj2, &val3);
52635 if (!SWIG_IsOK(ecode3)) {
52636 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
52637 }
52638 arg3 = static_cast< int >(val3);
52639 }
52640 {
52641 PyThreadState* __tstate = wxPyBeginAllowThreads();
52642 (arg1)->RightOf(arg2,arg3);
52643 wxPyEndAllowThreads(__tstate);
52644 if (PyErr_Occurred()) SWIG_fail;
52645 }
52646 resultobj = SWIG_Py_Void();
52647 return resultobj;
52648 fail:
52649 return NULL;
52650 }
52651
52652
52653 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52654 PyObject *resultobj = 0;
52655 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52656 wxWindow *arg2 = (wxWindow *) 0 ;
52657 int arg3 = (int) 0 ;
52658 void *argp1 = 0 ;
52659 int res1 = 0 ;
52660 void *argp2 = 0 ;
52661 int res2 = 0 ;
52662 int val3 ;
52663 int ecode3 = 0 ;
52664 PyObject * obj0 = 0 ;
52665 PyObject * obj1 = 0 ;
52666 PyObject * obj2 = 0 ;
52667 char * kwnames[] = {
52668 (char *) "self",(char *) "sibling",(char *) "marg", NULL
52669 };
52670
52671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52673 if (!SWIG_IsOK(res1)) {
52674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52675 }
52676 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52677 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52678 if (!SWIG_IsOK(res2)) {
52679 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
52680 }
52681 arg2 = reinterpret_cast< wxWindow * >(argp2);
52682 if (obj2) {
52683 ecode3 = SWIG_AsVal_int(obj2, &val3);
52684 if (!SWIG_IsOK(ecode3)) {
52685 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
52686 }
52687 arg3 = static_cast< int >(val3);
52688 }
52689 {
52690 PyThreadState* __tstate = wxPyBeginAllowThreads();
52691 (arg1)->Above(arg2,arg3);
52692 wxPyEndAllowThreads(__tstate);
52693 if (PyErr_Occurred()) SWIG_fail;
52694 }
52695 resultobj = SWIG_Py_Void();
52696 return resultobj;
52697 fail:
52698 return NULL;
52699 }
52700
52701
52702 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52703 PyObject *resultobj = 0;
52704 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52705 wxWindow *arg2 = (wxWindow *) 0 ;
52706 int arg3 = (int) 0 ;
52707 void *argp1 = 0 ;
52708 int res1 = 0 ;
52709 void *argp2 = 0 ;
52710 int res2 = 0 ;
52711 int val3 ;
52712 int ecode3 = 0 ;
52713 PyObject * obj0 = 0 ;
52714 PyObject * obj1 = 0 ;
52715 PyObject * obj2 = 0 ;
52716 char * kwnames[] = {
52717 (char *) "self",(char *) "sibling",(char *) "marg", NULL
52718 };
52719
52720 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52721 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52722 if (!SWIG_IsOK(res1)) {
52723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52724 }
52725 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52726 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52727 if (!SWIG_IsOK(res2)) {
52728 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
52729 }
52730 arg2 = reinterpret_cast< wxWindow * >(argp2);
52731 if (obj2) {
52732 ecode3 = SWIG_AsVal_int(obj2, &val3);
52733 if (!SWIG_IsOK(ecode3)) {
52734 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
52735 }
52736 arg3 = static_cast< int >(val3);
52737 }
52738 {
52739 PyThreadState* __tstate = wxPyBeginAllowThreads();
52740 (arg1)->Below(arg2,arg3);
52741 wxPyEndAllowThreads(__tstate);
52742 if (PyErr_Occurred()) SWIG_fail;
52743 }
52744 resultobj = SWIG_Py_Void();
52745 return resultobj;
52746 fail:
52747 return NULL;
52748 }
52749
52750
52751 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52752 PyObject *resultobj = 0;
52753 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52754 wxWindow *arg2 = (wxWindow *) 0 ;
52755 wxEdge arg3 ;
52756 int arg4 = (int) 0 ;
52757 void *argp1 = 0 ;
52758 int res1 = 0 ;
52759 void *argp2 = 0 ;
52760 int res2 = 0 ;
52761 int val3 ;
52762 int ecode3 = 0 ;
52763 int val4 ;
52764 int ecode4 = 0 ;
52765 PyObject * obj0 = 0 ;
52766 PyObject * obj1 = 0 ;
52767 PyObject * obj2 = 0 ;
52768 PyObject * obj3 = 0 ;
52769 char * kwnames[] = {
52770 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
52771 };
52772
52773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52774 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52775 if (!SWIG_IsOK(res1)) {
52776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52777 }
52778 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52779 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52780 if (!SWIG_IsOK(res2)) {
52781 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
52782 }
52783 arg2 = reinterpret_cast< wxWindow * >(argp2);
52784 ecode3 = SWIG_AsVal_int(obj2, &val3);
52785 if (!SWIG_IsOK(ecode3)) {
52786 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
52787 }
52788 arg3 = static_cast< wxEdge >(val3);
52789 if (obj3) {
52790 ecode4 = SWIG_AsVal_int(obj3, &val4);
52791 if (!SWIG_IsOK(ecode4)) {
52792 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
52793 }
52794 arg4 = static_cast< int >(val4);
52795 }
52796 {
52797 PyThreadState* __tstate = wxPyBeginAllowThreads();
52798 (arg1)->SameAs(arg2,arg3,arg4);
52799 wxPyEndAllowThreads(__tstate);
52800 if (PyErr_Occurred()) SWIG_fail;
52801 }
52802 resultobj = SWIG_Py_Void();
52803 return resultobj;
52804 fail:
52805 return NULL;
52806 }
52807
52808
52809 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52810 PyObject *resultobj = 0;
52811 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52812 wxWindow *arg2 = (wxWindow *) 0 ;
52813 wxEdge arg3 ;
52814 int arg4 ;
52815 void *argp1 = 0 ;
52816 int res1 = 0 ;
52817 void *argp2 = 0 ;
52818 int res2 = 0 ;
52819 int val3 ;
52820 int ecode3 = 0 ;
52821 int val4 ;
52822 int ecode4 = 0 ;
52823 PyObject * obj0 = 0 ;
52824 PyObject * obj1 = 0 ;
52825 PyObject * obj2 = 0 ;
52826 PyObject * obj3 = 0 ;
52827 char * kwnames[] = {
52828 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
52829 };
52830
52831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52833 if (!SWIG_IsOK(res1)) {
52834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52835 }
52836 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52837 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52838 if (!SWIG_IsOK(res2)) {
52839 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
52840 }
52841 arg2 = reinterpret_cast< wxWindow * >(argp2);
52842 ecode3 = SWIG_AsVal_int(obj2, &val3);
52843 if (!SWIG_IsOK(ecode3)) {
52844 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
52845 }
52846 arg3 = static_cast< wxEdge >(val3);
52847 ecode4 = SWIG_AsVal_int(obj3, &val4);
52848 if (!SWIG_IsOK(ecode4)) {
52849 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
52850 }
52851 arg4 = static_cast< int >(val4);
52852 {
52853 PyThreadState* __tstate = wxPyBeginAllowThreads();
52854 (arg1)->PercentOf(arg2,arg3,arg4);
52855 wxPyEndAllowThreads(__tstate);
52856 if (PyErr_Occurred()) SWIG_fail;
52857 }
52858 resultobj = SWIG_Py_Void();
52859 return resultobj;
52860 fail:
52861 return NULL;
52862 }
52863
52864
52865 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52866 PyObject *resultobj = 0;
52867 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52868 int arg2 ;
52869 void *argp1 = 0 ;
52870 int res1 = 0 ;
52871 int val2 ;
52872 int ecode2 = 0 ;
52873 PyObject * obj0 = 0 ;
52874 PyObject * obj1 = 0 ;
52875 char * kwnames[] = {
52876 (char *) "self",(char *) "val", NULL
52877 };
52878
52879 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
52880 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52881 if (!SWIG_IsOK(res1)) {
52882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52883 }
52884 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52885 ecode2 = SWIG_AsVal_int(obj1, &val2);
52886 if (!SWIG_IsOK(ecode2)) {
52887 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
52888 }
52889 arg2 = static_cast< int >(val2);
52890 {
52891 PyThreadState* __tstate = wxPyBeginAllowThreads();
52892 (arg1)->Absolute(arg2);
52893 wxPyEndAllowThreads(__tstate);
52894 if (PyErr_Occurred()) SWIG_fail;
52895 }
52896 resultobj = SWIG_Py_Void();
52897 return resultobj;
52898 fail:
52899 return NULL;
52900 }
52901
52902
52903 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52904 PyObject *resultobj = 0;
52905 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52906 void *argp1 = 0 ;
52907 int res1 = 0 ;
52908 PyObject *swig_obj[1] ;
52909
52910 if (!args) SWIG_fail;
52911 swig_obj[0] = args;
52912 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52913 if (!SWIG_IsOK(res1)) {
52914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52915 }
52916 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52917 {
52918 PyThreadState* __tstate = wxPyBeginAllowThreads();
52919 (arg1)->Unconstrained();
52920 wxPyEndAllowThreads(__tstate);
52921 if (PyErr_Occurred()) SWIG_fail;
52922 }
52923 resultobj = SWIG_Py_Void();
52924 return resultobj;
52925 fail:
52926 return NULL;
52927 }
52928
52929
52930 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52931 PyObject *resultobj = 0;
52932 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52933 void *argp1 = 0 ;
52934 int res1 = 0 ;
52935 PyObject *swig_obj[1] ;
52936
52937 if (!args) SWIG_fail;
52938 swig_obj[0] = args;
52939 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52940 if (!SWIG_IsOK(res1)) {
52941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52942 }
52943 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52944 {
52945 PyThreadState* __tstate = wxPyBeginAllowThreads();
52946 (arg1)->AsIs();
52947 wxPyEndAllowThreads(__tstate);
52948 if (PyErr_Occurred()) SWIG_fail;
52949 }
52950 resultobj = SWIG_Py_Void();
52951 return resultobj;
52952 fail:
52953 return NULL;
52954 }
52955
52956
52957 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52958 PyObject *resultobj = 0;
52959 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52960 wxWindow *result = 0 ;
52961 void *argp1 = 0 ;
52962 int res1 = 0 ;
52963 PyObject *swig_obj[1] ;
52964
52965 if (!args) SWIG_fail;
52966 swig_obj[0] = args;
52967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52968 if (!SWIG_IsOK(res1)) {
52969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52970 }
52971 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52972 {
52973 PyThreadState* __tstate = wxPyBeginAllowThreads();
52974 result = (wxWindow *)(arg1)->GetOtherWindow();
52975 wxPyEndAllowThreads(__tstate);
52976 if (PyErr_Occurred()) SWIG_fail;
52977 }
52978 {
52979 resultobj = wxPyMake_wxObject(result, 0);
52980 }
52981 return resultobj;
52982 fail:
52983 return NULL;
52984 }
52985
52986
52987 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52988 PyObject *resultobj = 0;
52989 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52990 wxEdge result;
52991 void *argp1 = 0 ;
52992 int res1 = 0 ;
52993 PyObject *swig_obj[1] ;
52994
52995 if (!args) SWIG_fail;
52996 swig_obj[0] = args;
52997 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52998 if (!SWIG_IsOK(res1)) {
52999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53000 }
53001 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53002 {
53003 PyThreadState* __tstate = wxPyBeginAllowThreads();
53004 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
53005 wxPyEndAllowThreads(__tstate);
53006 if (PyErr_Occurred()) SWIG_fail;
53007 }
53008 resultobj = SWIG_From_int(static_cast< int >(result));
53009 return resultobj;
53010 fail:
53011 return NULL;
53012 }
53013
53014
53015 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53016 PyObject *resultobj = 0;
53017 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53018 wxEdge arg2 ;
53019 void *argp1 = 0 ;
53020 int res1 = 0 ;
53021 int val2 ;
53022 int ecode2 = 0 ;
53023 PyObject * obj0 = 0 ;
53024 PyObject * obj1 = 0 ;
53025 char * kwnames[] = {
53026 (char *) "self",(char *) "which", NULL
53027 };
53028
53029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
53030 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53031 if (!SWIG_IsOK(res1)) {
53032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53033 }
53034 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53035 ecode2 = SWIG_AsVal_int(obj1, &val2);
53036 if (!SWIG_IsOK(ecode2)) {
53037 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
53038 }
53039 arg2 = static_cast< wxEdge >(val2);
53040 {
53041 PyThreadState* __tstate = wxPyBeginAllowThreads();
53042 (arg1)->SetEdge(arg2);
53043 wxPyEndAllowThreads(__tstate);
53044 if (PyErr_Occurred()) SWIG_fail;
53045 }
53046 resultobj = SWIG_Py_Void();
53047 return resultobj;
53048 fail:
53049 return NULL;
53050 }
53051
53052
53053 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53054 PyObject *resultobj = 0;
53055 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53056 int arg2 ;
53057 void *argp1 = 0 ;
53058 int res1 = 0 ;
53059 int val2 ;
53060 int ecode2 = 0 ;
53061 PyObject * obj0 = 0 ;
53062 PyObject * obj1 = 0 ;
53063 char * kwnames[] = {
53064 (char *) "self",(char *) "v", NULL
53065 };
53066
53067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
53068 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53069 if (!SWIG_IsOK(res1)) {
53070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53071 }
53072 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53073 ecode2 = SWIG_AsVal_int(obj1, &val2);
53074 if (!SWIG_IsOK(ecode2)) {
53075 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
53076 }
53077 arg2 = static_cast< int >(val2);
53078 {
53079 PyThreadState* __tstate = wxPyBeginAllowThreads();
53080 (arg1)->SetValue(arg2);
53081 wxPyEndAllowThreads(__tstate);
53082 if (PyErr_Occurred()) SWIG_fail;
53083 }
53084 resultobj = SWIG_Py_Void();
53085 return resultobj;
53086 fail:
53087 return NULL;
53088 }
53089
53090
53091 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53092 PyObject *resultobj = 0;
53093 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53094 int result;
53095 void *argp1 = 0 ;
53096 int res1 = 0 ;
53097 PyObject *swig_obj[1] ;
53098
53099 if (!args) SWIG_fail;
53100 swig_obj[0] = args;
53101 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53102 if (!SWIG_IsOK(res1)) {
53103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53104 }
53105 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53106 {
53107 PyThreadState* __tstate = wxPyBeginAllowThreads();
53108 result = (int)(arg1)->GetMargin();
53109 wxPyEndAllowThreads(__tstate);
53110 if (PyErr_Occurred()) SWIG_fail;
53111 }
53112 resultobj = SWIG_From_int(static_cast< int >(result));
53113 return resultobj;
53114 fail:
53115 return NULL;
53116 }
53117
53118
53119 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53120 PyObject *resultobj = 0;
53121 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53122 int arg2 ;
53123 void *argp1 = 0 ;
53124 int res1 = 0 ;
53125 int val2 ;
53126 int ecode2 = 0 ;
53127 PyObject * obj0 = 0 ;
53128 PyObject * obj1 = 0 ;
53129 char * kwnames[] = {
53130 (char *) "self",(char *) "m", NULL
53131 };
53132
53133 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
53134 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53135 if (!SWIG_IsOK(res1)) {
53136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53137 }
53138 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53139 ecode2 = SWIG_AsVal_int(obj1, &val2);
53140 if (!SWIG_IsOK(ecode2)) {
53141 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
53142 }
53143 arg2 = static_cast< int >(val2);
53144 {
53145 PyThreadState* __tstate = wxPyBeginAllowThreads();
53146 (arg1)->SetMargin(arg2);
53147 wxPyEndAllowThreads(__tstate);
53148 if (PyErr_Occurred()) SWIG_fail;
53149 }
53150 resultobj = SWIG_Py_Void();
53151 return resultobj;
53152 fail:
53153 return NULL;
53154 }
53155
53156
53157 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53158 PyObject *resultobj = 0;
53159 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53160 int result;
53161 void *argp1 = 0 ;
53162 int res1 = 0 ;
53163 PyObject *swig_obj[1] ;
53164
53165 if (!args) SWIG_fail;
53166 swig_obj[0] = args;
53167 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53168 if (!SWIG_IsOK(res1)) {
53169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53170 }
53171 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53172 {
53173 PyThreadState* __tstate = wxPyBeginAllowThreads();
53174 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
53175 wxPyEndAllowThreads(__tstate);
53176 if (PyErr_Occurred()) SWIG_fail;
53177 }
53178 resultobj = SWIG_From_int(static_cast< int >(result));
53179 return resultobj;
53180 fail:
53181 return NULL;
53182 }
53183
53184
53185 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53186 PyObject *resultobj = 0;
53187 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53188 int result;
53189 void *argp1 = 0 ;
53190 int res1 = 0 ;
53191 PyObject *swig_obj[1] ;
53192
53193 if (!args) SWIG_fail;
53194 swig_obj[0] = args;
53195 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53196 if (!SWIG_IsOK(res1)) {
53197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53198 }
53199 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53200 {
53201 PyThreadState* __tstate = wxPyBeginAllowThreads();
53202 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
53203 wxPyEndAllowThreads(__tstate);
53204 if (PyErr_Occurred()) SWIG_fail;
53205 }
53206 resultobj = SWIG_From_int(static_cast< int >(result));
53207 return resultobj;
53208 fail:
53209 return NULL;
53210 }
53211
53212
53213 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53214 PyObject *resultobj = 0;
53215 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53216 int result;
53217 void *argp1 = 0 ;
53218 int res1 = 0 ;
53219 PyObject *swig_obj[1] ;
53220
53221 if (!args) SWIG_fail;
53222 swig_obj[0] = args;
53223 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53224 if (!SWIG_IsOK(res1)) {
53225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53226 }
53227 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53228 {
53229 PyThreadState* __tstate = wxPyBeginAllowThreads();
53230 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
53231 wxPyEndAllowThreads(__tstate);
53232 if (PyErr_Occurred()) SWIG_fail;
53233 }
53234 resultobj = SWIG_From_int(static_cast< int >(result));
53235 return resultobj;
53236 fail:
53237 return NULL;
53238 }
53239
53240
53241 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53242 PyObject *resultobj = 0;
53243 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53244 bool result;
53245 void *argp1 = 0 ;
53246 int res1 = 0 ;
53247 PyObject *swig_obj[1] ;
53248
53249 if (!args) SWIG_fail;
53250 swig_obj[0] = args;
53251 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53252 if (!SWIG_IsOK(res1)) {
53253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53254 }
53255 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53256 {
53257 PyThreadState* __tstate = wxPyBeginAllowThreads();
53258 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
53259 wxPyEndAllowThreads(__tstate);
53260 if (PyErr_Occurred()) SWIG_fail;
53261 }
53262 {
53263 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53264 }
53265 return resultobj;
53266 fail:
53267 return NULL;
53268 }
53269
53270
53271 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53272 PyObject *resultobj = 0;
53273 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53274 bool arg2 ;
53275 void *argp1 = 0 ;
53276 int res1 = 0 ;
53277 bool val2 ;
53278 int ecode2 = 0 ;
53279 PyObject * obj0 = 0 ;
53280 PyObject * obj1 = 0 ;
53281 char * kwnames[] = {
53282 (char *) "self",(char *) "d", NULL
53283 };
53284
53285 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
53286 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53287 if (!SWIG_IsOK(res1)) {
53288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53289 }
53290 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53291 ecode2 = SWIG_AsVal_bool(obj1, &val2);
53292 if (!SWIG_IsOK(ecode2)) {
53293 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
53294 }
53295 arg2 = static_cast< bool >(val2);
53296 {
53297 PyThreadState* __tstate = wxPyBeginAllowThreads();
53298 (arg1)->SetDone(arg2);
53299 wxPyEndAllowThreads(__tstate);
53300 if (PyErr_Occurred()) SWIG_fail;
53301 }
53302 resultobj = SWIG_Py_Void();
53303 return resultobj;
53304 fail:
53305 return NULL;
53306 }
53307
53308
53309 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53310 PyObject *resultobj = 0;
53311 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53312 wxRelationship result;
53313 void *argp1 = 0 ;
53314 int res1 = 0 ;
53315 PyObject *swig_obj[1] ;
53316
53317 if (!args) SWIG_fail;
53318 swig_obj[0] = args;
53319 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53320 if (!SWIG_IsOK(res1)) {
53321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53322 }
53323 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53324 {
53325 PyThreadState* __tstate = wxPyBeginAllowThreads();
53326 result = (wxRelationship)(arg1)->GetRelationship();
53327 wxPyEndAllowThreads(__tstate);
53328 if (PyErr_Occurred()) SWIG_fail;
53329 }
53330 resultobj = SWIG_From_int(static_cast< int >(result));
53331 return resultobj;
53332 fail:
53333 return NULL;
53334 }
53335
53336
53337 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53338 PyObject *resultobj = 0;
53339 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53340 wxRelationship arg2 ;
53341 void *argp1 = 0 ;
53342 int res1 = 0 ;
53343 int val2 ;
53344 int ecode2 = 0 ;
53345 PyObject * obj0 = 0 ;
53346 PyObject * obj1 = 0 ;
53347 char * kwnames[] = {
53348 (char *) "self",(char *) "r", NULL
53349 };
53350
53351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
53352 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53353 if (!SWIG_IsOK(res1)) {
53354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53355 }
53356 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53357 ecode2 = SWIG_AsVal_int(obj1, &val2);
53358 if (!SWIG_IsOK(ecode2)) {
53359 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
53360 }
53361 arg2 = static_cast< wxRelationship >(val2);
53362 {
53363 PyThreadState* __tstate = wxPyBeginAllowThreads();
53364 (arg1)->SetRelationship(arg2);
53365 wxPyEndAllowThreads(__tstate);
53366 if (PyErr_Occurred()) SWIG_fail;
53367 }
53368 resultobj = SWIG_Py_Void();
53369 return resultobj;
53370 fail:
53371 return NULL;
53372 }
53373
53374
53375 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53376 PyObject *resultobj = 0;
53377 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53378 wxWindow *arg2 = (wxWindow *) 0 ;
53379 bool result;
53380 void *argp1 = 0 ;
53381 int res1 = 0 ;
53382 void *argp2 = 0 ;
53383 int res2 = 0 ;
53384 PyObject * obj0 = 0 ;
53385 PyObject * obj1 = 0 ;
53386 char * kwnames[] = {
53387 (char *) "self",(char *) "otherW", NULL
53388 };
53389
53390 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
53391 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53392 if (!SWIG_IsOK(res1)) {
53393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53394 }
53395 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53396 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53397 if (!SWIG_IsOK(res2)) {
53398 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
53399 }
53400 arg2 = reinterpret_cast< wxWindow * >(argp2);
53401 {
53402 PyThreadState* __tstate = wxPyBeginAllowThreads();
53403 result = (bool)(arg1)->ResetIfWin(arg2);
53404 wxPyEndAllowThreads(__tstate);
53405 if (PyErr_Occurred()) SWIG_fail;
53406 }
53407 {
53408 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53409 }
53410 return resultobj;
53411 fail:
53412 return NULL;
53413 }
53414
53415
53416 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53417 PyObject *resultobj = 0;
53418 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53419 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
53420 wxWindow *arg3 = (wxWindow *) 0 ;
53421 bool result;
53422 void *argp1 = 0 ;
53423 int res1 = 0 ;
53424 void *argp2 = 0 ;
53425 int res2 = 0 ;
53426 void *argp3 = 0 ;
53427 int res3 = 0 ;
53428 PyObject * obj0 = 0 ;
53429 PyObject * obj1 = 0 ;
53430 PyObject * obj2 = 0 ;
53431 char * kwnames[] = {
53432 (char *) "self",(char *) "constraints",(char *) "win", NULL
53433 };
53434
53435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53436 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53437 if (!SWIG_IsOK(res1)) {
53438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53439 }
53440 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53441 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53442 if (!SWIG_IsOK(res2)) {
53443 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
53444 }
53445 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
53446 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
53447 if (!SWIG_IsOK(res3)) {
53448 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
53449 }
53450 arg3 = reinterpret_cast< wxWindow * >(argp3);
53451 {
53452 PyThreadState* __tstate = wxPyBeginAllowThreads();
53453 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
53454 wxPyEndAllowThreads(__tstate);
53455 if (PyErr_Occurred()) SWIG_fail;
53456 }
53457 {
53458 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53459 }
53460 return resultobj;
53461 fail:
53462 return NULL;
53463 }
53464
53465
53466 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53467 PyObject *resultobj = 0;
53468 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53469 wxEdge arg2 ;
53470 wxWindow *arg3 = (wxWindow *) 0 ;
53471 wxWindow *arg4 = (wxWindow *) 0 ;
53472 int result;
53473 void *argp1 = 0 ;
53474 int res1 = 0 ;
53475 int val2 ;
53476 int ecode2 = 0 ;
53477 void *argp3 = 0 ;
53478 int res3 = 0 ;
53479 void *argp4 = 0 ;
53480 int res4 = 0 ;
53481 PyObject * obj0 = 0 ;
53482 PyObject * obj1 = 0 ;
53483 PyObject * obj2 = 0 ;
53484 PyObject * obj3 = 0 ;
53485 char * kwnames[] = {
53486 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
53487 };
53488
53489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
53490 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53491 if (!SWIG_IsOK(res1)) {
53492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53493 }
53494 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53495 ecode2 = SWIG_AsVal_int(obj1, &val2);
53496 if (!SWIG_IsOK(ecode2)) {
53497 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
53498 }
53499 arg2 = static_cast< wxEdge >(val2);
53500 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
53501 if (!SWIG_IsOK(res3)) {
53502 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
53503 }
53504 arg3 = reinterpret_cast< wxWindow * >(argp3);
53505 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
53506 if (!SWIG_IsOK(res4)) {
53507 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
53508 }
53509 arg4 = reinterpret_cast< wxWindow * >(argp4);
53510 {
53511 PyThreadState* __tstate = wxPyBeginAllowThreads();
53512 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
53513 wxPyEndAllowThreads(__tstate);
53514 if (PyErr_Occurred()) SWIG_fail;
53515 }
53516 resultobj = SWIG_From_int(static_cast< int >(result));
53517 return resultobj;
53518 fail:
53519 return NULL;
53520 }
53521
53522
53523 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53524 PyObject *obj;
53525 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53526 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
53527 return SWIG_Py_Void();
53528 }
53529
53530 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53531 PyObject *resultobj = 0;
53532 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53533 wxIndividualLayoutConstraint *result = 0 ;
53534 void *argp1 = 0 ;
53535 int res1 = 0 ;
53536 PyObject *swig_obj[1] ;
53537
53538 if (!args) SWIG_fail;
53539 swig_obj[0] = args;
53540 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53541 if (!SWIG_IsOK(res1)) {
53542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53543 }
53544 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53545 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
53546 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53547 return resultobj;
53548 fail:
53549 return NULL;
53550 }
53551
53552
53553 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53554 PyObject *resultobj = 0;
53555 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53556 wxIndividualLayoutConstraint *result = 0 ;
53557 void *argp1 = 0 ;
53558 int res1 = 0 ;
53559 PyObject *swig_obj[1] ;
53560
53561 if (!args) SWIG_fail;
53562 swig_obj[0] = args;
53563 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53564 if (!SWIG_IsOK(res1)) {
53565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53566 }
53567 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53568 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
53569 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53570 return resultobj;
53571 fail:
53572 return NULL;
53573 }
53574
53575
53576 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53577 PyObject *resultobj = 0;
53578 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53579 wxIndividualLayoutConstraint *result = 0 ;
53580 void *argp1 = 0 ;
53581 int res1 = 0 ;
53582 PyObject *swig_obj[1] ;
53583
53584 if (!args) SWIG_fail;
53585 swig_obj[0] = args;
53586 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53587 if (!SWIG_IsOK(res1)) {
53588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53589 }
53590 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53591 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
53592 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53593 return resultobj;
53594 fail:
53595 return NULL;
53596 }
53597
53598
53599 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53600 PyObject *resultobj = 0;
53601 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53602 wxIndividualLayoutConstraint *result = 0 ;
53603 void *argp1 = 0 ;
53604 int res1 = 0 ;
53605 PyObject *swig_obj[1] ;
53606
53607 if (!args) SWIG_fail;
53608 swig_obj[0] = args;
53609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53610 if (!SWIG_IsOK(res1)) {
53611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53612 }
53613 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53614 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
53615 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53616 return resultobj;
53617 fail:
53618 return NULL;
53619 }
53620
53621
53622 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53623 PyObject *resultobj = 0;
53624 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53625 wxIndividualLayoutConstraint *result = 0 ;
53626 void *argp1 = 0 ;
53627 int res1 = 0 ;
53628 PyObject *swig_obj[1] ;
53629
53630 if (!args) SWIG_fail;
53631 swig_obj[0] = args;
53632 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53633 if (!SWIG_IsOK(res1)) {
53634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53635 }
53636 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53637 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
53638 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53639 return resultobj;
53640 fail:
53641 return NULL;
53642 }
53643
53644
53645 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53646 PyObject *resultobj = 0;
53647 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53648 wxIndividualLayoutConstraint *result = 0 ;
53649 void *argp1 = 0 ;
53650 int res1 = 0 ;
53651 PyObject *swig_obj[1] ;
53652
53653 if (!args) SWIG_fail;
53654 swig_obj[0] = args;
53655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53656 if (!SWIG_IsOK(res1)) {
53657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53658 }
53659 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53660 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
53661 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53662 return resultobj;
53663 fail:
53664 return NULL;
53665 }
53666
53667
53668 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53669 PyObject *resultobj = 0;
53670 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53671 wxIndividualLayoutConstraint *result = 0 ;
53672 void *argp1 = 0 ;
53673 int res1 = 0 ;
53674 PyObject *swig_obj[1] ;
53675
53676 if (!args) SWIG_fail;
53677 swig_obj[0] = args;
53678 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53679 if (!SWIG_IsOK(res1)) {
53680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53681 }
53682 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53683 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
53684 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53685 return resultobj;
53686 fail:
53687 return NULL;
53688 }
53689
53690
53691 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53692 PyObject *resultobj = 0;
53693 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53694 wxIndividualLayoutConstraint *result = 0 ;
53695 void *argp1 = 0 ;
53696 int res1 = 0 ;
53697 PyObject *swig_obj[1] ;
53698
53699 if (!args) SWIG_fail;
53700 swig_obj[0] = args;
53701 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53702 if (!SWIG_IsOK(res1)) {
53703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53704 }
53705 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53706 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
53707 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53708 return resultobj;
53709 fail:
53710 return NULL;
53711 }
53712
53713
53714 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53715 PyObject *resultobj = 0;
53716 wxLayoutConstraints *result = 0 ;
53717
53718 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
53719 {
53720 PyThreadState* __tstate = wxPyBeginAllowThreads();
53721 result = (wxLayoutConstraints *)new wxLayoutConstraints();
53722 wxPyEndAllowThreads(__tstate);
53723 if (PyErr_Occurred()) SWIG_fail;
53724 }
53725 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
53726 return resultobj;
53727 fail:
53728 return NULL;
53729 }
53730
53731
53732 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53733 PyObject *resultobj = 0;
53734 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53735 void *argp1 = 0 ;
53736 int res1 = 0 ;
53737 PyObject *swig_obj[1] ;
53738
53739 if (!args) SWIG_fail;
53740 swig_obj[0] = args;
53741 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
53742 if (!SWIG_IsOK(res1)) {
53743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53744 }
53745 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53746 {
53747 PyThreadState* __tstate = wxPyBeginAllowThreads();
53748 delete arg1;
53749
53750 wxPyEndAllowThreads(__tstate);
53751 if (PyErr_Occurred()) SWIG_fail;
53752 }
53753 resultobj = SWIG_Py_Void();
53754 return resultobj;
53755 fail:
53756 return NULL;
53757 }
53758
53759
53760 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53761 PyObject *resultobj = 0;
53762 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53763 wxWindow *arg2 = (wxWindow *) 0 ;
53764 int *arg3 = (int *) 0 ;
53765 bool result;
53766 void *argp1 = 0 ;
53767 int res1 = 0 ;
53768 void *argp2 = 0 ;
53769 int res2 = 0 ;
53770 int temp3 ;
53771 int res3 = SWIG_TMPOBJ ;
53772 PyObject * obj0 = 0 ;
53773 PyObject * obj1 = 0 ;
53774 char * kwnames[] = {
53775 (char *) "self",(char *) "win", NULL
53776 };
53777
53778 arg3 = &temp3;
53779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
53780 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53781 if (!SWIG_IsOK(res1)) {
53782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53783 }
53784 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53785 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53786 if (!SWIG_IsOK(res2)) {
53787 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
53788 }
53789 arg2 = reinterpret_cast< wxWindow * >(argp2);
53790 {
53791 PyThreadState* __tstate = wxPyBeginAllowThreads();
53792 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
53793 wxPyEndAllowThreads(__tstate);
53794 if (PyErr_Occurred()) SWIG_fail;
53795 }
53796 {
53797 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53798 }
53799 if (SWIG_IsTmpObj(res3)) {
53800 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
53801 } else {
53802 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
53803 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
53804 }
53805 return resultobj;
53806 fail:
53807 return NULL;
53808 }
53809
53810
53811 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53812 PyObject *resultobj = 0;
53813 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53814 bool result;
53815 void *argp1 = 0 ;
53816 int res1 = 0 ;
53817 PyObject *swig_obj[1] ;
53818
53819 if (!args) SWIG_fail;
53820 swig_obj[0] = args;
53821 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53822 if (!SWIG_IsOK(res1)) {
53823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
53824 }
53825 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53826 {
53827 PyThreadState* __tstate = wxPyBeginAllowThreads();
53828 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
53829 wxPyEndAllowThreads(__tstate);
53830 if (PyErr_Occurred()) SWIG_fail;
53831 }
53832 {
53833 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53834 }
53835 return resultobj;
53836 fail:
53837 return NULL;
53838 }
53839
53840
53841 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53842 PyObject *obj;
53843 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53844 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
53845 return SWIG_Py_Void();
53846 }
53847
53848 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53849 return SWIG_Python_InitShadowInstance(args);
53850 }
53851
53852 static PyMethodDef SwigMethods[] = {
53853 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
53854 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
53855 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
53856 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
53857 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
53858 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
53859 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
53860 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
53861 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
53862 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
53863 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53864 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53865 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
53866 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
53867 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
53868 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
53869 { (char *)"Size_Scale", (PyCFunction) _wrap_Size_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
53870 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53871 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
53872 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
53873 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
53874 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
53875 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
53876 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
53877 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
53878 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
53879 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
53880 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
53881 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
53882 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
53883 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
53884 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53885 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
53886 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53887 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53888 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
53889 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
53890 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53891 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
53892 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
53893 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
53894 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
53895 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
53896 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
53897 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
53898 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
53899 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
53900 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53901 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53902 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
53903 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
53904 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
53905 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
53906 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53907 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
53908 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
53909 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
53910 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
53911 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
53912 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
53913 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
53914 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
53915 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
53916 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
53917 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
53918 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
53919 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
53920 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
53921 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
53922 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
53923 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
53924 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53925 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
53926 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53927 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
53928 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
53929 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
53930 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
53931 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
53932 { (char *)"Rect_GetTopRight", (PyCFunction)_wrap_Rect_GetTopRight, METH_O, NULL},
53933 { (char *)"Rect_SetTopRight", (PyCFunction) _wrap_Rect_SetTopRight, METH_VARARGS | METH_KEYWORDS, NULL},
53934 { (char *)"Rect_GetBottomLeft", (PyCFunction)_wrap_Rect_GetBottomLeft, METH_O, NULL},
53935 { (char *)"Rect_SetBottomLeft", (PyCFunction) _wrap_Rect_SetBottomLeft, METH_VARARGS | METH_KEYWORDS, NULL},
53936 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
53937 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
53938 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
53939 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
53940 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
53941 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
53942 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
53943 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
53944 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
53945 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
53946 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
53947 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
53948 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
53949 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
53950 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
53951 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
53952 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53953 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53954 { (char *)"Rect_ContainsXY", (PyCFunction) _wrap_Rect_ContainsXY, METH_VARARGS | METH_KEYWORDS, NULL},
53955 { (char *)"Rect_Contains", (PyCFunction) _wrap_Rect_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
53956 { (char *)"Rect_ContainsRect", (PyCFunction) _wrap_Rect_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
53957 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
53958 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
53959 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
53960 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
53961 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
53962 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
53963 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
53964 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
53965 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
53966 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
53967 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53968 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
53969 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
53970 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
53971 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
53972 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
53973 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
53974 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53975 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
53976 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
53977 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
53978 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
53979 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
53980 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
53981 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
53982 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
53983 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
53984 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
53985 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
53986 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
53987 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
53988 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
53989 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
53990 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53991 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53992 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
53993 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
53994 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
53995 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
53996 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53997 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
53998 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
53999 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
54000 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
54001 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
54002 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
54003 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
54004 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
54005 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
54006 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
54007 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
54008 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
54009 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
54010 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
54011 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
54012 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
54013 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
54014 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
54015 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
54016 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
54017 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
54018 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
54019 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
54020 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
54021 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
54022 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
54023 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
54024 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
54025 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
54026 { (char *)"FSFile_DetachStream", (PyCFunction)_wrap_FSFile_DetachStream, METH_O, NULL},
54027 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
54028 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
54029 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
54030 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
54031 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
54032 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
54033 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
54034 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
54035 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
54036 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54037 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
54038 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
54039 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
54040 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
54041 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
54042 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
54043 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
54044 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
54045 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
54046 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
54047 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
54048 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
54049 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
54050 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
54051 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
54052 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
54053 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
54054 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
54055 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54056 { (char *)"FileSystem_RemoveHandler", (PyCFunction) _wrap_FileSystem_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54057 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
54058 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
54059 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
54060 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
54061 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
54062 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
54063 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
54064 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
54065 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
54066 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
54067 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
54068 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
54069 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
54070 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
54071 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
54072 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
54073 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
54074 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
54075 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54076 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
54077 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
54078 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
54079 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
54080 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
54081 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
54082 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
54083 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
54084 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
54085 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
54086 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
54087 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
54088 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
54089 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
54090 { (char *)"ImageHandler_CanReadStream", (PyCFunction) _wrap_ImageHandler_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
54091 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
54092 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
54093 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
54094 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
54095 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
54096 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
54097 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
54098 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
54099 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
54100 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
54101 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
54102 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
54103 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
54104 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
54105 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
54106 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
54107 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
54108 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
54109 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
54110 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
54111 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
54112 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
54113 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
54114 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
54115 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
54116 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
54117 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
54118 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
54119 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
54120 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
54121 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
54122 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
54123 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
54124 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
54125 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
54126 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
54127 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
54128 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
54129 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
54130 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
54131 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
54132 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54133 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
54134 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
54135 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
54136 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
54137 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
54138 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
54139 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
54140 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
54141 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
54142 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
54143 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
54144 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
54145 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
54146 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
54147 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
54148 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
54149 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
54150 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
54151 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
54152 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
54153 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
54154 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
54155 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
54156 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
54157 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
54158 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
54159 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
54160 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
54161 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
54162 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
54163 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
54164 { (char *)"Image_Ok", (PyCFunction)_wrap_Image_Ok, METH_O, NULL},
54165 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
54166 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
54167 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
54168 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
54169 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
54170 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
54171 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
54172 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
54173 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
54174 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
54175 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
54176 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
54177 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
54178 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
54179 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
54180 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
54181 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
54182 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
54183 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
54184 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
54185 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
54186 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
54187 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
54188 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
54189 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
54190 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
54191 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
54192 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
54193 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
54194 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
54195 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
54196 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
54197 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
54198 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
54199 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
54200 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54201 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54202 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54203 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
54204 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
54205 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54206 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54207 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
54208 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
54209 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
54210 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
54211 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
54212 { (char *)"_ImageFromBuffer", (PyCFunction) _wrap__ImageFromBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
54213 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
54214 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
54215 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
54216 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
54217 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
54218 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
54219 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
54220 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
54221 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
54222 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
54223 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
54224 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
54225 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
54226 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
54227 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
54228 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
54229 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
54230 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
54231 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
54232 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
54233 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
54234 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
54235 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
54236 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
54237 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
54238 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
54239 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
54240 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
54241 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
54242 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
54243 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
54244 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
54245 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
54246 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
54247 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
54248 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
54249 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
54250 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
54251 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54252 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54253 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
54254 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
54255 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54256 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54257 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
54258 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
54259 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
54260 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54261 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
54262 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
54263 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
54264 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
54265 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
54266 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
54267 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
54268 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
54269 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
54270 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
54271 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
54272 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
54273 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
54274 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
54275 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
54276 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
54277 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
54278 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
54279 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
54280 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
54281 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
54282 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
54283 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
54284 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
54285 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
54286 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
54287 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
54288 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
54289 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54290 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
54291 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
54292 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
54293 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
54294 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
54295 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
54296 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
54297 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
54298 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
54299 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
54300 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
54301 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
54302 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
54303 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
54304 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54305 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
54306 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
54307 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
54308 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
54309 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
54310 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54311 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
54312 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
54313 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
54314 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54315 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
54316 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
54317 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54318 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
54319 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
54320 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
54321 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54322 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
54323 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
54324 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54325 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
54326 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
54327 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
54328 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
54329 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
54330 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
54331 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
54332 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
54333 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
54334 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
54335 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
54336 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
54337 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
54338 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
54339 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
54340 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
54341 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
54342 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
54343 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
54344 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
54345 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
54346 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
54347 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
54348 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
54349 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
54350 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
54351 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
54352 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
54353 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
54354 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
54355 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54356 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
54357 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
54358 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
54359 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
54360 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
54361 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
54362 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
54363 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
54364 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
54365 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
54366 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
54367 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
54368 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
54369 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
54370 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
54371 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
54372 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
54373 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
54374 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
54375 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
54376 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
54377 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
54378 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
54379 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
54380 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
54381 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
54382 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
54383 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
54384 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
54385 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
54386 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
54387 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
54388 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54389 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
54390 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
54391 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
54392 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
54393 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
54394 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
54395 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
54396 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54397 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
54398 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
54399 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
54400 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
54401 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
54402 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
54403 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
54404 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
54405 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
54406 { (char *)"KeyEvent_SetUnicodeKey", (PyCFunction) _wrap_KeyEvent_SetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
54407 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
54408 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
54409 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
54410 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
54411 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
54412 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
54413 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
54414 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
54415 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
54416 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
54417 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
54418 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
54419 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
54420 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
54421 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
54422 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
54423 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
54424 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
54425 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
54426 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
54427 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
54428 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
54429 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
54430 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
54431 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
54432 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
54433 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
54434 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
54435 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54436 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
54437 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
54438 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
54439 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
54440 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
54441 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
54442 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
54443 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
54444 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
54445 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
54446 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54447 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
54448 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
54449 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
54450 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54451 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
54452 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
54453 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54454 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
54455 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
54456 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54457 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
54458 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
54459 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54460 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
54461 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
54462 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
54463 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54464 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
54465 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54466 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
54467 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
54468 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54469 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
54470 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
54471 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
54472 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54473 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
54474 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
54475 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
54476 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54477 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
54478 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
54479 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54480 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
54481 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
54482 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
54483 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
54484 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
54485 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54486 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
54487 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
54488 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
54489 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
54490 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
54491 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
54492 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
54493 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
54494 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54495 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
54496 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
54497 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
54498 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
54499 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54500 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
54501 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
54502 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
54503 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54504 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
54505 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
54506 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
54507 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
54508 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
54509 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
54510 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54511 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
54512 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
54513 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
54514 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
54515 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
54516 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
54517 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
54518 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
54519 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
54520 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54521 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
54522 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
54523 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
54524 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
54525 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
54526 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
54527 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
54528 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
54529 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
54530 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
54531 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
54532 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
54533 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
54534 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54535 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
54536 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
54537 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
54538 { (char *)"new_MouseCaptureLostEvent", (PyCFunction) _wrap_new_MouseCaptureLostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54539 { (char *)"MouseCaptureLostEvent_swigregister", MouseCaptureLostEvent_swigregister, METH_VARARGS, NULL},
54540 { (char *)"MouseCaptureLostEvent_swiginit", MouseCaptureLostEvent_swiginit, METH_VARARGS, NULL},
54541 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
54542 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
54543 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
54544 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54545 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54546 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
54547 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
54548 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
54549 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54550 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
54551 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
54552 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
54553 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
54554 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
54555 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
54556 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
54557 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
54558 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
54559 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
54560 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
54561 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
54562 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
54563 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
54564 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
54565 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
54566 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54567 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
54568 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
54569 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
54570 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54571 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
54572 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
54573 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
54574 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54575 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
54576 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54577 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
54578 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
54579 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
54580 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
54581 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
54582 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
54583 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
54584 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
54585 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
54586 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
54587 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54588 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
54589 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
54590 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54591 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
54592 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
54593 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
54594 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
54595 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
54596 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54597 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
54598 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
54599 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
54600 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
54601 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
54602 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54603 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
54604 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
54605 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
54606 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
54607 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
54608 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
54609 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54610 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
54611 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
54612 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
54613 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
54614 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
54615 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
54616 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
54617 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
54618 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
54619 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
54620 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
54621 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
54622 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
54623 { (char *)"PyApp_GetLayoutDirection", (PyCFunction)_wrap_PyApp_GetLayoutDirection, METH_O, NULL},
54624 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
54625 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
54626 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
54627 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
54628 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
54629 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
54630 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54631 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
54632 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
54633 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
54634 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
54635 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
54636 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
54637 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
54638 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
54639 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
54640 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
54641 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
54642 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
54643 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
54644 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
54645 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
54646 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
54647 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
54648 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
54649 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
54650 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
54651 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
54652 { (char *)"PyApp_IsDisplayAvailable", (PyCFunction)_wrap_PyApp_IsDisplayAvailable, METH_NOARGS, NULL},
54653 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
54654 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
54655 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
54656 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
54657 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
54658 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
54659 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
54660 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54661 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
54662 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
54663 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
54664 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
54665 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
54666 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
54667 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
54668 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
54669 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
54670 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
54671 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
54672 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
54673 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
54674 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
54675 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
54676 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
54677 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
54678 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
54679 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
54680 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
54681 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
54682 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54683 { (char *)"AcceleratorEntry_Create", (PyCFunction) _wrap_AcceleratorEntry_Create, METH_VARARGS | METH_KEYWORDS, NULL},
54684 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
54685 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
54686 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
54687 { (char *)"AcceleratorEntry_IsOk", (PyCFunction)_wrap_AcceleratorEntry_IsOk, METH_O, NULL},
54688 { (char *)"AcceleratorEntry_ToString", (PyCFunction)_wrap_AcceleratorEntry_ToString, METH_O, NULL},
54689 { (char *)"AcceleratorEntry_FromString", (PyCFunction) _wrap_AcceleratorEntry_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
54690 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
54691 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
54692 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
54693 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
54694 { (char *)"AcceleratorTable_Ok", (PyCFunction)_wrap_AcceleratorTable_Ok, METH_O, NULL},
54695 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
54696 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
54697 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
54698 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
54699 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
54700 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
54701 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
54702 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
54703 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
54704 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
54705 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
54706 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
54707 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
54708 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
54709 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
54710 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
54711 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
54712 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
54713 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
54714 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
54715 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54716 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
54717 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
54718 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
54719 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
54720 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
54721 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
54722 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
54723 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
54724 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
54725 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
54726 { (char *)"Window_GetLayoutDirection", (PyCFunction)_wrap_Window_GetLayoutDirection, METH_O, NULL},
54727 { (char *)"Window_SetLayoutDirection", (PyCFunction) _wrap_Window_SetLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
54728 { (char *)"Window_AdjustForLayoutDirection", (PyCFunction) _wrap_Window_AdjustForLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
54729 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
54730 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
54731 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
54732 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
54733 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
54734 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
54735 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
54736 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
54737 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
54738 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
54739 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
54740 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
54741 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
54742 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
54743 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
54744 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
54745 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
54746 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
54747 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
54748 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
54749 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
54750 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
54751 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
54752 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
54753 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
54754 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
54755 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
54756 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
54757 { (char *)"Window_GetBestFittingSize", (PyCFunction)_wrap_Window_GetBestFittingSize, METH_O, NULL},
54758 { (char *)"Window_GetAdjustedBestSize", (PyCFunction)_wrap_Window_GetAdjustedBestSize, METH_O, NULL},
54759 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
54760 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
54761 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
54762 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
54763 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
54764 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
54765 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
54766 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
54767 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
54768 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
54769 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
54770 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
54771 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
54772 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
54773 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
54774 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
54775 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
54776 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
54777 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
54778 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
54779 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
54780 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
54781 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
54782 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54783 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
54784 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
54785 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
54786 { (char *)"Window_IsShownOnScreen", (PyCFunction)_wrap_Window_IsShownOnScreen, METH_O, NULL},
54787 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
54788 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
54789 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
54790 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
54791 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
54792 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
54793 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
54794 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
54795 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
54796 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
54797 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
54798 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
54799 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
54800 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
54801 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
54802 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
54803 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
54804 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
54805 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
54806 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
54807 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
54808 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
54809 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
54810 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
54811 { (char *)"Window_SetDoubleBuffered", (PyCFunction) _wrap_Window_SetDoubleBuffered, METH_VARARGS | METH_KEYWORDS, NULL},
54812 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
54813 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
54814 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
54815 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54816 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54817 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54818 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54819 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
54820 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
54821 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
54822 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
54823 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
54824 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
54825 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
54826 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
54827 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
54828 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
54829 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
54830 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
54831 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
54832 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
54833 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
54834 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
54835 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
54836 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
54837 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
54838 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
54839 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
54840 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
54841 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
54842 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
54843 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
54844 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
54845 { (char *)"Window_IsFrozen", (PyCFunction)_wrap_Window_IsFrozen, METH_O, NULL},
54846 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
54847 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
54848 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
54849 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
54850 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
54851 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54852 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
54853 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
54854 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
54855 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54856 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54857 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54858 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54859 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
54860 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
54861 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
54862 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
54863 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
54864 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
54865 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
54866 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
54867 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
54868 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
54869 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
54870 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
54871 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
54872 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
54873 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
54874 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
54875 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
54876 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
54877 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
54878 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
54879 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
54880 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
54881 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
54882 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
54883 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
54884 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
54885 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
54886 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54887 { (char *)"Window_HasMultiplePages", (PyCFunction)_wrap_Window_HasMultiplePages, METH_O, NULL},
54888 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
54889 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
54890 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
54891 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
54892 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
54893 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
54894 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
54895 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
54896 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
54897 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54898 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
54899 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
54900 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
54901 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
54902 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
54903 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
54904 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
54905 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
54906 { (char *)"Window_GetHelpTextAtPoint", (PyCFunction) _wrap_Window_GetHelpTextAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54907 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
54908 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
54909 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
54910 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
54911 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
54912 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
54913 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
54914 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
54915 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
54916 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
54917 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
54918 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
54919 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54920 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
54921 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
54922 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54923 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
54924 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
54925 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
54926 { (char *)"Window_CanSetTransparent", (PyCFunction)_wrap_Window_CanSetTransparent, METH_O, NULL},
54927 { (char *)"Window_SetTransparent", (PyCFunction) _wrap_Window_SetTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
54928 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
54929 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
54930 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
54931 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
54932 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54933 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
54934 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
54935 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
54936 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
54937 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
54938 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
54939 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
54940 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
54941 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54942 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
54943 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
54944 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
54945 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
54946 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
54947 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54948 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
54949 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
54950 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
54951 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
54952 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
54953 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
54954 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
54955 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54956 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54957 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
54958 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
54959 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
54960 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
54961 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54962 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
54963 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
54964 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
54965 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54966 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
54967 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
54968 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
54969 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
54970 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54971 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
54972 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
54973 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
54974 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
54975 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
54976 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
54977 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
54978 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
54979 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
54980 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
54981 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
54982 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54983 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54984 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
54985 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
54986 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
54987 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54988 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54989 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
54990 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
54991 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
54992 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
54993 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54994 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
54995 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54996 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
54997 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
54998 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
54999 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
55000 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
55001 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
55002 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
55003 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
55004 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
55005 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
55006 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
55007 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
55008 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
55009 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
55010 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
55011 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55012 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
55013 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
55014 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
55015 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
55016 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
55017 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
55018 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
55019 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
55020 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55021 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
55022 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
55023 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
55024 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
55025 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
55026 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
55027 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
55028 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
55029 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
55030 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
55031 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
55032 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
55033 { (char *)"MenuBar_UpdateMenus", (PyCFunction)_wrap_MenuBar_UpdateMenus, METH_O, NULL},
55034 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55035 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
55036 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
55037 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
55038 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
55039 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
55040 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
55041 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55042 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
55043 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
55044 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
55045 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
55046 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
55047 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
55048 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
55049 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
55050 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
55051 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
55052 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
55053 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
55054 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55055 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
55056 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
55057 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
55058 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
55059 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
55060 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
55061 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
55062 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
55063 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
55064 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
55065 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
55066 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
55067 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
55068 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
55069 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
55070 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
55071 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
55072 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
55073 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
55074 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
55075 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
55076 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
55077 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
55078 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
55079 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
55080 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
55081 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
55082 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
55083 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
55084 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
55085 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
55086 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
55087 { (char *)"Control_GetAlignment", (PyCFunction)_wrap_Control_GetAlignment, METH_O, NULL},
55088 { (char *)"Control_GetLabelText", (PyCFunction)_wrap_Control_GetLabelText, METH_O, NULL},
55089 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
55090 { (char *)"Control_GetLabel", (PyCFunction)_wrap_Control_GetLabel, METH_O, NULL},
55091 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
55092 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
55093 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
55094 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
55095 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
55096 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
55097 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
55098 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
55099 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
55100 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
55101 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
55102 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
55103 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
55104 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
55105 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
55106 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
55107 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
55108 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
55109 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
55110 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
55111 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
55112 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
55113 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
55114 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
55115 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
55116 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55117 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
55118 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55119 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
55120 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
55121 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
55122 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
55123 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
55124 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
55125 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
55126 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
55127 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
55128 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
55129 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
55130 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
55131 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
55132 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
55133 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
55134 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
55135 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
55136 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
55137 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
55138 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
55139 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
55140 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
55141 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
55142 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55143 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
55144 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55145 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
55146 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
55147 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
55148 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
55149 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
55150 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
55151 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
55152 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
55153 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
55154 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
55155 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
55156 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
55157 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
55158 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
55159 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
55160 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
55161 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
55162 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
55163 { (char *)"Sizer__ReplaceWin", (PyCFunction) _wrap_Sizer__ReplaceWin, METH_VARARGS | METH_KEYWORDS, NULL},
55164 { (char *)"Sizer__ReplaceSizer", (PyCFunction) _wrap_Sizer__ReplaceSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55165 { (char *)"Sizer__ReplaceItem", (PyCFunction) _wrap_Sizer__ReplaceItem, METH_VARARGS | METH_KEYWORDS, NULL},
55166 { (char *)"Sizer_SetContainingWindow", (PyCFunction) _wrap_Sizer_SetContainingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55167 { (char *)"Sizer_GetContainingWindow", (PyCFunction)_wrap_Sizer_GetContainingWindow, METH_O, NULL},
55168 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
55169 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
55170 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
55171 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
55172 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
55173 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
55174 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
55175 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
55176 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
55177 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
55178 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
55179 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
55180 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
55181 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
55182 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
55183 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
55184 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
55185 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
55186 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
55187 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
55188 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
55189 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
55190 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
55191 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
55192 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
55193 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
55194 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55195 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
55196 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
55197 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
55198 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
55199 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55200 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
55201 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
55202 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
55203 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55204 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
55205 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
55206 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
55207 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
55208 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
55209 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
55210 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
55211 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
55212 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
55213 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
55214 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55215 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
55216 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
55217 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
55218 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
55219 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
55220 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
55221 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
55222 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
55223 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
55224 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
55225 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
55226 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
55227 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
55228 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
55229 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
55230 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
55231 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
55232 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
55233 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
55234 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
55235 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
55236 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
55237 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
55238 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
55239 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
55240 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
55241 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
55242 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
55243 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
55244 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
55245 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
55246 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
55247 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
55248 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
55249 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
55250 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
55251 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
55252 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
55253 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
55254 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
55255 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
55256 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
55257 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
55258 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
55259 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
55260 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
55261 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
55262 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
55263 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
55264 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
55265 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
55266 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55267 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55268 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
55269 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
55270 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
55271 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
55272 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
55273 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
55274 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
55275 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
55276 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
55277 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55278 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
55279 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
55280 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55281 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
55282 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
55283 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
55284 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
55285 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
55286 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
55287 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
55288 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
55289 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
55290 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
55291 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
55292 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
55293 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
55294 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
55295 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
55296 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
55297 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
55298 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
55299 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
55300 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
55301 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
55302 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
55303 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
55304 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
55305 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
55306 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
55307 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
55308 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
55309 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
55310 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
55311 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
55312 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
55313 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
55314 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
55315 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
55316 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
55317 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
55318 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
55319 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
55320 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
55321 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
55322 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
55323 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
55324 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
55325 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
55326 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
55327 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
55328 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
55329 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
55330 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
55331 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
55332 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
55333 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
55334 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
55335 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
55336 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
55337 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
55338 { NULL, NULL, 0, NULL }
55339 };
55340
55341
55342 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
55343
55344 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
55345 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
55346 }
55347 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
55348 return (void *)((wxSizer *) ((wxBoxSizer *) x));
55349 }
55350 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
55351 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
55352 }
55353 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
55354 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
55355 }
55356 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
55357 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
55358 }
55359 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
55360 return (void *)((wxSizer *) ((wxGridSizer *) x));
55361 }
55362 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
55363 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
55364 }
55365 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
55366 return (void *)((wxSizer *) ((wxPySizer *) x));
55367 }
55368 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
55369 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
55370 }
55371 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
55372 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
55373 }
55374 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
55375 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
55376 }
55377 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
55378 return (void *)((wxEvent *) ((wxMenuEvent *) x));
55379 }
55380 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
55381 return (void *)((wxEvent *) ((wxCloseEvent *) x));
55382 }
55383 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
55384 return (void *)((wxEvent *) ((wxMouseEvent *) x));
55385 }
55386 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
55387 return (void *)((wxEvent *) ((wxEraseEvent *) x));
55388 }
55389 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
55390 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
55391 }
55392 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
55393 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
55394 }
55395 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
55396 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
55397 }
55398 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
55399 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
55400 }
55401 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
55402 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
55403 }
55404 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
55405 return (void *)((wxEvent *) ((wxPyEvent *) x));
55406 }
55407 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
55408 return (void *)((wxEvent *) ((wxIdleEvent *) x));
55409 }
55410 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
55411 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
55412 }
55413 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
55414 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
55415 }
55416 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
55417 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
55418 }
55419 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
55420 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
55421 }
55422 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
55423 return (void *)((wxEvent *) ((wxActivateEvent *) x));
55424 }
55425 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
55426 return (void *)((wxEvent *) ((wxSizeEvent *) x));
55427 }
55428 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
55429 return (void *)((wxEvent *) ((wxMoveEvent *) x));
55430 }
55431 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
55432 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
55433 }
55434 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
55435 return (void *)((wxEvent *) ((wxPaintEvent *) x));
55436 }
55437 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
55438 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
55439 }
55440 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
55441 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
55442 }
55443 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
55444 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
55445 }
55446 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
55447 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
55448 }
55449 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
55450 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
55451 }
55452 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
55453 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
55454 }
55455 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
55456 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
55457 }
55458 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
55459 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
55460 }
55461 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
55462 return (void *)((wxEvent *) ((wxFocusEvent *) x));
55463 }
55464 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
55465 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
55466 }
55467 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
55468 return (void *)((wxEvent *) ((wxShowEvent *) x));
55469 }
55470 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
55471 return (void *)((wxEvent *) ((wxCommandEvent *) x));
55472 }
55473 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
55474 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
55475 }
55476 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
55477 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
55478 }
55479 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
55480 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
55481 }
55482 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
55483 return (void *)((wxEvent *) ((wxKeyEvent *) x));
55484 }
55485 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
55486 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
55487 }
55488 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
55489 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
55490 }
55491 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
55492 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
55493 }
55494 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
55495 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
55496 }
55497 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
55498 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
55499 }
55500 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
55501 return (void *)((wxControl *) ((wxControlWithItems *) x));
55502 }
55503 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
55504 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
55505 }
55506 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
55507 return (void *)((wxEvtHandler *) ((wxWindow *) x));
55508 }
55509 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
55510 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
55511 }
55512 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
55513 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
55514 }
55515 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
55516 return (void *)((wxEvtHandler *) ((wxValidator *) x));
55517 }
55518 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
55519 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
55520 }
55521 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
55522 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
55523 }
55524 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
55525 return (void *)((wxEvtHandler *) ((wxMenu *) x));
55526 }
55527 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
55528 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
55529 }
55530 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
55531 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
55532 }
55533 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
55534 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
55535 }
55536 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
55537 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
55538 }
55539 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
55540 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
55541 }
55542 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
55543 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
55544 }
55545 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
55546 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
55547 }
55548 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
55549 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
55550 }
55551 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
55552 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
55553 }
55554 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
55555 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
55556 }
55557 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
55558 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
55559 }
55560 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
55561 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
55562 }
55563 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
55564 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
55565 }
55566 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
55567 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
55568 }
55569 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
55570 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
55571 }
55572 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
55573 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
55574 }
55575 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
55576 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
55577 }
55578 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
55579 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
55580 }
55581 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
55582 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
55583 }
55584 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
55585 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
55586 }
55587 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
55588 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
55589 }
55590 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
55591 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
55592 }
55593 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
55594 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
55595 }
55596 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
55597 return (void *)((wxObject *) ((wxSizerItem *) x));
55598 }
55599 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
55600 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
55601 }
55602 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
55603 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
55604 }
55605 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
55606 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
55607 }
55608 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
55609 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
55610 }
55611 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
55612 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
55613 }
55614 static void *_p_wxSizerTo_p_wxObject(void *x) {
55615 return (void *)((wxObject *) ((wxSizer *) x));
55616 }
55617 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
55618 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
55619 }
55620 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
55621 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
55622 }
55623 static void *_p_wxEventTo_p_wxObject(void *x) {
55624 return (void *)((wxObject *) ((wxEvent *) x));
55625 }
55626 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
55627 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
55628 }
55629 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
55630 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
55631 }
55632 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
55633 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
55634 }
55635 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
55636 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
55637 }
55638 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
55639 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
55640 }
55641 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
55642 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
55643 }
55644 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
55645 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
55646 }
55647 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
55648 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
55649 }
55650 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
55651 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
55652 }
55653 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
55654 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
55655 }
55656 static void *_p_wxControlTo_p_wxObject(void *x) {
55657 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
55658 }
55659 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
55660 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
55661 }
55662 static void *_p_wxFSFileTo_p_wxObject(void *x) {
55663 return (void *)((wxObject *) ((wxFSFile *) x));
55664 }
55665 static void *_p_wxPySizerTo_p_wxObject(void *x) {
55666 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
55667 }
55668 static void *_p_wxPyEventTo_p_wxObject(void *x) {
55669 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
55670 }
55671 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
55672 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
55673 }
55674 static void *_p_wxShowEventTo_p_wxObject(void *x) {
55675 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
55676 }
55677 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
55678 return (void *)((wxObject *) ((wxMenuItem *) x));
55679 }
55680 static void *_p_wxDateEventTo_p_wxObject(void *x) {
55681 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
55682 }
55683 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
55684 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
55685 }
55686 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
55687 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
55688 }
55689 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
55690 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
55691 }
55692 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
55693 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
55694 }
55695 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
55696 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
55697 }
55698 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
55699 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
55700 }
55701 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
55702 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
55703 }
55704 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
55705 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
55706 }
55707 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
55708 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
55709 }
55710 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
55711 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
55712 }
55713 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
55714 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
55715 }
55716 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
55717 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
55718 }
55719 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
55720 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
55721 }
55722 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
55723 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
55724 }
55725 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
55726 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
55727 }
55728 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
55729 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
55730 }
55731 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
55732 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
55733 }
55734 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
55735 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
55736 }
55737 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
55738 return (void *)((wxObject *) ((wxImageHandler *) x));
55739 }
55740 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
55741 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
55742 }
55743 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
55744 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
55745 }
55746 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
55747 return (void *)((wxObject *) ((wxEvtHandler *) x));
55748 }
55749 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
55750 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
55751 }
55752 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
55753 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
55754 }
55755 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
55756 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
55757 }
55758 static void *_p_wxImageTo_p_wxObject(void *x) {
55759 return (void *)((wxObject *) ((wxImage *) x));
55760 }
55761 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
55762 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
55763 }
55764 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
55765 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
55766 }
55767 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
55768 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
55769 }
55770 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
55771 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
55772 }
55773 static void *_p_wxWindowTo_p_wxObject(void *x) {
55774 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
55775 }
55776 static void *_p_wxMenuTo_p_wxObject(void *x) {
55777 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
55778 }
55779 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
55780 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
55781 }
55782 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
55783 return (void *)((wxObject *) ((wxFileSystem *) x));
55784 }
55785 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
55786 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
55787 }
55788 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
55789 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
55790 }
55791 static void *_p_wxPyAppTo_p_wxObject(void *x) {
55792 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
55793 }
55794 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
55795 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
55796 }
55797 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
55798 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
55799 }
55800 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
55801 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
55802 }
55803 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
55804 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
55805 }
55806 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
55807 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
55808 }
55809 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
55810 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
55811 }
55812 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
55813 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
55814 }
55815 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
55816 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
55817 }
55818 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
55819 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
55820 }
55821 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
55822 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
55823 }
55824 static void *_p_wxValidatorTo_p_wxObject(void *x) {
55825 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
55826 }
55827 static void *_p_wxControlTo_p_wxWindow(void *x) {
55828 return (void *)((wxWindow *) ((wxControl *) x));
55829 }
55830 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
55831 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
55832 }
55833 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
55834 return (void *)((wxWindow *) ((wxMenuBar *) x));
55835 }
55836 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
55837 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
55838 }
55839 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
55840 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
55841 }
55842 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
55843 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
55844 }
55845 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
55846 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
55847 }
55848 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
55849 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
55850 }
55851 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
55852 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
55853 }
55854 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
55855 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
55856 }
55857 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
55858 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
55859 }
55860 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
55861 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
55862 }
55863 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
55864 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
55865 }
55866 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
55867 return (void *)((wxValidator *) ((wxPyValidator *) x));
55868 }
55869 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
55870 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
55871 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};
55872 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
55873 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
55874 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
55875 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
55876 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
55877 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
55878 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
55879 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
55880 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
55881 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
55882 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
55883 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
55884 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
55885 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
55886 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
55887 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
55888 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
55889 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
55890 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
55891 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
55892 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
55893 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
55894 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
55895 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
55896 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
55897 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
55898 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
55899 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
55900 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
55901 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
55902 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
55903 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
55904 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
55905 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
55906 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
55907 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
55908 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
55909 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
55910 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
55911 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
55912 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
55913 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
55914 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
55915 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
55916 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
55917 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
55918 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
55919 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
55920 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
55921 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
55922 static swig_type_info _swigt__p_wxHelpEvent__Origin = {"_p_wxHelpEvent__Origin", "wxHelpEvent::Origin *", 0, 0, (void*)0, 0};
55923 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
55924 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
55925 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
55926 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
55927 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
55928 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
55929 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
55930 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
55931 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
55932 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
55933 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
55934 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
55935 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
55936 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
55937 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
55938 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
55939 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
55940 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
55941 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
55942 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
55943 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
55944 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
55945 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
55946 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
55947 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", "wxMouseCaptureLostEvent *", 0, 0, (void*)0, 0};
55948 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
55949 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
55950 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
55951 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
55952 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
55953 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
55954 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
55955 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
55956 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
55957 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
55958 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
55959 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
55960 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
55961 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
55962 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
55963 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
55964 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
55965 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
55966 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
55967 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
55968 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
55969 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
55970 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
55971 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
55972 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
55973 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
55974 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
55975 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
55976 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
55977 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
55978 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
55979 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
55980 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
55981 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
55982 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
55983 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
55984 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
55985 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
55986 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
55987 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
55988 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
55989 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
55990 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
55991 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
55992 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
55993 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
55994 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
55995 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
55996 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
55997 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
55998 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
55999 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
56000 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
56001
56002 static swig_type_info *swig_type_initial[] = {
56003 &_swigt__p_buffer,
56004 &_swigt__p_char,
56005 &_swigt__p_form_ops_t,
56006 &_swigt__p_int,
56007 &_swigt__p_long,
56008 &_swigt__p_unsigned_char,
56009 &_swigt__p_unsigned_int,
56010 &_swigt__p_unsigned_long,
56011 &_swigt__p_wxANIHandler,
56012 &_swigt__p_wxAcceleratorEntry,
56013 &_swigt__p_wxAcceleratorTable,
56014 &_swigt__p_wxActivateEvent,
56015 &_swigt__p_wxAppTraits,
56016 &_swigt__p_wxArrayString,
56017 &_swigt__p_wxBMPHandler,
56018 &_swigt__p_wxBitmap,
56019 &_swigt__p_wxBoxSizer,
56020 &_swigt__p_wxButton,
56021 &_swigt__p_wxCURHandler,
56022 &_swigt__p_wxCaret,
56023 &_swigt__p_wxChildFocusEvent,
56024 &_swigt__p_wxClipboardTextEvent,
56025 &_swigt__p_wxCloseEvent,
56026 &_swigt__p_wxColour,
56027 &_swigt__p_wxCommandEvent,
56028 &_swigt__p_wxContextMenuEvent,
56029 &_swigt__p_wxControl,
56030 &_swigt__p_wxControlWithItems,
56031 &_swigt__p_wxCursor,
56032 &_swigt__p_wxDC,
56033 &_swigt__p_wxDateEvent,
56034 &_swigt__p_wxDateTime,
56035 &_swigt__p_wxDisplayChangedEvent,
56036 &_swigt__p_wxDropFilesEvent,
56037 &_swigt__p_wxDuplexMode,
56038 &_swigt__p_wxEraseEvent,
56039 &_swigt__p_wxEvent,
56040 &_swigt__p_wxEventLoop,
56041 &_swigt__p_wxEventLoopActivator,
56042 &_swigt__p_wxEvtHandler,
56043 &_swigt__p_wxFSFile,
56044 &_swigt__p_wxFileSystem,
56045 &_swigt__p_wxFileSystemHandler,
56046 &_swigt__p_wxFlexGridSizer,
56047 &_swigt__p_wxFocusEvent,
56048 &_swigt__p_wxFont,
56049 &_swigt__p_wxFrame,
56050 &_swigt__p_wxGBPosition,
56051 &_swigt__p_wxGBSizerItem,
56052 &_swigt__p_wxGBSpan,
56053 &_swigt__p_wxGIFHandler,
56054 &_swigt__p_wxGridBagSizer,
56055 &_swigt__p_wxGridSizer,
56056 &_swigt__p_wxHelpEvent__Origin,
56057 &_swigt__p_wxICOHandler,
56058 &_swigt__p_wxIconizeEvent,
56059 &_swigt__p_wxIdleEvent,
56060 &_swigt__p_wxImage,
56061 &_swigt__p_wxImageHandler,
56062 &_swigt__p_wxImageHistogram,
56063 &_swigt__p_wxImage_HSVValue,
56064 &_swigt__p_wxImage_RGBValue,
56065 &_swigt__p_wxIndividualLayoutConstraint,
56066 &_swigt__p_wxInitDialogEvent,
56067 &_swigt__p_wxInputStream,
56068 &_swigt__p_wxInternetFSHandler,
56069 &_swigt__p_wxItemContainer,
56070 &_swigt__p_wxJPEGHandler,
56071 &_swigt__p_wxKeyEvent,
56072 &_swigt__p_wxLayoutConstraints,
56073 &_swigt__p_wxMaximizeEvent,
56074 &_swigt__p_wxMemoryFSHandler,
56075 &_swigt__p_wxMenu,
56076 &_swigt__p_wxMenuBar,
56077 &_swigt__p_wxMenuBarBase,
56078 &_swigt__p_wxMenuEvent,
56079 &_swigt__p_wxMenuItem,
56080 &_swigt__p_wxMouseCaptureChangedEvent,
56081 &_swigt__p_wxMouseCaptureLostEvent,
56082 &_swigt__p_wxMouseEvent,
56083 &_swigt__p_wxMoveEvent,
56084 &_swigt__p_wxNavigationKeyEvent,
56085 &_swigt__p_wxNcPaintEvent,
56086 &_swigt__p_wxNotifyEvent,
56087 &_swigt__p_wxObject,
56088 &_swigt__p_wxOutputStream,
56089 &_swigt__p_wxPCXHandler,
56090 &_swigt__p_wxPNGHandler,
56091 &_swigt__p_wxPNMHandler,
56092 &_swigt__p_wxPaintEvent,
56093 &_swigt__p_wxPaletteChangedEvent,
56094 &_swigt__p_wxPaperSize,
56095 &_swigt__p_wxPoint,
56096 &_swigt__p_wxPoint2D,
56097 &_swigt__p_wxPropagateOnce,
56098 &_swigt__p_wxPropagationDisabler,
56099 &_swigt__p_wxPyApp,
56100 &_swigt__p_wxPyCommandEvent,
56101 &_swigt__p_wxPyDropTarget,
56102 &_swigt__p_wxPyEvent,
56103 &_swigt__p_wxPyFileSystemHandler,
56104 &_swigt__p_wxPyImageHandler,
56105 &_swigt__p_wxPyInputStream,
56106 &_swigt__p_wxPySizer,
56107 &_swigt__p_wxPyValidator,
56108 &_swigt__p_wxQuantize,
56109 &_swigt__p_wxQueryNewPaletteEvent,
56110 &_swigt__p_wxRealPoint,
56111 &_swigt__p_wxRect,
56112 &_swigt__p_wxRegion,
56113 &_swigt__p_wxScrollEvent,
56114 &_swigt__p_wxScrollWinEvent,
56115 &_swigt__p_wxSetCursorEvent,
56116 &_swigt__p_wxShowEvent,
56117 &_swigt__p_wxSize,
56118 &_swigt__p_wxSizeEvent,
56119 &_swigt__p_wxSizer,
56120 &_swigt__p_wxSizerItem,
56121 &_swigt__p_wxStaticBox,
56122 &_swigt__p_wxStaticBoxSizer,
56123 &_swigt__p_wxStdDialogButtonSizer,
56124 &_swigt__p_wxSysColourChangedEvent,
56125 &_swigt__p_wxTIFFHandler,
56126 &_swigt__p_wxToolTip,
56127 &_swigt__p_wxUpdateUIEvent,
56128 &_swigt__p_wxValidator,
56129 &_swigt__p_wxVisualAttributes,
56130 &_swigt__p_wxWindow,
56131 &_swigt__p_wxWindowCreateEvent,
56132 &_swigt__p_wxWindowDestroyEvent,
56133 &_swigt__p_wxXPMHandler,
56134 &_swigt__p_wxZipFSHandler,
56135 };
56136
56137 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
56138 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
56139 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
56140 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
56141 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
56142 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
56143 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
56144 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
56145 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
56146 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
56147 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
56148 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
56149 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
56150 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
56151 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}};
56152 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
56153 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}};
56154 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
56155 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}};
56156 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
56157 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
56158 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
56159 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
56160 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
56161 static swig_cast_info _swigc__p_wxCommandEvent[] = { {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxCommandEvent, 0, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxCommandEvent, 0, 0},{0, 0, 0, 0}};
56162 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
56163 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}};
56164 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
56165 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
56166 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
56167 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
56168 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
56169 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
56170 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
56171 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
56172 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
56173 static swig_cast_info _swigc__p_wxEvent[] = { {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEvent, 0, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxEvent, 0, 0},{0, 0, 0, 0}};
56174 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
56175 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
56176 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}};
56177 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
56178 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
56179 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}};
56180 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}};
56181 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
56182 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
56183 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
56184 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
56185 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
56186 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
56187 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
56188 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
56189 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}};
56190 static swig_cast_info _swigc__p_wxHelpEvent__Origin[] = { {&_swigt__p_wxHelpEvent__Origin, 0, 0, 0},{0, 0, 0, 0}};
56191 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}};
56192 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
56193 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
56194 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
56195 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}};
56196 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
56197 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
56198 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
56199 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
56200 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
56201 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
56202 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
56203 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}};
56204 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
56205 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
56206 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
56207 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
56208 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
56209 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
56210 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
56211 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
56212 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
56213 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
56214 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
56215 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = { {&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
56216 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
56217 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
56218 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
56219 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
56220 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
56221 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxAcceleratorTable, _p_wxAcceleratorTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxImage, _p_wxImageTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxObject, 0, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileSystem, _p_wxFileSystemTo_p_wxObject, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxObject, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxObject, 0, 0},{0, 0, 0, 0}};
56222 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
56223 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
56224 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
56225 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
56226 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
56227 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
56228 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
56229 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
56230 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
56231 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
56232 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
56233 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
56234 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
56235 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
56236 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
56237 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
56238 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
56239 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
56240 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
56241 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
56242 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
56243 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
56244 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
56245 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
56246 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
56247 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
56248 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
56249 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
56250 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
56251 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
56252 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
56253 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}};
56254 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}};
56255 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
56256 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
56257 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
56258 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
56259 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
56260 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
56261 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
56262 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}};
56263 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
56264 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}};
56265 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
56266 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
56267 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
56268 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
56269
56270 static swig_cast_info *swig_cast_initial[] = {
56271 _swigc__p_buffer,
56272 _swigc__p_char,
56273 _swigc__p_form_ops_t,
56274 _swigc__p_int,
56275 _swigc__p_long,
56276 _swigc__p_unsigned_char,
56277 _swigc__p_unsigned_int,
56278 _swigc__p_unsigned_long,
56279 _swigc__p_wxANIHandler,
56280 _swigc__p_wxAcceleratorEntry,
56281 _swigc__p_wxAcceleratorTable,
56282 _swigc__p_wxActivateEvent,
56283 _swigc__p_wxAppTraits,
56284 _swigc__p_wxArrayString,
56285 _swigc__p_wxBMPHandler,
56286 _swigc__p_wxBitmap,
56287 _swigc__p_wxBoxSizer,
56288 _swigc__p_wxButton,
56289 _swigc__p_wxCURHandler,
56290 _swigc__p_wxCaret,
56291 _swigc__p_wxChildFocusEvent,
56292 _swigc__p_wxClipboardTextEvent,
56293 _swigc__p_wxCloseEvent,
56294 _swigc__p_wxColour,
56295 _swigc__p_wxCommandEvent,
56296 _swigc__p_wxContextMenuEvent,
56297 _swigc__p_wxControl,
56298 _swigc__p_wxControlWithItems,
56299 _swigc__p_wxCursor,
56300 _swigc__p_wxDC,
56301 _swigc__p_wxDateEvent,
56302 _swigc__p_wxDateTime,
56303 _swigc__p_wxDisplayChangedEvent,
56304 _swigc__p_wxDropFilesEvent,
56305 _swigc__p_wxDuplexMode,
56306 _swigc__p_wxEraseEvent,
56307 _swigc__p_wxEvent,
56308 _swigc__p_wxEventLoop,
56309 _swigc__p_wxEventLoopActivator,
56310 _swigc__p_wxEvtHandler,
56311 _swigc__p_wxFSFile,
56312 _swigc__p_wxFileSystem,
56313 _swigc__p_wxFileSystemHandler,
56314 _swigc__p_wxFlexGridSizer,
56315 _swigc__p_wxFocusEvent,
56316 _swigc__p_wxFont,
56317 _swigc__p_wxFrame,
56318 _swigc__p_wxGBPosition,
56319 _swigc__p_wxGBSizerItem,
56320 _swigc__p_wxGBSpan,
56321 _swigc__p_wxGIFHandler,
56322 _swigc__p_wxGridBagSizer,
56323 _swigc__p_wxGridSizer,
56324 _swigc__p_wxHelpEvent__Origin,
56325 _swigc__p_wxICOHandler,
56326 _swigc__p_wxIconizeEvent,
56327 _swigc__p_wxIdleEvent,
56328 _swigc__p_wxImage,
56329 _swigc__p_wxImageHandler,
56330 _swigc__p_wxImageHistogram,
56331 _swigc__p_wxImage_HSVValue,
56332 _swigc__p_wxImage_RGBValue,
56333 _swigc__p_wxIndividualLayoutConstraint,
56334 _swigc__p_wxInitDialogEvent,
56335 _swigc__p_wxInputStream,
56336 _swigc__p_wxInternetFSHandler,
56337 _swigc__p_wxItemContainer,
56338 _swigc__p_wxJPEGHandler,
56339 _swigc__p_wxKeyEvent,
56340 _swigc__p_wxLayoutConstraints,
56341 _swigc__p_wxMaximizeEvent,
56342 _swigc__p_wxMemoryFSHandler,
56343 _swigc__p_wxMenu,
56344 _swigc__p_wxMenuBar,
56345 _swigc__p_wxMenuBarBase,
56346 _swigc__p_wxMenuEvent,
56347 _swigc__p_wxMenuItem,
56348 _swigc__p_wxMouseCaptureChangedEvent,
56349 _swigc__p_wxMouseCaptureLostEvent,
56350 _swigc__p_wxMouseEvent,
56351 _swigc__p_wxMoveEvent,
56352 _swigc__p_wxNavigationKeyEvent,
56353 _swigc__p_wxNcPaintEvent,
56354 _swigc__p_wxNotifyEvent,
56355 _swigc__p_wxObject,
56356 _swigc__p_wxOutputStream,
56357 _swigc__p_wxPCXHandler,
56358 _swigc__p_wxPNGHandler,
56359 _swigc__p_wxPNMHandler,
56360 _swigc__p_wxPaintEvent,
56361 _swigc__p_wxPaletteChangedEvent,
56362 _swigc__p_wxPaperSize,
56363 _swigc__p_wxPoint,
56364 _swigc__p_wxPoint2D,
56365 _swigc__p_wxPropagateOnce,
56366 _swigc__p_wxPropagationDisabler,
56367 _swigc__p_wxPyApp,
56368 _swigc__p_wxPyCommandEvent,
56369 _swigc__p_wxPyDropTarget,
56370 _swigc__p_wxPyEvent,
56371 _swigc__p_wxPyFileSystemHandler,
56372 _swigc__p_wxPyImageHandler,
56373 _swigc__p_wxPyInputStream,
56374 _swigc__p_wxPySizer,
56375 _swigc__p_wxPyValidator,
56376 _swigc__p_wxQuantize,
56377 _swigc__p_wxQueryNewPaletteEvent,
56378 _swigc__p_wxRealPoint,
56379 _swigc__p_wxRect,
56380 _swigc__p_wxRegion,
56381 _swigc__p_wxScrollEvent,
56382 _swigc__p_wxScrollWinEvent,
56383 _swigc__p_wxSetCursorEvent,
56384 _swigc__p_wxShowEvent,
56385 _swigc__p_wxSize,
56386 _swigc__p_wxSizeEvent,
56387 _swigc__p_wxSizer,
56388 _swigc__p_wxSizerItem,
56389 _swigc__p_wxStaticBox,
56390 _swigc__p_wxStaticBoxSizer,
56391 _swigc__p_wxStdDialogButtonSizer,
56392 _swigc__p_wxSysColourChangedEvent,
56393 _swigc__p_wxTIFFHandler,
56394 _swigc__p_wxToolTip,
56395 _swigc__p_wxUpdateUIEvent,
56396 _swigc__p_wxValidator,
56397 _swigc__p_wxVisualAttributes,
56398 _swigc__p_wxWindow,
56399 _swigc__p_wxWindowCreateEvent,
56400 _swigc__p_wxWindowDestroyEvent,
56401 _swigc__p_wxXPMHandler,
56402 _swigc__p_wxZipFSHandler,
56403 };
56404
56405
56406 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
56407
56408 static swig_const_info swig_const_table[] = {
56409 {0, 0, 0, 0.0, 0, 0}};
56410
56411 #ifdef __cplusplus
56412 }
56413 #endif
56414 /* -----------------------------------------------------------------------------
56415 * Type initialization:
56416 * This problem is tough by the requirement that no dynamic
56417 * memory is used. Also, since swig_type_info structures store pointers to
56418 * swig_cast_info structures and swig_cast_info structures store pointers back
56419 * to swig_type_info structures, we need some lookup code at initialization.
56420 * The idea is that swig generates all the structures that are needed.
56421 * The runtime then collects these partially filled structures.
56422 * The SWIG_InitializeModule function takes these initial arrays out of
56423 * swig_module, and does all the lookup, filling in the swig_module.types
56424 * array with the correct data and linking the correct swig_cast_info
56425 * structures together.
56426 *
56427 * The generated swig_type_info structures are assigned staticly to an initial
56428 * array. We just loop though that array, and handle each type individually.
56429 * First we lookup if this type has been already loaded, and if so, use the
56430 * loaded structure instead of the generated one. Then we have to fill in the
56431 * cast linked list. The cast data is initially stored in something like a
56432 * two-dimensional array. Each row corresponds to a type (there are the same
56433 * number of rows as there are in the swig_type_initial array). Each entry in
56434 * a column is one of the swig_cast_info structures for that type.
56435 * The cast_initial array is actually an array of arrays, because each row has
56436 * a variable number of columns. So to actually build the cast linked list,
56437 * we find the array of casts associated with the type, and loop through it
56438 * adding the casts to the list. The one last trick we need to do is making
56439 * sure the type pointer in the swig_cast_info struct is correct.
56440 *
56441 * First off, we lookup the cast->type name to see if it is already loaded.
56442 * There are three cases to handle:
56443 * 1) If the cast->type has already been loaded AND the type we are adding
56444 * casting info to has not been loaded (it is in this module), THEN we
56445 * replace the cast->type pointer with the type pointer that has already
56446 * been loaded.
56447 * 2) If BOTH types (the one we are adding casting info to, and the
56448 * cast->type) are loaded, THEN the cast info has already been loaded by
56449 * the previous module so we just ignore it.
56450 * 3) Finally, if cast->type has not already been loaded, then we add that
56451 * swig_cast_info to the linked list (because the cast->type) pointer will
56452 * be correct.
56453 * ----------------------------------------------------------------------------- */
56454
56455 #ifdef __cplusplus
56456 extern "C" {
56457 #if 0
56458 } /* c-mode */
56459 #endif
56460 #endif
56461
56462 #if 0
56463 #define SWIGRUNTIME_DEBUG
56464 #endif
56465
56466 SWIGRUNTIME void
56467 SWIG_InitializeModule(void *clientdata) {
56468 size_t i;
56469 swig_module_info *module_head;
56470 static int init_run = 0;
56471
56472 clientdata = clientdata;
56473
56474 if (init_run) return;
56475 init_run = 1;
56476
56477 /* Initialize the swig_module */
56478 swig_module.type_initial = swig_type_initial;
56479 swig_module.cast_initial = swig_cast_initial;
56480
56481 /* Try and load any already created modules */
56482 module_head = SWIG_GetModule(clientdata);
56483 if (module_head) {
56484 swig_module.next = module_head->next;
56485 module_head->next = &swig_module;
56486 } else {
56487 /* This is the first module loaded */
56488 swig_module.next = &swig_module;
56489 SWIG_SetModule(clientdata, &swig_module);
56490 }
56491
56492 /* Now work on filling in swig_module.types */
56493 #ifdef SWIGRUNTIME_DEBUG
56494 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
56495 #endif
56496 for (i = 0; i < swig_module.size; ++i) {
56497 swig_type_info *type = 0;
56498 swig_type_info *ret;
56499 swig_cast_info *cast;
56500
56501 #ifdef SWIGRUNTIME_DEBUG
56502 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
56503 #endif
56504
56505 /* if there is another module already loaded */
56506 if (swig_module.next != &swig_module) {
56507 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
56508 }
56509 if (type) {
56510 /* Overwrite clientdata field */
56511 #ifdef SWIGRUNTIME_DEBUG
56512 printf("SWIG_InitializeModule: found type %s\n", type->name);
56513 #endif
56514 if (swig_module.type_initial[i]->clientdata) {
56515 type->clientdata = swig_module.type_initial[i]->clientdata;
56516 #ifdef SWIGRUNTIME_DEBUG
56517 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
56518 #endif
56519 }
56520 } else {
56521 type = swig_module.type_initial[i];
56522 }
56523
56524 /* Insert casting types */
56525 cast = swig_module.cast_initial[i];
56526 while (cast->type) {
56527 /* Don't need to add information already in the list */
56528 ret = 0;
56529 #ifdef SWIGRUNTIME_DEBUG
56530 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
56531 #endif
56532 if (swig_module.next != &swig_module) {
56533 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
56534 #ifdef SWIGRUNTIME_DEBUG
56535 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
56536 #endif
56537 }
56538 if (ret) {
56539 if (type == swig_module.type_initial[i]) {
56540 #ifdef SWIGRUNTIME_DEBUG
56541 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
56542 #endif
56543 cast->type = ret;
56544 ret = 0;
56545 } else {
56546 /* Check for casting already in the list */
56547 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
56548 #ifdef SWIGRUNTIME_DEBUG
56549 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
56550 #endif
56551 if (!ocast) ret = 0;
56552 }
56553 }
56554
56555 if (!ret) {
56556 #ifdef SWIGRUNTIME_DEBUG
56557 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
56558 #endif
56559 if (type->cast) {
56560 type->cast->prev = cast;
56561 cast->next = type->cast;
56562 }
56563 type->cast = cast;
56564 }
56565 cast++;
56566 }
56567 /* Set entry in modules->types array equal to the type */
56568 swig_module.types[i] = type;
56569 }
56570 swig_module.types[i] = 0;
56571
56572 #ifdef SWIGRUNTIME_DEBUG
56573 printf("**** SWIG_InitializeModule: Cast List ******\n");
56574 for (i = 0; i < swig_module.size; ++i) {
56575 int j = 0;
56576 swig_cast_info *cast = swig_module.cast_initial[i];
56577 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
56578 while (cast->type) {
56579 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
56580 cast++;
56581 ++j;
56582 }
56583 printf("---- Total casts: %d\n",j);
56584 }
56585 printf("**** SWIG_InitializeModule: Cast List ******\n");
56586 #endif
56587 }
56588
56589 /* This function will propagate the clientdata field of type to
56590 * any new swig_type_info structures that have been added into the list
56591 * of equivalent types. It is like calling
56592 * SWIG_TypeClientData(type, clientdata) a second time.
56593 */
56594 SWIGRUNTIME void
56595 SWIG_PropagateClientData(void) {
56596 size_t i;
56597 swig_cast_info *equiv;
56598 static int init_run = 0;
56599
56600 if (init_run) return;
56601 init_run = 1;
56602
56603 for (i = 0; i < swig_module.size; i++) {
56604 if (swig_module.types[i]->clientdata) {
56605 equiv = swig_module.types[i]->cast;
56606 while (equiv) {
56607 if (!equiv->converter) {
56608 if (equiv->type && !equiv->type->clientdata)
56609 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
56610 }
56611 equiv = equiv->next;
56612 }
56613 }
56614 }
56615 }
56616
56617 #ifdef __cplusplus
56618 #if 0
56619 {
56620 /* c-mode */
56621 #endif
56622 }
56623 #endif
56624
56625
56626
56627 #ifdef __cplusplus
56628 extern "C" {
56629 #endif
56630
56631 /* Python-specific SWIG API */
56632 #define SWIG_newvarlink() SWIG_Python_newvarlink()
56633 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
56634 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
56635
56636 /* -----------------------------------------------------------------------------
56637 * global variable support code.
56638 * ----------------------------------------------------------------------------- */
56639
56640 typedef struct swig_globalvar {
56641 char *name; /* Name of global variable */
56642 PyObject *(*get_attr)(void); /* Return the current value */
56643 int (*set_attr)(PyObject *); /* Set the value */
56644 struct swig_globalvar *next;
56645 } swig_globalvar;
56646
56647 typedef struct swig_varlinkobject {
56648 PyObject_HEAD
56649 swig_globalvar *vars;
56650 } swig_varlinkobject;
56651
56652 SWIGINTERN PyObject *
56653 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
56654 return PyString_FromString("<Swig global variables>");
56655 }
56656
56657 SWIGINTERN PyObject *
56658 swig_varlink_str(swig_varlinkobject *v) {
56659 PyObject *str = PyString_FromString("(");
56660 swig_globalvar *var;
56661 for (var = v->vars; var; var=var->next) {
56662 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
56663 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
56664 }
56665 PyString_ConcatAndDel(&str,PyString_FromString(")"));
56666 return str;
56667 }
56668
56669 SWIGINTERN int
56670 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
56671 PyObject *str = swig_varlink_str(v);
56672 fprintf(fp,"Swig global variables ");
56673 fprintf(fp,"%s\n", PyString_AsString(str));
56674 Py_DECREF(str);
56675 return 0;
56676 }
56677
56678 SWIGINTERN void
56679 swig_varlink_dealloc(swig_varlinkobject *v) {
56680 swig_globalvar *var = v->vars;
56681 while (var) {
56682 swig_globalvar *n = var->next;
56683 free(var->name);
56684 free(var);
56685 var = n;
56686 }
56687 }
56688
56689 SWIGINTERN PyObject *
56690 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
56691 PyObject *res = NULL;
56692 swig_globalvar *var = v->vars;
56693 while (var) {
56694 if (strcmp(var->name,n) == 0) {
56695 res = (*var->get_attr)();
56696 break;
56697 }
56698 var = var->next;
56699 }
56700 if (res == NULL && !PyErr_Occurred()) {
56701 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
56702 }
56703 return res;
56704 }
56705
56706 SWIGINTERN int
56707 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
56708 int res = 1;
56709 swig_globalvar *var = v->vars;
56710 while (var) {
56711 if (strcmp(var->name,n) == 0) {
56712 res = (*var->set_attr)(p);
56713 break;
56714 }
56715 var = var->next;
56716 }
56717 if (res == 1 && !PyErr_Occurred()) {
56718 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
56719 }
56720 return res;
56721 }
56722
56723 SWIGINTERN PyTypeObject*
56724 swig_varlink_type(void) {
56725 static char varlink__doc__[] = "Swig var link object";
56726 static PyTypeObject varlink_type;
56727 static int type_init = 0;
56728 if (!type_init) {
56729 const PyTypeObject tmp
56730 = {
56731 PyObject_HEAD_INIT(NULL)
56732 0, /* Number of items in variable part (ob_size) */
56733 (char *)"swigvarlink", /* Type name (tp_name) */
56734 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
56735 0, /* Itemsize (tp_itemsize) */
56736 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
56737 (printfunc) swig_varlink_print, /* Print (tp_print) */
56738 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
56739 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
56740 0, /* tp_compare */
56741 (reprfunc) swig_varlink_repr, /* tp_repr */
56742 0, /* tp_as_number */
56743 0, /* tp_as_sequence */
56744 0, /* tp_as_mapping */
56745 0, /* tp_hash */
56746 0, /* tp_call */
56747 (reprfunc)swig_varlink_str, /* tp_str */
56748 0, /* tp_getattro */
56749 0, /* tp_setattro */
56750 0, /* tp_as_buffer */
56751 0, /* tp_flags */
56752 varlink__doc__, /* tp_doc */
56753 0, /* tp_traverse */
56754 0, /* tp_clear */
56755 0, /* tp_richcompare */
56756 0, /* tp_weaklistoffset */
56757 #if PY_VERSION_HEX >= 0x02020000
56758 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
56759 #endif
56760 #if PY_VERSION_HEX >= 0x02030000
56761 0, /* tp_del */
56762 #endif
56763 #ifdef COUNT_ALLOCS
56764 0,0,0,0 /* tp_alloc -> tp_next */
56765 #endif
56766 };
56767 varlink_type = tmp;
56768 varlink_type.ob_type = &PyType_Type;
56769 type_init = 1;
56770 }
56771 return &varlink_type;
56772 }
56773
56774 /* Create a variable linking object for use later */
56775 SWIGINTERN PyObject *
56776 SWIG_Python_newvarlink(void) {
56777 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
56778 if (result) {
56779 result->vars = 0;
56780 }
56781 return ((PyObject*) result);
56782 }
56783
56784 SWIGINTERN void
56785 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
56786 swig_varlinkobject *v = (swig_varlinkobject *) p;
56787 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
56788 if (gv) {
56789 size_t size = strlen(name)+1;
56790 gv->name = (char *)malloc(size);
56791 if (gv->name) {
56792 strncpy(gv->name,name,size);
56793 gv->get_attr = get_attr;
56794 gv->set_attr = set_attr;
56795 gv->next = v->vars;
56796 }
56797 }
56798 v->vars = gv;
56799 }
56800
56801 SWIGINTERN PyObject *
56802 SWIG_globals() {
56803 static PyObject *_SWIG_globals = 0;
56804 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
56805 return _SWIG_globals;
56806 }
56807
56808 /* -----------------------------------------------------------------------------
56809 * constants/methods manipulation
56810 * ----------------------------------------------------------------------------- */
56811
56812 /* Install Constants */
56813 SWIGINTERN void
56814 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
56815 PyObject *obj = 0;
56816 size_t i;
56817 for (i = 0; constants[i].type; ++i) {
56818 switch(constants[i].type) {
56819 case SWIG_PY_POINTER:
56820 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
56821 break;
56822 case SWIG_PY_BINARY:
56823 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
56824 break;
56825 default:
56826 obj = 0;
56827 break;
56828 }
56829 if (obj) {
56830 PyDict_SetItemString(d, constants[i].name, obj);
56831 Py_DECREF(obj);
56832 }
56833 }
56834 }
56835
56836 /* -----------------------------------------------------------------------------*/
56837 /* Fix SwigMethods to carry the callback ptrs when needed */
56838 /* -----------------------------------------------------------------------------*/
56839
56840 SWIGINTERN void
56841 SWIG_Python_FixMethods(PyMethodDef *methods,
56842 swig_const_info *const_table,
56843 swig_type_info **types,
56844 swig_type_info **types_initial) {
56845 size_t i;
56846 for (i = 0; methods[i].ml_name; ++i) {
56847 const char *c = methods[i].ml_doc;
56848 if (c && (c = strstr(c, "swig_ptr: "))) {
56849 int j;
56850 swig_const_info *ci = 0;
56851 const char *name = c + 10;
56852 for (j = 0; const_table[j].type; ++j) {
56853 if (strncmp(const_table[j].name, name,
56854 strlen(const_table[j].name)) == 0) {
56855 ci = &(const_table[j]);
56856 break;
56857 }
56858 }
56859 if (ci) {
56860 size_t shift = (ci->ptype) - types;
56861 swig_type_info *ty = types_initial[shift];
56862 size_t ldoc = (c - methods[i].ml_doc);
56863 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
56864 char *ndoc = (char*)malloc(ldoc + lptr + 10);
56865 if (ndoc) {
56866 char *buff = ndoc;
56867 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
56868 if (ptr) {
56869 strncpy(buff, methods[i].ml_doc, ldoc);
56870 buff += ldoc;
56871 strncpy(buff, "swig_ptr: ", 10);
56872 buff += 10;
56873 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
56874 methods[i].ml_doc = ndoc;
56875 }
56876 }
56877 }
56878 }
56879 }
56880 }
56881
56882 #ifdef __cplusplus
56883 }
56884 #endif
56885
56886 /* -----------------------------------------------------------------------------*
56887 * Partial Init method
56888 * -----------------------------------------------------------------------------*/
56889
56890 #ifdef __cplusplus
56891 extern "C"
56892 #endif
56893 SWIGEXPORT void SWIG_init(void) {
56894 PyObject *m, *d;
56895
56896 /* Fix SwigMethods to carry the callback ptrs when needed */
56897 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
56898
56899 m = Py_InitModule((char *) SWIG_name, SwigMethods);
56900 d = PyModule_GetDict(m);
56901
56902 SWIG_InitializeModule(0);
56903 SWIG_InstallConstants(d,swig_const_table);
56904
56905
56906
56907 #ifndef wxPyUSE_EXPORT
56908 // Make our API structure a CObject so other modules can import it
56909 // from this module.
56910 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
56911 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
56912 Py_XDECREF(cobj);
56913 #endif
56914
56915 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
56916 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
56917 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
56918 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
56919 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
56920 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
56921 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
56922 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
56923 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
56924 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
56925 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
56926 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
56927 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
56928 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
56929 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
56930 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
56931 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
56932 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
56933 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
56934 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
56935 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
56936 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
56937 SWIG_Python_SetConstant(d, "WINDOW_STYLE_MASK",SWIG_From_int(static_cast< int >(wxWINDOW_STYLE_MASK)));
56938 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
56939 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
56940 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
56941 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
56942 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
56943 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
56944 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
56945 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
56946 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
56947 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
56948 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
56949 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
56950 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
56951 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
56952 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
56953 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
56954 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
56955 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
56956 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
56957 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
56958 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
56959 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
56960 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
56961 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
56962 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
56963 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
56964 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
56965 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
56966 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
56967 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
56968 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
56969 SWIG_Python_SetConstant(d, "ST_DOTS_MIDDLE",SWIG_From_int(static_cast< int >(wxST_DOTS_MIDDLE)));
56970 SWIG_Python_SetConstant(d, "ST_DOTS_END",SWIG_From_int(static_cast< int >(wxST_DOTS_END)));
56971 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
56972 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
56973 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
56974 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
56975 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
56976 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
56977 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
56978 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
56979 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
56980 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
56981 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
56982 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
56983 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
56984 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
56985 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
56986 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
56987 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
56988 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
56989 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
56990 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
56991 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
56992 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
56993 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
56994 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
56995 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
56996 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
56997 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
56998 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
56999 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
57000 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
57001 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
57002 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
57003 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
57004 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
57005 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
57006 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
57007 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
57008 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
57009 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
57010 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
57011 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
57012 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
57013 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
57014 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
57015 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
57016 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
57017 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
57018 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
57019 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
57020 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
57021 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
57022 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
57023 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
57024 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
57025 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
57026 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
57027 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
57028 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
57029 SWIG_Python_SetConstant(d, "ID_PAGE_SETUP",SWIG_From_int(static_cast< int >(wxID_PAGE_SETUP)));
57030 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
57031 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
57032 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
57033 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
57034 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
57035 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
57036 SWIG_Python_SetConstant(d, "ID_HELP_INDEX",SWIG_From_int(static_cast< int >(wxID_HELP_INDEX)));
57037 SWIG_Python_SetConstant(d, "ID_HELP_SEARCH",SWIG_From_int(static_cast< int >(wxID_HELP_SEARCH)));
57038 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
57039 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
57040 SWIG_Python_SetConstant(d, "ID_EDIT",SWIG_From_int(static_cast< int >(wxID_EDIT)));
57041 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
57042 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
57043 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
57044 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
57045 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
57046 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
57047 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
57048 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
57049 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
57050 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
57051 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
57052 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
57053 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
57054 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
57055 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
57056 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
57057 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
57058 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
57059 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
57060 SWIG_Python_SetConstant(d, "ID_FILE",SWIG_From_int(static_cast< int >(wxID_FILE)));
57061 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
57062 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
57063 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
57064 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
57065 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
57066 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
57067 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
57068 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
57069 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
57070 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
57071 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
57072 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
57073 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
57074 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
57075 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
57076 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
57077 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
57078 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
57079 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
57080 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
57081 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
57082 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
57083 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
57084 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
57085 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
57086 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
57087 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
57088 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
57089 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
57090 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
57091 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
57092 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
57093 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
57094 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
57095 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
57096 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
57097 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
57098 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
57099 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
57100 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
57101 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
57102 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
57103 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
57104 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
57105 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
57106 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
57107 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
57108 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
57109 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
57110 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
57111 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
57112 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
57113 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
57114 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
57115 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
57116 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
57117 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
57118 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
57119 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
57120 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
57121 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
57122 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
57123 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
57124 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
57125 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
57126 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
57127 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
57128 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
57129 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
57130 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
57131 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
57132 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
57133 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
57134 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
57135 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
57136 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
57137 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
57138 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
57139 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
57140 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
57141 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
57142 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
57143 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
57144 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
57145 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
57146 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
57147 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
57148 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
57149 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
57150 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
57151 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
57152 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
57153 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
57154 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
57155 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
57156 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
57157 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
57158 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
57159 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
57160 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
57161 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
57162 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
57163 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
57164 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
57165 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
57166 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
57167 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
57168 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
57169 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
57170 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
57171 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
57172 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
57173 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
57174 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
57175 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
57176 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
57177 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
57178 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
57179 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
57180 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
57181 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
57182 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
57183 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
57184 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
57185 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
57186 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
57187 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
57188 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
57189 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
57190 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
57191 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
57192 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
57193 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
57194 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
57195 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
57196 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
57197 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
57198 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
57199 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
57200 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
57201 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
57202 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
57203 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
57204 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
57205 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
57206 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
57207 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
57208 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
57209 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
57210 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
57211 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
57212 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
57213 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
57214 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
57215 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
57216 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
57217 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
57218 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
57219 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
57220 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
57221 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
57222 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
57223 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
57224 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
57225 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
57226 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
57227 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
57228 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
57229 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
57230 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
57231 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
57232 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
57233 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
57234 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
57235 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
57236 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
57237 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
57238 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
57239 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
57240 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
57241 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
57242 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
57243 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
57244 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
57245 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
57246 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
57247 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
57248 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
57249 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
57250 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
57251 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
57252 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
57253 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
57254 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
57255 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
57256 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
57257 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
57258 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
57259 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
57260 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
57261 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
57262 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
57263 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
57264 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
57265 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
57266 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
57267 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
57268 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
57269 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
57270 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
57271 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
57272 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
57273 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
57274 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
57275 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
57276 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
57277 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
57278 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
57279 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
57280 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
57281 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
57282 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
57283 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
57284 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
57285 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
57286 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
57287 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
57288 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
57289 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
57290 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
57291 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
57292 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
57293 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
57294 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
57295 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
57296 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
57297 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
57298 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
57299 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
57300 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
57301 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
57302 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
57303 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
57304 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
57305 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
57306 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
57307 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
57308 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
57309 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
57310 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
57311 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
57312 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
57313 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
57314 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
57315 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
57316 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
57317 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
57318 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
57319 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
57320 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
57321 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
57322 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
57323 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
57324 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
57325 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
57326 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
57327 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
57328 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
57329 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
57330 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
57331 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
57332 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
57333 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
57334 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
57335 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
57336 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
57337 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
57338 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
57339 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
57340 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
57341 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
57342 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
57343 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
57344 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
57345 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
57346 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
57347 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
57348 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
57349 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
57350 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
57351 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
57352 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
57353 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
57354 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
57355 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
57356 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
57357 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
57358 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
57359 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
57360 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
57361 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
57362 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
57363 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
57364 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
57365 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
57366 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
57367 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
57368 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
57369 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
57370 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
57371 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
57372 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
57373 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
57374 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
57375 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
57376 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
57377 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
57378 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
57379 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
57380 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
57381 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
57382 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
57383 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
57384 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
57385 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
57386 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
57387 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
57388 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
57389 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
57390 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
57391 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
57392 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
57393 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
57394 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
57395 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
57396 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
57397 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
57398 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
57399 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
57400 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
57401 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
57402 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
57403 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
57404 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
57405 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
57406 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
57407 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
57408 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
57409 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
57410 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
57411 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
57412 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
57413 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
57414 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
57415 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
57416 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
57417 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
57418 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
57419 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
57420 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
57421 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
57422 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
57423 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
57424 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
57425 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
57426 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
57427 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
57428 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
57429 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
57430 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
57431 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
57432 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
57433 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
57434 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
57435 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
57436 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
57437 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
57438 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
57439 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
57440 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
57441 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
57442 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
57443 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
57444 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
57445 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
57446 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
57447 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
57448 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
57449 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
57450 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
57451 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
57452 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
57453 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
57454 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
57455 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
57456 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
57457 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
57458 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
57459 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
57460 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
57461 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
57462 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
57463 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
57464 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
57465 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
57466 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
57467 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
57468 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
57469 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
57470 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
57471 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
57472 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
57473 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
57474 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
57475 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
57476 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
57477 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
57478 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
57479 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
57480 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
57481 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
57482 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
57483 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
57484 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
57485 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
57486 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
57487 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
57488 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
57489 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
57490 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
57491 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
57492 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
57493 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
57494 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
57495 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
57496 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
57497 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
57498 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
57499 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
57500 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
57501 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
57502 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
57503 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
57504 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
57505 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
57506 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
57507 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
57508 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
57509 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
57510 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
57511 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
57512 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
57513 SWIG_Python_SetConstant(d, "Layout_Default",SWIG_From_int(static_cast< int >(wxLayout_Default)));
57514 SWIG_Python_SetConstant(d, "Layout_LeftToRight",SWIG_From_int(static_cast< int >(wxLayout_LeftToRight)));
57515 SWIG_Python_SetConstant(d, "Layout_RightToLeft",SWIG_From_int(static_cast< int >(wxLayout_RightToLeft)));
57516 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
57517 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
57518 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
57519 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
57520 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
57521 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
57522 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
57523 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
57524 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
57525 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
57526 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
57527 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
57528 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
57529 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
57530 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
57531 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
57532 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
57533 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
57534 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
57535 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
57536 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
57537 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
57538 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
57539 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
57540 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
57541 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
57542 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
57543 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
57544 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
57545 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
57546 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
57547 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
57548 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
57549 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
57550 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
57551 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
57552 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
57553 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
57554 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
57555 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
57556 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
57557 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
57558 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
57559 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
57560 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
57561 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
57562 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
57563 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
57564 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
57565 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
57566 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
57567 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
57568 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
57569 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
57570 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
57571 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
57572 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
57573 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
57574
57575 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
57576
57577
57578 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
57579
57580 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
57581 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
57582 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
57583 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
57584 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
57585 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
57586 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
57587 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
57588 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
57589 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
57590 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
57591 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
57592 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
57593 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
57594 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
57595 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
57596 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
57597 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
57598 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
57599 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
57600 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
57601 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
57602 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
57603 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
57604 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
57605 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
57606 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
57607 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
57608 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
57609 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
57610 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
57611 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
57612 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
57613 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
57614 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
57615 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
57616 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
57617 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
57618 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
57619 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
57620 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
57621 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
57622 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
57623 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
57624 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
57625 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
57626 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
57627 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
57628 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
57629 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
57630 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
57631 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
57632 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
57633 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
57634 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
57635 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
57636 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
57637 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
57638 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
57639 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
57640 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
57641 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
57642 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
57643 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
57644 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
57645 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
57646 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
57647 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
57648 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
57649 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
57650 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
57651 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
57652 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
57653 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
57654 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
57655 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
57656 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
57657 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
57658 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
57659 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
57660 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
57661 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
57662 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
57663 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
57664 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
57665 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
57666 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
57667 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
57668 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
57669 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
57670 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
57671 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
57672 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
57673 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
57674 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
57675 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
57676 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
57677 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
57678 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
57679 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
57680 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
57681 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
57682 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
57683 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
57684 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
57685 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
57686 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
57687 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
57688 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
57689 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
57690 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
57691 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
57692 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
57693 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
57694 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
57695 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
57696 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
57697 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
57698 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
57699 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
57700 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
57701 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_LOST", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_LOST));
57702 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
57703 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
57704 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
57705 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
57706 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
57707 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
57708 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
57709 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
57710 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
57711 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
57712 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
57713 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
57714 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
57715 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
57716 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
57717 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
57718 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
57719 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
57720 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
57721 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
57722 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
57723 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
57724 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
57725 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
57726 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
57727 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
57728 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
57729 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
57730 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
57731 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
57732 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
57733 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
57734 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
57735 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
57736 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
57737 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
57738 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
57739 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
57740 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
57741 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
57742 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
57743 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
57744 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
57745 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
57746 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
57747 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
57748 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
57749 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
57750 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
57751 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
57752 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
57753 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
57754 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
57755 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
57756 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
57757 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
57758 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
57759 SWIG_Python_SetConstant(d, "ACCEL_CMD",SWIG_From_int(static_cast< int >(wxACCEL_CMD)));
57760 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
57761 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
57762 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
57763 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
57764 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
57765 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
57766 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
57767 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
57768 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
57769 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
57770 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
57771 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
57772 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
57773 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
57774 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
57775 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
57776 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
57777 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
57778 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
57779 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
57780 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
57781 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
57782 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
57783 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
57784 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
57785 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
57786 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
57787 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
57788 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
57789 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
57790 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
57791 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
57792
57793 // Initialize threading, some globals and such
57794 __wxPyPreStart(d);
57795
57796
57797 // Although these are defined in __version__ they need to be here too so
57798 // that an assert can be done to ensure that the wxPython and the wxWindows
57799 // versions match.
57800 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
57801 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
57802 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
57803
57804 }
57805
wxWidgets (Impactor)