]> 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
reSWIGged
[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 /* for raw pointers */
989 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
990 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
991 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
992 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
993 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
994 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
995 #define swig_owntype int
996
997 /* for raw packed data */
998 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
999 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1000
1001 /* for class or struct pointers */
1002 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1003 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1004
1005 /* for C or C++ function pointers */
1006 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1007 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1008
1009 /* for C++ member pointers, ie, member methods */
1010 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1011 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1012
1013
1014 /* Runtime API */
1015
1016 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1017 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1018 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1019
1020 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1021 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1022 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1023 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1024 #define SWIG_fail goto fail
1025
1026
1027 /* Runtime API implementation */
1028
1029 /* Error manipulation */
1030
1031 SWIGINTERN void
1032 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1033 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1034 PyErr_SetObject(errtype, obj);
1035 Py_DECREF(obj);
1036 SWIG_PYTHON_THREAD_END_BLOCK;
1037 }
1038
1039 SWIGINTERN void
1040 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1041 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1042 PyErr_SetString(errtype, (char *) msg);
1043 SWIG_PYTHON_THREAD_END_BLOCK;
1044 }
1045
1046 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1047
1048 /* Set a constant value */
1049
1050 SWIGINTERN void
1051 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1052 PyDict_SetItemString(d, (char*) name, obj);
1053 Py_DECREF(obj);
1054 }
1055
1056 /* Append a value to the result obj */
1057
1058 SWIGINTERN PyObject*
1059 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1060 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1061 if (!result) {
1062 result = obj;
1063 } else if (result == Py_None) {
1064 Py_DECREF(result);
1065 result = obj;
1066 } else {
1067 if (!PyList_Check(result)) {
1068 PyObject *o2 = result;
1069 result = PyList_New(1);
1070 PyList_SetItem(result, 0, o2);
1071 }
1072 PyList_Append(result,obj);
1073 Py_DECREF(obj);
1074 }
1075 return result;
1076 #else
1077 PyObject* o2;
1078 PyObject* o3;
1079 if (!result) {
1080 result = obj;
1081 } else if (result == Py_None) {
1082 Py_DECREF(result);
1083 result = obj;
1084 } else {
1085 if (!PyTuple_Check(result)) {
1086 o2 = result;
1087 result = PyTuple_New(1);
1088 PyTuple_SET_ITEM(result, 0, o2);
1089 }
1090 o3 = PyTuple_New(1);
1091 PyTuple_SET_ITEM(o3, 0, obj);
1092 o2 = result;
1093 result = PySequence_Concat(o2, o3);
1094 Py_DECREF(o2);
1095 Py_DECREF(o3);
1096 }
1097 return result;
1098 #endif
1099 }
1100
1101 /* Unpack the argument tuple */
1102
1103 SWIGINTERN int
1104 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1105 {
1106 if (!args) {
1107 if (!min && !max) {
1108 return 1;
1109 } else {
1110 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1111 name, (min == max ? "" : "at least "), min);
1112 return 0;
1113 }
1114 }
1115 if (!PyTuple_Check(args)) {
1116 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1117 return 0;
1118 } else {
1119 register int l = PyTuple_GET_SIZE(args);
1120 if (l < min) {
1121 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1122 name, (min == max ? "" : "at least "), min, l);
1123 return 0;
1124 } else if (l > max) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at most "), max, l);
1127 return 0;
1128 } else {
1129 register int i;
1130 for (i = 0; i < l; ++i) {
1131 objs[i] = PyTuple_GET_ITEM(args, i);
1132 }
1133 for (; l < max; ++l) {
1134 objs[l] = 0;
1135 }
1136 return i + 1;
1137 }
1138 }
1139 }
1140
1141 /* A functor is a function object with one single object argument */
1142 #if PY_VERSION_HEX >= 0x02020000
1143 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1144 #else
1145 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1146 #endif
1147
1148 /*
1149 Helper for static pointer initialization for both C and C++ code, for example
1150 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1151 */
1152 #ifdef __cplusplus
1153 #define SWIG_STATIC_POINTER(var) var
1154 #else
1155 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1156 #endif
1157
1158 /* -----------------------------------------------------------------------------
1159 * Pointer declarations
1160 * ----------------------------------------------------------------------------- */
1161
1162 /* Flags for new pointer objects */
1163 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1164 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1165
1166 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1167
1168 #ifdef __cplusplus
1169 extern "C" {
1170 #if 0
1171 } /* cc-mode */
1172 #endif
1173 #endif
1174
1175 /* How to access Py_None */
1176 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1177 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1178 # ifndef SWIG_PYTHON_BUILD_NONE
1179 # define SWIG_PYTHON_BUILD_NONE
1180 # endif
1181 # endif
1182 #endif
1183
1184 #ifdef SWIG_PYTHON_BUILD_NONE
1185 # ifdef Py_None
1186 # undef Py_None
1187 # define Py_None SWIG_Py_None()
1188 # endif
1189 SWIGRUNTIMEINLINE PyObject *
1190 _SWIG_Py_None(void)
1191 {
1192 PyObject *none = Py_BuildValue("");
1193 Py_DECREF(none);
1194 return none;
1195 }
1196 SWIGRUNTIME PyObject *
1197 SWIG_Py_None(void)
1198 {
1199 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1200 return none;
1201 }
1202 #endif
1203
1204 /* The python void return value */
1205
1206 SWIGRUNTIMEINLINE PyObject *
1207 SWIG_Py_Void(void)
1208 {
1209 PyObject *none = Py_None;
1210 Py_INCREF(none);
1211 return none;
1212 }
1213
1214 /* PySwigClientData */
1215
1216 typedef struct {
1217 PyObject *klass;
1218 PyObject *newraw;
1219 PyObject *newargs;
1220 PyObject *destroy;
1221 int delargs;
1222 int implicitconv;
1223 } PySwigClientData;
1224
1225 SWIGRUNTIMEINLINE int
1226 SWIG_Python_CheckImplicit(swig_type_info *ty)
1227 {
1228 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1229 return data ? data->implicitconv : 0;
1230 }
1231
1232 SWIGRUNTIMEINLINE PyObject *
1233 SWIG_Python_ExceptionType(swig_type_info *desc) {
1234 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1235 PyObject *klass = data ? data->klass : 0;
1236 return (klass ? klass : PyExc_RuntimeError);
1237 }
1238
1239
1240 SWIGRUNTIME PySwigClientData *
1241 PySwigClientData_New(PyObject* obj)
1242 {
1243 if (!obj) {
1244 return 0;
1245 } else {
1246 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1247 /* the klass element */
1248 data->klass = obj;
1249 Py_INCREF(data->klass);
1250 /* the newraw method and newargs arguments used to create a new raw instance */
1251 if (PyClass_Check(obj)) {
1252 data->newraw = 0;
1253 data->newargs = obj;
1254 Py_INCREF(obj);
1255 } else {
1256 #if (PY_VERSION_HEX < 0x02020000)
1257 data->newraw = 0;
1258 #else
1259 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1260 #endif
1261 if (data->newraw) {
1262 Py_INCREF(data->newraw);
1263 data->newargs = PyTuple_New(1);
1264 PyTuple_SetItem(data->newargs, 0, obj);
1265 } else {
1266 data->newargs = obj;
1267 }
1268 Py_INCREF(data->newargs);
1269 }
1270 /* the destroy method, aka as the C++ delete method */
1271 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1272 if (PyErr_Occurred()) {
1273 PyErr_Clear();
1274 data->destroy = 0;
1275 }
1276 if (data->destroy) {
1277 int flags;
1278 Py_INCREF(data->destroy);
1279 flags = PyCFunction_GET_FLAGS(data->destroy);
1280 #ifdef METH_O
1281 data->delargs = !(flags & (METH_O));
1282 #else
1283 data->delargs = 0;
1284 #endif
1285 } else {
1286 data->delargs = 0;
1287 }
1288 data->implicitconv = 0;
1289 return data;
1290 }
1291 }
1292
1293 SWIGRUNTIME void
1294 PySwigClientData_Del(PySwigClientData* data)
1295 {
1296 Py_XDECREF(data->newraw);
1297 Py_XDECREF(data->newargs);
1298 Py_XDECREF(data->destroy);
1299 }
1300
1301 /* =============== PySwigObject =====================*/
1302
1303 typedef struct {
1304 PyObject_HEAD
1305 void *ptr;
1306 swig_type_info *ty;
1307 int own;
1308 PyObject *next;
1309 } PySwigObject;
1310
1311 SWIGRUNTIME PyObject *
1312 PySwigObject_long(PySwigObject *v)
1313 {
1314 return PyLong_FromVoidPtr(v->ptr);
1315 }
1316
1317 SWIGRUNTIME PyObject *
1318 PySwigObject_format(const char* fmt, PySwigObject *v)
1319 {
1320 PyObject *res = NULL;
1321 PyObject *args = PyTuple_New(1);
1322 if (args) {
1323 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1324 PyObject *ofmt = PyString_FromString(fmt);
1325 if (ofmt) {
1326 res = PyString_Format(ofmt,args);
1327 Py_DECREF(ofmt);
1328 }
1329 Py_DECREF(args);
1330 }
1331 }
1332 return res;
1333 }
1334
1335 SWIGRUNTIME PyObject *
1336 PySwigObject_oct(PySwigObject *v)
1337 {
1338 return PySwigObject_format("%o",v);
1339 }
1340
1341 SWIGRUNTIME PyObject *
1342 PySwigObject_hex(PySwigObject *v)
1343 {
1344 return PySwigObject_format("%x",v);
1345 }
1346
1347 SWIGRUNTIME PyObject *
1348 #ifdef METH_NOARGS
1349 PySwigObject_repr(PySwigObject *v)
1350 #else
1351 PySwigObject_repr(PySwigObject *v, PyObject *args)
1352 #endif
1353 {
1354 const char *name = SWIG_TypePrettyName(v->ty);
1355 PyObject *hex = PySwigObject_hex(v);
1356 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1357 Py_DECREF(hex);
1358 if (v->next) {
1359 #ifdef METH_NOARGS
1360 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1361 #else
1362 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1363 #endif
1364 PyString_ConcatAndDel(&repr,nrep);
1365 }
1366 return repr;
1367 }
1368
1369 SWIGRUNTIME int
1370 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1371 {
1372 #ifdef METH_NOARGS
1373 PyObject *repr = PySwigObject_repr(v);
1374 #else
1375 PyObject *repr = PySwigObject_repr(v, NULL);
1376 #endif
1377 if (repr) {
1378 fputs(PyString_AsString(repr), fp);
1379 Py_DECREF(repr);
1380 return 0;
1381 } else {
1382 return 1;
1383 }
1384 }
1385
1386 SWIGRUNTIME PyObject *
1387 PySwigObject_str(PySwigObject *v)
1388 {
1389 char result[SWIG_BUFFER_SIZE];
1390 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1391 PyString_FromString(result) : 0;
1392 }
1393
1394 SWIGRUNTIME int
1395 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1396 {
1397 void *i = v->ptr;
1398 void *j = w->ptr;
1399 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1400 }
1401
1402 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1403
1404 SWIGRUNTIME PyTypeObject*
1405 PySwigObject_type(void) {
1406 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1407 return type;
1408 }
1409
1410 SWIGRUNTIMEINLINE int
1411 PySwigObject_Check(PyObject *op) {
1412 return ((op)->ob_type == PySwigObject_type())
1413 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1414 }
1415
1416 SWIGRUNTIME PyObject *
1417 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1418
1419 SWIGRUNTIME void
1420 PySwigObject_dealloc(PyObject *v)
1421 {
1422 PySwigObject *sobj = (PySwigObject *) v;
1423 PyObject *next = sobj->next;
1424 if (sobj->own) {
1425 swig_type_info *ty = sobj->ty;
1426 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1427 PyObject *destroy = data ? data->destroy : 0;
1428 if (destroy) {
1429 /* destroy is always a VARARGS method */
1430 PyObject *res;
1431 if (data->delargs) {
1432 /* we need to create a temporal object to carry the destroy operation */
1433 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1434 res = SWIG_Python_CallFunctor(destroy, tmp);
1435 Py_DECREF(tmp);
1436 } else {
1437 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1438 PyObject *mself = PyCFunction_GET_SELF(destroy);
1439 res = ((*meth)(mself, v));
1440 }
1441 Py_XDECREF(res);
1442 } else {
1443 const char *name = SWIG_TypePrettyName(ty);
1444 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1445 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1446 #endif
1447 }
1448 }
1449 Py_XDECREF(next);
1450 PyObject_DEL(v);
1451 }
1452
1453 SWIGRUNTIME PyObject*
1454 PySwigObject_append(PyObject* v, PyObject* next)
1455 {
1456 PySwigObject *sobj = (PySwigObject *) v;
1457 #ifndef METH_O
1458 PyObject *tmp = 0;
1459 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1460 next = tmp;
1461 #endif
1462 if (!PySwigObject_Check(next)) {
1463 return NULL;
1464 }
1465 sobj->next = next;
1466 Py_INCREF(next);
1467 return SWIG_Py_Void();
1468 }
1469
1470 SWIGRUNTIME PyObject*
1471 #ifdef METH_NOARGS
1472 PySwigObject_next(PyObject* v)
1473 #else
1474 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1475 #endif
1476 {
1477 PySwigObject *sobj = (PySwigObject *) v;
1478 if (sobj->next) {
1479 Py_INCREF(sobj->next);
1480 return sobj->next;
1481 } else {
1482 return SWIG_Py_Void();
1483 }
1484 }
1485
1486 SWIGINTERN PyObject*
1487 #ifdef METH_NOARGS
1488 PySwigObject_disown(PyObject *v)
1489 #else
1490 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1491 #endif
1492 {
1493 PySwigObject *sobj = (PySwigObject *)v;
1494 sobj->own = 0;
1495 return SWIG_Py_Void();
1496 }
1497
1498 SWIGINTERN PyObject*
1499 #ifdef METH_NOARGS
1500 PySwigObject_acquire(PyObject *v)
1501 #else
1502 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1503 #endif
1504 {
1505 PySwigObject *sobj = (PySwigObject *)v;
1506 sobj->own = SWIG_POINTER_OWN;
1507 return SWIG_Py_Void();
1508 }
1509
1510 SWIGINTERN PyObject*
1511 PySwigObject_own(PyObject *v, PyObject *args)
1512 {
1513 PyObject *val = 0;
1514 #if (PY_VERSION_HEX < 0x02020000)
1515 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1516 #else
1517 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1518 #endif
1519 {
1520 return NULL;
1521 }
1522 else
1523 {
1524 PySwigObject *sobj = (PySwigObject *)v;
1525 PyObject *obj = PyBool_FromLong(sobj->own);
1526 if (val) {
1527 #ifdef METH_NOARGS
1528 if (PyObject_IsTrue(val)) {
1529 PySwigObject_acquire(v);
1530 } else {
1531 PySwigObject_disown(v);
1532 }
1533 #else
1534 if (PyObject_IsTrue(val)) {
1535 PySwigObject_acquire(v,args);
1536 } else {
1537 PySwigObject_disown(v,args);
1538 }
1539 #endif
1540 }
1541 return obj;
1542 }
1543 }
1544
1545 #ifdef METH_O
1546 static PyMethodDef
1547 swigobject_methods[] = {
1548 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1549 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1550 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1551 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1552 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1553 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1554 {0, 0, 0, 0}
1555 };
1556 #else
1557 static PyMethodDef
1558 swigobject_methods[] = {
1559 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1560 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1561 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1562 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1563 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1564 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1565 {0, 0, 0, 0}
1566 };
1567 #endif
1568
1569 #if PY_VERSION_HEX < 0x02020000
1570 SWIGINTERN PyObject *
1571 PySwigObject_getattr(PySwigObject *sobj,char *name)
1572 {
1573 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1574 }
1575 #endif
1576
1577 SWIGRUNTIME PyTypeObject*
1578 _PySwigObject_type(void) {
1579 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1580
1581 static PyNumberMethods PySwigObject_as_number = {
1582 (binaryfunc)0, /*nb_add*/
1583 (binaryfunc)0, /*nb_subtract*/
1584 (binaryfunc)0, /*nb_multiply*/
1585 (binaryfunc)0, /*nb_divide*/
1586 (binaryfunc)0, /*nb_remainder*/
1587 (binaryfunc)0, /*nb_divmod*/
1588 (ternaryfunc)0,/*nb_power*/
1589 (unaryfunc)0, /*nb_negative*/
1590 (unaryfunc)0, /*nb_positive*/
1591 (unaryfunc)0, /*nb_absolute*/
1592 (inquiry)0, /*nb_nonzero*/
1593 0, /*nb_invert*/
1594 0, /*nb_lshift*/
1595 0, /*nb_rshift*/
1596 0, /*nb_and*/
1597 0, /*nb_xor*/
1598 0, /*nb_or*/
1599 (coercion)0, /*nb_coerce*/
1600 (unaryfunc)PySwigObject_long, /*nb_int*/
1601 (unaryfunc)PySwigObject_long, /*nb_long*/
1602 (unaryfunc)0, /*nb_float*/
1603 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1604 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1605 #if PY_VERSION_HEX >= 0x02020000
1606 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1607 #elif PY_VERSION_HEX >= 0x02000000
1608 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1609 #endif
1610 };
1611
1612 static PyTypeObject pyswigobject_type;
1613 static int type_init = 0;
1614 if (!type_init) {
1615 const PyTypeObject tmp
1616 = {
1617 PyObject_HEAD_INIT(NULL)
1618 0, /* ob_size */
1619 (char *)"PySwigObject", /* tp_name */
1620 sizeof(PySwigObject), /* tp_basicsize */
1621 0, /* tp_itemsize */
1622 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1623 (printfunc)PySwigObject_print, /* tp_print */
1624 #if PY_VERSION_HEX < 0x02020000
1625 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1626 #else
1627 (getattrfunc)0, /* tp_getattr */
1628 #endif
1629 (setattrfunc)0, /* tp_setattr */
1630 (cmpfunc)PySwigObject_compare, /* tp_compare */
1631 (reprfunc)PySwigObject_repr, /* tp_repr */
1632 &PySwigObject_as_number, /* tp_as_number */
1633 0, /* tp_as_sequence */
1634 0, /* tp_as_mapping */
1635 (hashfunc)0, /* tp_hash */
1636 (ternaryfunc)0, /* tp_call */
1637 (reprfunc)PySwigObject_str, /* tp_str */
1638 PyObject_GenericGetAttr, /* tp_getattro */
1639 0, /* tp_setattro */
1640 0, /* tp_as_buffer */
1641 Py_TPFLAGS_DEFAULT, /* tp_flags */
1642 swigobject_doc, /* tp_doc */
1643 0, /* tp_traverse */
1644 0, /* tp_clear */
1645 0, /* tp_richcompare */
1646 0, /* tp_weaklistoffset */
1647 #if PY_VERSION_HEX >= 0x02020000
1648 0, /* tp_iter */
1649 0, /* tp_iternext */
1650 swigobject_methods, /* tp_methods */
1651 0, /* tp_members */
1652 0, /* tp_getset */
1653 0, /* tp_base */
1654 0, /* tp_dict */
1655 0, /* tp_descr_get */
1656 0, /* tp_descr_set */
1657 0, /* tp_dictoffset */
1658 0, /* tp_init */
1659 0, /* tp_alloc */
1660 0, /* tp_new */
1661 0, /* tp_free */
1662 0, /* tp_is_gc */
1663 0, /* tp_bases */
1664 0, /* tp_mro */
1665 0, /* tp_cache */
1666 0, /* tp_subclasses */
1667 0, /* tp_weaklist */
1668 #endif
1669 #if PY_VERSION_HEX >= 0x02030000
1670 0, /* tp_del */
1671 #endif
1672 #ifdef COUNT_ALLOCS
1673 0,0,0,0 /* tp_alloc -> tp_next */
1674 #endif
1675 };
1676 pyswigobject_type = tmp;
1677 pyswigobject_type.ob_type = &PyType_Type;
1678 type_init = 1;
1679 }
1680 return &pyswigobject_type;
1681 }
1682
1683 SWIGRUNTIME PyObject *
1684 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1685 {
1686 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1687 if (sobj) {
1688 sobj->ptr = ptr;
1689 sobj->ty = ty;
1690 sobj->own = own;
1691 sobj->next = 0;
1692 }
1693 return (PyObject *)sobj;
1694 }
1695
1696 /* -----------------------------------------------------------------------------
1697 * Implements a simple Swig Packed type, and use it instead of string
1698 * ----------------------------------------------------------------------------- */
1699
1700 typedef struct {
1701 PyObject_HEAD
1702 void *pack;
1703 swig_type_info *ty;
1704 size_t size;
1705 } PySwigPacked;
1706
1707 SWIGRUNTIME int
1708 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1709 {
1710 char result[SWIG_BUFFER_SIZE];
1711 fputs("<Swig Packed ", fp);
1712 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1713 fputs("at ", fp);
1714 fputs(result, fp);
1715 }
1716 fputs(v->ty->name,fp);
1717 fputs(">", fp);
1718 return 0;
1719 }
1720
1721 SWIGRUNTIME PyObject *
1722 PySwigPacked_repr(PySwigPacked *v)
1723 {
1724 char result[SWIG_BUFFER_SIZE];
1725 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1726 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1727 } else {
1728 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1729 }
1730 }
1731
1732 SWIGRUNTIME PyObject *
1733 PySwigPacked_str(PySwigPacked *v)
1734 {
1735 char result[SWIG_BUFFER_SIZE];
1736 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1737 return PyString_FromFormat("%s%s", result, v->ty->name);
1738 } else {
1739 return PyString_FromString(v->ty->name);
1740 }
1741 }
1742
1743 SWIGRUNTIME int
1744 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1745 {
1746 size_t i = v->size;
1747 size_t j = w->size;
1748 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1749 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1750 }
1751
1752 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1753
1754 SWIGRUNTIME PyTypeObject*
1755 PySwigPacked_type(void) {
1756 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1757 return type;
1758 }
1759
1760 SWIGRUNTIMEINLINE int
1761 PySwigPacked_Check(PyObject *op) {
1762 return ((op)->ob_type == _PySwigPacked_type())
1763 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1764 }
1765
1766 SWIGRUNTIME void
1767 PySwigPacked_dealloc(PyObject *v)
1768 {
1769 if (PySwigPacked_Check(v)) {
1770 PySwigPacked *sobj = (PySwigPacked *) v;
1771 free(sobj->pack);
1772 }
1773 PyObject_DEL(v);
1774 }
1775
1776 SWIGRUNTIME PyTypeObject*
1777 _PySwigPacked_type(void) {
1778 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1779 static PyTypeObject pyswigpacked_type;
1780 static int type_init = 0;
1781 if (!type_init) {
1782 const PyTypeObject tmp
1783 = {
1784 PyObject_HEAD_INIT(NULL)
1785 0, /* ob_size */
1786 (char *)"PySwigPacked", /* tp_name */
1787 sizeof(PySwigPacked), /* tp_basicsize */
1788 0, /* tp_itemsize */
1789 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1790 (printfunc)PySwigPacked_print, /* tp_print */
1791 (getattrfunc)0, /* tp_getattr */
1792 (setattrfunc)0, /* tp_setattr */
1793 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1794 (reprfunc)PySwigPacked_repr, /* tp_repr */
1795 0, /* tp_as_number */
1796 0, /* tp_as_sequence */
1797 0, /* tp_as_mapping */
1798 (hashfunc)0, /* tp_hash */
1799 (ternaryfunc)0, /* tp_call */
1800 (reprfunc)PySwigPacked_str, /* tp_str */
1801 PyObject_GenericGetAttr, /* tp_getattro */
1802 0, /* tp_setattro */
1803 0, /* tp_as_buffer */
1804 Py_TPFLAGS_DEFAULT, /* tp_flags */
1805 swigpacked_doc, /* tp_doc */
1806 0, /* tp_traverse */
1807 0, /* tp_clear */
1808 0, /* tp_richcompare */
1809 0, /* tp_weaklistoffset */
1810 #if PY_VERSION_HEX >= 0x02020000
1811 0, /* tp_iter */
1812 0, /* tp_iternext */
1813 0, /* tp_methods */
1814 0, /* tp_members */
1815 0, /* tp_getset */
1816 0, /* tp_base */
1817 0, /* tp_dict */
1818 0, /* tp_descr_get */
1819 0, /* tp_descr_set */
1820 0, /* tp_dictoffset */
1821 0, /* tp_init */
1822 0, /* tp_alloc */
1823 0, /* tp_new */
1824 0, /* tp_free */
1825 0, /* tp_is_gc */
1826 0, /* tp_bases */
1827 0, /* tp_mro */
1828 0, /* tp_cache */
1829 0, /* tp_subclasses */
1830 0, /* tp_weaklist */
1831 #endif
1832 #if PY_VERSION_HEX >= 0x02030000
1833 0, /* tp_del */
1834 #endif
1835 #ifdef COUNT_ALLOCS
1836 0,0,0,0 /* tp_alloc -> tp_next */
1837 #endif
1838 };
1839 pyswigpacked_type = tmp;
1840 pyswigpacked_type.ob_type = &PyType_Type;
1841 type_init = 1;
1842 }
1843 return &pyswigpacked_type;
1844 }
1845
1846 SWIGRUNTIME PyObject *
1847 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1848 {
1849 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1850 if (sobj) {
1851 void *pack = malloc(size);
1852 if (pack) {
1853 memcpy(pack, ptr, size);
1854 sobj->pack = pack;
1855 sobj->ty = ty;
1856 sobj->size = size;
1857 } else {
1858 PyObject_DEL((PyObject *) sobj);
1859 sobj = 0;
1860 }
1861 }
1862 return (PyObject *) sobj;
1863 }
1864
1865 SWIGRUNTIME swig_type_info *
1866 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1867 {
1868 if (PySwigPacked_Check(obj)) {
1869 PySwigPacked *sobj = (PySwigPacked *)obj;
1870 if (sobj->size != size) return 0;
1871 memcpy(ptr, sobj->pack, size);
1872 return sobj->ty;
1873 } else {
1874 return 0;
1875 }
1876 }
1877
1878 /* -----------------------------------------------------------------------------
1879 * pointers/data manipulation
1880 * ----------------------------------------------------------------------------- */
1881
1882 SWIGRUNTIMEINLINE PyObject *
1883 _SWIG_This(void)
1884 {
1885 return PyString_FromString("this");
1886 }
1887
1888 SWIGRUNTIME PyObject *
1889 SWIG_This(void)
1890 {
1891 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1892 return swig_this;
1893 }
1894
1895 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1896
1897 SWIGRUNTIME PySwigObject *
1898 SWIG_Python_GetSwigThis(PyObject *pyobj)
1899 {
1900 if (PySwigObject_Check(pyobj)) {
1901 return (PySwigObject *) pyobj;
1902 } else {
1903 PyObject *obj = 0;
1904 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1905 if (PyInstance_Check(pyobj)) {
1906 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1907 } else {
1908 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1909 if (dictptr != NULL) {
1910 PyObject *dict = *dictptr;
1911 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1912 } else {
1913 #ifdef PyWeakref_CheckProxy
1914 if (PyWeakref_CheckProxy(pyobj)) {
1915 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1916 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1917 }
1918 #endif
1919 obj = PyObject_GetAttr(pyobj,SWIG_This());
1920 if (obj) {
1921 Py_DECREF(obj);
1922 } else {
1923 if (PyErr_Occurred()) PyErr_Clear();
1924 return 0;
1925 }
1926 }
1927 }
1928 #else
1929 obj = PyObject_GetAttr(pyobj,SWIG_This());
1930 if (obj) {
1931 Py_DECREF(obj);
1932 } else {
1933 if (PyErr_Occurred()) PyErr_Clear();
1934 return 0;
1935 }
1936 #endif
1937 if (obj && !PySwigObject_Check(obj)) {
1938 /* a PyObject is called 'this', try to get the 'real this'
1939 PySwigObject from it */
1940 return SWIG_Python_GetSwigThis(obj);
1941 }
1942 return (PySwigObject *)obj;
1943 }
1944 }
1945
1946 /* Acquire a pointer value */
1947
1948 SWIGRUNTIME int
1949 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1950 if (own) {
1951 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1952 if (sobj) {
1953 int oldown = sobj->own;
1954 sobj->own = own;
1955 return oldown;
1956 }
1957 }
1958 return 0;
1959 }
1960
1961 /* Convert a pointer value */
1962
1963 SWIGRUNTIME int
1964 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1965 if (!obj) return SWIG_ERROR;
1966 if (obj == Py_None) {
1967 if (ptr) *ptr = 0;
1968 return SWIG_OK;
1969 } else {
1970 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1971 while (sobj) {
1972 void *vptr = sobj->ptr;
1973 if (ty) {
1974 swig_type_info *to = sobj->ty;
1975 if (to == ty) {
1976 /* no type cast needed */
1977 if (ptr) *ptr = vptr;
1978 break;
1979 } else {
1980 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1981 if (!tc) {
1982 sobj = (PySwigObject *)sobj->next;
1983 } else {
1984 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1985 break;
1986 }
1987 }
1988 } else {
1989 if (ptr) *ptr = vptr;
1990 break;
1991 }
1992 }
1993 if (sobj) {
1994 if (own) *own = sobj->own;
1995 if (flags & SWIG_POINTER_DISOWN) {
1996 sobj->own = 0;
1997 }
1998 return SWIG_OK;
1999 } else {
2000 int res = SWIG_ERROR;
2001 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2002 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2003 if (data && !data->implicitconv) {
2004 PyObject *klass = data->klass;
2005 if (klass) {
2006 PyObject *impconv;
2007 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2008 impconv = SWIG_Python_CallFunctor(klass, obj);
2009 data->implicitconv = 0;
2010 if (PyErr_Occurred()) {
2011 PyErr_Clear();
2012 impconv = 0;
2013 }
2014 if (impconv) {
2015 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2016 if (iobj) {
2017 void *vptr;
2018 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2019 if (SWIG_IsOK(res)) {
2020 if (ptr) {
2021 *ptr = vptr;
2022 /* transfer the ownership to 'ptr' */
2023 iobj->own = 0;
2024 res = SWIG_AddCast(res);
2025 res = SWIG_AddNewMask(res);
2026 } else {
2027 res = SWIG_AddCast(res);
2028 }
2029 }
2030 }
2031 Py_DECREF(impconv);
2032 }
2033 }
2034 }
2035 }
2036 return res;
2037 }
2038 }
2039 }
2040
2041 /* Convert a function ptr value */
2042
2043 SWIGRUNTIME int
2044 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2045 if (!PyCFunction_Check(obj)) {
2046 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2047 } else {
2048 void *vptr = 0;
2049
2050 /* here we get the method pointer for callbacks */
2051 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2052 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2053 if (desc) {
2054 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2055 if (!desc) return SWIG_ERROR;
2056 }
2057 if (ty) {
2058 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2059 if (!tc) return SWIG_ERROR;
2060 *ptr = SWIG_TypeCast(tc,vptr);
2061 } else {
2062 *ptr = vptr;
2063 }
2064 return SWIG_OK;
2065 }
2066 }
2067
2068 /* Convert a packed value value */
2069
2070 SWIGRUNTIME int
2071 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2072 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2073 if (!to) return SWIG_ERROR;
2074 if (ty) {
2075 if (to != ty) {
2076 /* check type cast? */
2077 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2078 if (!tc) return SWIG_ERROR;
2079 }
2080 }
2081 return SWIG_OK;
2082 }
2083
2084 /* -----------------------------------------------------------------------------
2085 * Create a new pointer object
2086 * ----------------------------------------------------------------------------- */
2087
2088 /*
2089 Create a new instance object, whitout calling __init__, and set the
2090 'this' attribute.
2091 */
2092
2093 SWIGRUNTIME PyObject*
2094 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2095 {
2096 #if (PY_VERSION_HEX >= 0x02020000)
2097 PyObject *inst = 0;
2098 PyObject *newraw = data->newraw;
2099 if (newraw) {
2100 inst = PyObject_Call(newraw, data->newargs, NULL);
2101 if (inst) {
2102 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2103 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2104 if (dictptr != NULL) {
2105 PyObject *dict = *dictptr;
2106 if (dict == NULL) {
2107 dict = PyDict_New();
2108 *dictptr = dict;
2109 PyDict_SetItem(dict, SWIG_This(), swig_this);
2110 }
2111 }
2112 #else
2113 PyObject *key = SWIG_This();
2114 PyObject_SetAttr(inst, key, swig_this);
2115 #endif
2116 }
2117 } else {
2118 PyObject *dict = PyDict_New();
2119 PyDict_SetItem(dict, SWIG_This(), swig_this);
2120 inst = PyInstance_NewRaw(data->newargs, dict);
2121 Py_DECREF(dict);
2122 }
2123 return inst;
2124 #else
2125 #if (PY_VERSION_HEX >= 0x02010000)
2126 PyObject *inst;
2127 PyObject *dict = PyDict_New();
2128 PyDict_SetItem(dict, SWIG_This(), swig_this);
2129 inst = PyInstance_NewRaw(data->newargs, dict);
2130 Py_DECREF(dict);
2131 return (PyObject *) inst;
2132 #else
2133 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2134 if (inst == NULL) {
2135 return NULL;
2136 }
2137 inst->in_class = (PyClassObject *)data->newargs;
2138 Py_INCREF(inst->in_class);
2139 inst->in_dict = PyDict_New();
2140 if (inst->in_dict == NULL) {
2141 Py_DECREF(inst);
2142 return NULL;
2143 }
2144 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2145 inst->in_weakreflist = NULL;
2146 #endif
2147 #ifdef Py_TPFLAGS_GC
2148 PyObject_GC_Init(inst);
2149 #endif
2150 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2151 return (PyObject *) inst;
2152 #endif
2153 #endif
2154 }
2155
2156 SWIGRUNTIME void
2157 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2158 {
2159 PyObject *dict;
2160 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2161 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2162 if (dictptr != NULL) {
2163 dict = *dictptr;
2164 if (dict == NULL) {
2165 dict = PyDict_New();
2166 *dictptr = dict;
2167 }
2168 PyDict_SetItem(dict, SWIG_This(), swig_this);
2169 return;
2170 }
2171 #endif
2172 dict = PyObject_GetAttrString(inst, "__dict__");
2173 PyDict_SetItem(dict, SWIG_This(), swig_this);
2174 Py_DECREF(dict);
2175 }
2176
2177
2178 SWIGINTERN PyObject *
2179 SWIG_Python_InitShadowInstance(PyObject *args) {
2180 PyObject *obj[2];
2181 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2182 return NULL;
2183 } else {
2184 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2185 if (sthis) {
2186 PySwigObject_append((PyObject*) sthis, obj[1]);
2187 } else {
2188 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2189 }
2190 return SWIG_Py_Void();
2191 }
2192 }
2193
2194 /* Create a new pointer object */
2195
2196 SWIGRUNTIME PyObject *
2197 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2198 if (!ptr) {
2199 return SWIG_Py_Void();
2200 } else {
2201 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2202 PyObject *robj = PySwigObject_New(ptr, type, own);
2203 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2204 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2205 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2206 if (inst) {
2207 Py_DECREF(robj);
2208 robj = inst;
2209 }
2210 }
2211 return robj;
2212 }
2213 }
2214
2215 /* Create a new packed object */
2216
2217 SWIGRUNTIMEINLINE PyObject *
2218 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2219 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2220 }
2221
2222 /* -----------------------------------------------------------------------------*
2223 * Get type list
2224 * -----------------------------------------------------------------------------*/
2225
2226 #ifdef SWIG_LINK_RUNTIME
2227 void *SWIG_ReturnGlobalTypeList(void *);
2228 #endif
2229
2230 SWIGRUNTIME swig_module_info *
2231 SWIG_Python_GetModule(void) {
2232 static void *type_pointer = (void *)0;
2233 /* first check if module already created */
2234 if (!type_pointer) {
2235 #ifdef SWIG_LINK_RUNTIME
2236 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2237 #else
2238 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2239 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2240 if (PyErr_Occurred()) {
2241 PyErr_Clear();
2242 type_pointer = (void *)0;
2243 }
2244 #endif
2245 }
2246 return (swig_module_info *) type_pointer;
2247 }
2248
2249 #if PY_MAJOR_VERSION < 2
2250 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2251 is copied out of Python/modsupport.c in python version 2.3.4 */
2252 SWIGINTERN int
2253 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2254 {
2255 PyObject *dict;
2256 if (!PyModule_Check(m)) {
2257 PyErr_SetString(PyExc_TypeError,
2258 "PyModule_AddObject() needs module as first arg");
2259 return SWIG_ERROR;
2260 }
2261 if (!o) {
2262 PyErr_SetString(PyExc_TypeError,
2263 "PyModule_AddObject() needs non-NULL value");
2264 return SWIG_ERROR;
2265 }
2266
2267 dict = PyModule_GetDict(m);
2268 if (dict == NULL) {
2269 /* Internal error -- modules must have a dict! */
2270 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2271 PyModule_GetName(m));
2272 return SWIG_ERROR;
2273 }
2274 if (PyDict_SetItemString(dict, name, o))
2275 return SWIG_ERROR;
2276 Py_DECREF(o);
2277 return SWIG_OK;
2278 }
2279 #endif
2280
2281 SWIGRUNTIME void
2282 SWIG_Python_DestroyModule(void *vptr)
2283 {
2284 swig_module_info *swig_module = (swig_module_info *) vptr;
2285 swig_type_info **types = swig_module->types;
2286 size_t i;
2287 for (i =0; i < swig_module->size; ++i) {
2288 swig_type_info *ty = types[i];
2289 if (ty->owndata) {
2290 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2291 if (data) PySwigClientData_Del(data);
2292 }
2293 }
2294 Py_DECREF(SWIG_This());
2295 }
2296
2297 SWIGRUNTIME void
2298 SWIG_Python_SetModule(swig_module_info *swig_module) {
2299 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2300
2301 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2302 swig_empty_runtime_method_table);
2303 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2304 if (pointer && module) {
2305 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2306 } else {
2307 Py_XDECREF(pointer);
2308 }
2309 }
2310
2311 /* The python cached type query */
2312 SWIGRUNTIME PyObject *
2313 SWIG_Python_TypeCache() {
2314 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2315 return cache;
2316 }
2317
2318 SWIGRUNTIME swig_type_info *
2319 SWIG_Python_TypeQuery(const char *type)
2320 {
2321 PyObject *cache = SWIG_Python_TypeCache();
2322 PyObject *key = PyString_FromString(type);
2323 PyObject *obj = PyDict_GetItem(cache, key);
2324 swig_type_info *descriptor;
2325 if (obj) {
2326 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2327 } else {
2328 swig_module_info *swig_module = SWIG_Python_GetModule();
2329 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2330 if (descriptor) {
2331 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2332 PyDict_SetItem(cache, key, obj);
2333 Py_DECREF(obj);
2334 }
2335 }
2336 Py_DECREF(key);
2337 return descriptor;
2338 }
2339
2340 /*
2341 For backward compatibility only
2342 */
2343 #define SWIG_POINTER_EXCEPTION 0
2344 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2345 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2346
2347 SWIGRUNTIME int
2348 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2349 {
2350 if (PyErr_Occurred()) {
2351 PyObject *type = 0;
2352 PyObject *value = 0;
2353 PyObject *traceback = 0;
2354 PyErr_Fetch(&type, &value, &traceback);
2355 if (value) {
2356 PyObject *old_str = PyObject_Str(value);
2357 Py_XINCREF(type);
2358 PyErr_Clear();
2359 if (infront) {
2360 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2361 } else {
2362 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2363 }
2364 Py_DECREF(old_str);
2365 }
2366 return 1;
2367 } else {
2368 return 0;
2369 }
2370 }
2371
2372 SWIGRUNTIME int
2373 SWIG_Python_ArgFail(int argnum)
2374 {
2375 if (PyErr_Occurred()) {
2376 /* add information about failing argument */
2377 char mesg[256];
2378 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2379 return SWIG_Python_AddErrMesg(mesg, 1);
2380 } else {
2381 return 0;
2382 }
2383 }
2384
2385 SWIGRUNTIMEINLINE const char *
2386 PySwigObject_GetDesc(PyObject *self)
2387 {
2388 PySwigObject *v = (PySwigObject *)self;
2389 swig_type_info *ty = v ? v->ty : 0;
2390 return ty ? ty->str : (char*)"";
2391 }
2392
2393 SWIGRUNTIME void
2394 SWIG_Python_TypeError(const char *type, PyObject *obj)
2395 {
2396 if (type) {
2397 #if defined(SWIG_COBJECT_TYPES)
2398 if (obj && PySwigObject_Check(obj)) {
2399 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2400 if (otype) {
2401 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2402 type, otype);
2403 return;
2404 }
2405 } else
2406 #endif
2407 {
2408 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2409 if (otype) {
2410 PyObject *str = PyObject_Str(obj);
2411 const char *cstr = str ? PyString_AsString(str) : 0;
2412 if (cstr) {
2413 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2414 type, otype, cstr);
2415 } else {
2416 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2417 type, otype);
2418 }
2419 Py_XDECREF(str);
2420 return;
2421 }
2422 }
2423 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2424 } else {
2425 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2426 }
2427 }
2428
2429
2430 /* Convert a pointer value, signal an exception on a type mismatch */
2431 SWIGRUNTIME void *
2432 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2433 void *result;
2434 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2435 PyErr_Clear();
2436 if (flags & SWIG_POINTER_EXCEPTION) {
2437 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2438 SWIG_Python_ArgFail(argnum);
2439 }
2440 }
2441 return result;
2442 }
2443
2444
2445 #ifdef __cplusplus
2446 #if 0
2447 { /* cc-mode */
2448 #endif
2449 }
2450 #endif
2451
2452
2453
2454 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2455
2456 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2457
2458
2459
2460 /* -------- TYPES TABLE (BEGIN) -------- */
2461
2462 #define SWIGTYPE_p_buffer swig_types[0]
2463 #define SWIGTYPE_p_char swig_types[1]
2464 #define SWIGTYPE_p_form_ops_t swig_types[2]
2465 #define SWIGTYPE_p_int swig_types[3]
2466 #define SWIGTYPE_p_long swig_types[4]
2467 #define SWIGTYPE_p_unsigned_char swig_types[5]
2468 #define SWIGTYPE_p_unsigned_int swig_types[6]
2469 #define SWIGTYPE_p_unsigned_long swig_types[7]
2470 #define SWIGTYPE_p_wxANIHandler swig_types[8]
2471 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[9]
2472 #define SWIGTYPE_p_wxAcceleratorTable swig_types[10]
2473 #define SWIGTYPE_p_wxActivateEvent swig_types[11]
2474 #define SWIGTYPE_p_wxAppTraits swig_types[12]
2475 #define SWIGTYPE_p_wxArrayString swig_types[13]
2476 #define SWIGTYPE_p_wxBMPHandler swig_types[14]
2477 #define SWIGTYPE_p_wxBitmap swig_types[15]
2478 #define SWIGTYPE_p_wxBoxSizer swig_types[16]
2479 #define SWIGTYPE_p_wxButton swig_types[17]
2480 #define SWIGTYPE_p_wxCURHandler swig_types[18]
2481 #define SWIGTYPE_p_wxCaret swig_types[19]
2482 #define SWIGTYPE_p_wxChildFocusEvent swig_types[20]
2483 #define SWIGTYPE_p_wxCloseEvent swig_types[21]
2484 #define SWIGTYPE_p_wxColour swig_types[22]
2485 #define SWIGTYPE_p_wxCommandEvent swig_types[23]
2486 #define SWIGTYPE_p_wxContextMenuEvent swig_types[24]
2487 #define SWIGTYPE_p_wxControl swig_types[25]
2488 #define SWIGTYPE_p_wxControlWithItems swig_types[26]
2489 #define SWIGTYPE_p_wxCursor swig_types[27]
2490 #define SWIGTYPE_p_wxDC swig_types[28]
2491 #define SWIGTYPE_p_wxDateEvent swig_types[29]
2492 #define SWIGTYPE_p_wxDateTime swig_types[30]
2493 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[31]
2494 #define SWIGTYPE_p_wxDropFilesEvent swig_types[32]
2495 #define SWIGTYPE_p_wxDuplexMode swig_types[33]
2496 #define SWIGTYPE_p_wxEraseEvent swig_types[34]
2497 #define SWIGTYPE_p_wxEvent swig_types[35]
2498 #define SWIGTYPE_p_wxEventLoop swig_types[36]
2499 #define SWIGTYPE_p_wxEventLoopActivator swig_types[37]
2500 #define SWIGTYPE_p_wxEvtHandler swig_types[38]
2501 #define SWIGTYPE_p_wxFSFile swig_types[39]
2502 #define SWIGTYPE_p_wxFileSystem swig_types[40]
2503 #define SWIGTYPE_p_wxFileSystemHandler swig_types[41]
2504 #define SWIGTYPE_p_wxFlexGridSizer swig_types[42]
2505 #define SWIGTYPE_p_wxFocusEvent swig_types[43]
2506 #define SWIGTYPE_p_wxFont swig_types[44]
2507 #define SWIGTYPE_p_wxFrame swig_types[45]
2508 #define SWIGTYPE_p_wxGBPosition swig_types[46]
2509 #define SWIGTYPE_p_wxGBSizerItem swig_types[47]
2510 #define SWIGTYPE_p_wxGBSpan swig_types[48]
2511 #define SWIGTYPE_p_wxGIFHandler swig_types[49]
2512 #define SWIGTYPE_p_wxGridBagSizer swig_types[50]
2513 #define SWIGTYPE_p_wxGridSizer swig_types[51]
2514 #define SWIGTYPE_p_wxICOHandler swig_types[52]
2515 #define SWIGTYPE_p_wxIconizeEvent swig_types[53]
2516 #define SWIGTYPE_p_wxIdleEvent swig_types[54]
2517 #define SWIGTYPE_p_wxImage swig_types[55]
2518 #define SWIGTYPE_p_wxImageHandler swig_types[56]
2519 #define SWIGTYPE_p_wxImageHistogram swig_types[57]
2520 #define SWIGTYPE_p_wxImage_HSVValue swig_types[58]
2521 #define SWIGTYPE_p_wxImage_RGBValue swig_types[59]
2522 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[60]
2523 #define SWIGTYPE_p_wxInitDialogEvent swig_types[61]
2524 #define SWIGTYPE_p_wxInputStream swig_types[62]
2525 #define SWIGTYPE_p_wxInternetFSHandler swig_types[63]
2526 #define SWIGTYPE_p_wxItemContainer swig_types[64]
2527 #define SWIGTYPE_p_wxJPEGHandler swig_types[65]
2528 #define SWIGTYPE_p_wxKeyEvent swig_types[66]
2529 #define SWIGTYPE_p_wxLayoutConstraints swig_types[67]
2530 #define SWIGTYPE_p_wxMaximizeEvent swig_types[68]
2531 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[69]
2532 #define SWIGTYPE_p_wxMenu swig_types[70]
2533 #define SWIGTYPE_p_wxMenuBar swig_types[71]
2534 #define SWIGTYPE_p_wxMenuBarBase swig_types[72]
2535 #define SWIGTYPE_p_wxMenuEvent swig_types[73]
2536 #define SWIGTYPE_p_wxMenuItem swig_types[74]
2537 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[75]
2538 #define SWIGTYPE_p_wxMouseEvent swig_types[76]
2539 #define SWIGTYPE_p_wxMoveEvent swig_types[77]
2540 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[78]
2541 #define SWIGTYPE_p_wxNcPaintEvent swig_types[79]
2542 #define SWIGTYPE_p_wxNotifyEvent swig_types[80]
2543 #define SWIGTYPE_p_wxObject swig_types[81]
2544 #define SWIGTYPE_p_wxOutputStream swig_types[82]
2545 #define SWIGTYPE_p_wxPCXHandler swig_types[83]
2546 #define SWIGTYPE_p_wxPNGHandler swig_types[84]
2547 #define SWIGTYPE_p_wxPNMHandler swig_types[85]
2548 #define SWIGTYPE_p_wxPaintEvent swig_types[86]
2549 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[87]
2550 #define SWIGTYPE_p_wxPaperSize swig_types[88]
2551 #define SWIGTYPE_p_wxPoint swig_types[89]
2552 #define SWIGTYPE_p_wxPoint2D swig_types[90]
2553 #define SWIGTYPE_p_wxPropagateOnce swig_types[91]
2554 #define SWIGTYPE_p_wxPropagationDisabler swig_types[92]
2555 #define SWIGTYPE_p_wxPyApp swig_types[93]
2556 #define SWIGTYPE_p_wxPyCommandEvent swig_types[94]
2557 #define SWIGTYPE_p_wxPyDropTarget swig_types[95]
2558 #define SWIGTYPE_p_wxPyEvent swig_types[96]
2559 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[97]
2560 #define SWIGTYPE_p_wxPyImageHandler swig_types[98]
2561 #define SWIGTYPE_p_wxPyInputStream swig_types[99]
2562 #define SWIGTYPE_p_wxPySizer swig_types[100]
2563 #define SWIGTYPE_p_wxPyValidator swig_types[101]
2564 #define SWIGTYPE_p_wxQuantize swig_types[102]
2565 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[103]
2566 #define SWIGTYPE_p_wxRealPoint swig_types[104]
2567 #define SWIGTYPE_p_wxRect swig_types[105]
2568 #define SWIGTYPE_p_wxRegion swig_types[106]
2569 #define SWIGTYPE_p_wxScrollEvent swig_types[107]
2570 #define SWIGTYPE_p_wxScrollWinEvent swig_types[108]
2571 #define SWIGTYPE_p_wxSetCursorEvent swig_types[109]
2572 #define SWIGTYPE_p_wxShowEvent swig_types[110]
2573 #define SWIGTYPE_p_wxSize swig_types[111]
2574 #define SWIGTYPE_p_wxSizeEvent swig_types[112]
2575 #define SWIGTYPE_p_wxSizer swig_types[113]
2576 #define SWIGTYPE_p_wxSizerItem swig_types[114]
2577 #define SWIGTYPE_p_wxStaticBox swig_types[115]
2578 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[116]
2579 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[117]
2580 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[118]
2581 #define SWIGTYPE_p_wxTIFFHandler swig_types[119]
2582 #define SWIGTYPE_p_wxToolTip swig_types[120]
2583 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[121]
2584 #define SWIGTYPE_p_wxValidator swig_types[122]
2585 #define SWIGTYPE_p_wxVisualAttributes swig_types[123]
2586 #define SWIGTYPE_p_wxWindow swig_types[124]
2587 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[125]
2588 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[126]
2589 #define SWIGTYPE_p_wxXPMHandler swig_types[127]
2590 #define SWIGTYPE_p_wxZipFSHandler swig_types[128]
2591 static swig_type_info *swig_types[130];
2592 static swig_module_info swig_module = {swig_types, 129, 0, 0, 0, 0};
2593 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2594 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2595
2596 /* -------- TYPES TABLE (END) -------- */
2597
2598 #if (PY_VERSION_HEX <= 0x02000000)
2599 # if !defined(SWIG_PYTHON_CLASSIC)
2600 # error "This python version requires to use swig with the '-classic' option"
2601 # endif
2602 #endif
2603 #if (PY_VERSION_HEX <= 0x02020000)
2604 # error "This python version requires to use swig with the '-nomodern' option"
2605 #endif
2606 #if (PY_VERSION_HEX <= 0x02020000)
2607 # error "This python version requires to use swig with the '-nomodernargs' option"
2608 #endif
2609 #ifndef METH_O
2610 # error "This python version requires to use swig with the '-nofastunpack' option"
2611 #endif
2612
2613 /*-----------------------------------------------
2614 @(target):= _core_.so
2615 ------------------------------------------------*/
2616 #define SWIG_init init_core_
2617
2618 #define SWIG_name "_core_"
2619
2620 #define SWIGVERSION 0x010329
2621
2622
2623 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2624 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2625
2626
2627 #include <stdexcept>
2628
2629
2630 namespace swig {
2631 class PyObject_ptr {
2632 protected:
2633 PyObject *_obj;
2634
2635 public:
2636 PyObject_ptr() :_obj(0)
2637 {
2638 }
2639
2640 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2641 {
2642 Py_XINCREF(_obj);
2643 }
2644
2645 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2646 {
2647 if (initial_ref) Py_XINCREF(_obj);
2648 }
2649
2650 PyObject_ptr & operator=(const PyObject_ptr& item)
2651 {
2652 Py_XINCREF(item._obj);
2653 Py_XDECREF(_obj);
2654 _obj = item._obj;
2655 return *this;
2656 }
2657
2658 ~PyObject_ptr()
2659 {
2660 Py_XDECREF(_obj);
2661 }
2662
2663 operator PyObject *() const
2664 {
2665 return _obj;
2666 }
2667
2668 PyObject *operator->() const
2669 {
2670 return _obj;
2671 }
2672 };
2673 }
2674
2675
2676 namespace swig {
2677 struct PyObject_var : PyObject_ptr {
2678 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2679
2680 PyObject_var & operator = (PyObject* obj)
2681 {
2682 Py_XDECREF(_obj);
2683 _obj = obj;
2684 return *this;
2685 }
2686 };
2687 }
2688
2689
2690 #include "wx/wxPython/wxPython_int.h"
2691 #include "wx/wxPython/pyclasses.h"
2692
2693
2694 #ifndef wxPyUSE_EXPORT
2695 // Helper functions for dealing with SWIG objects and such. These are
2696 // located here so they know about the SWIG types and functions declared
2697 // in the wrapper code.
2698
2699 #include <wx/hashmap.h>
2700 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
2701
2702
2703 // Maintains a hashmap of className to swig_type_info pointers. Given the
2704 // name of a class either looks up the type info in the cache, or scans the
2705 // SWIG tables for it.
2706 extern PyObject* wxPyPtrTypeMap;
2707 static
2708 swig_type_info* wxPyFindSwigType(const wxChar* className) {
2709
2710 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
2711
2712 if (typeInfoCache == NULL)
2713 typeInfoCache = new wxPyTypeInfoHashMap;
2714
2715 wxString name(className);
2716 swig_type_info* swigType = (*typeInfoCache)[name];
2717
2718 if (! swigType) {
2719 // it wasn't in the cache, so look it up from SWIG
2720 name.Append(wxT(" *"));
2721 swigType = SWIG_TypeQuery(name.mb_str());
2722
2723 // if it still wasn't found, try looking for a mapped name
2724 if (!swigType) {
2725 PyObject* item;
2726 name = className;
2727
2728 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
2729 (char*)(const char*)name.mbc_str())) != NULL) {
2730 name = wxString(PyString_AsString(item), *wxConvCurrent);
2731 name.Append(wxT(" *"));
2732 swigType = SWIG_TypeQuery(name.mb_str());
2733 }
2734 }
2735 if (swigType) {
2736 // and add it to the map if found
2737 (*typeInfoCache)[className] = swigType;
2738 }
2739 }
2740 return swigType;
2741 }
2742
2743
2744 // Check if a class name is a type known to SWIG
2745 bool wxPyCheckSwigType(const wxChar* className) {
2746
2747 swig_type_info* swigType = wxPyFindSwigType(className);
2748 return swigType != NULL;
2749 }
2750
2751
2752 // Given a pointer to a C++ object and a class name, construct a Python proxy
2753 // object for it.
2754 PyObject* wxPyConstructObject(void* ptr,
2755 const wxChar* className,
2756 int setThisOwn) {
2757
2758 swig_type_info* swigType = wxPyFindSwigType(className);
2759 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
2760
2761 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
2762 }
2763
2764
2765 // Extract a pointer to the wrapped C++ object from a Python proxy object.
2766 // Ensures that the proxy object is of the specified (or derived) type. If
2767 // not able to perform the conversion then a Python exception is set and the
2768 // error should be handled properly in the caller. Returns True on success.
2769 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
2770 const wxChar* className) {
2771
2772 swig_type_info* swigType = wxPyFindSwigType(className);
2773 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
2774
2775 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
2776 }
2777
2778
2779
2780 // Make a SWIGified pointer object suitable for a .this attribute
2781 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
2782
2783 PyObject* robj = NULL;
2784
2785 swig_type_info* swigType = wxPyFindSwigType(className);
2786 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyMakeSwigPtr"));
2787
2788 robj = PySwigObject_New(ptr, swigType, 0);
2789 return robj;
2790 }
2791
2792
2793 // Python's PyInstance_Check does not return True for instances of new-style
2794 // classes. This should get close enough for both new and old classes but I
2795 // should re-evaluate the need for doing instance checks...
2796 bool wxPyInstance_Check(PyObject* obj) {
2797 return PyObject_HasAttrString(obj, "__class__") != 0;
2798 }
2799
2800
2801 // This one checks if the object is an instance of a SWIG proxy class (it has
2802 // a .this attribute, and the .this attribute is a PySwigObject.)
2803 bool wxPySwigInstance_Check(PyObject* obj) {
2804 static PyObject* this_str = NULL;
2805 if (this_str == NULL)
2806 this_str = PyString_FromString("this");
2807
2808 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
2809 if (this_attr) {
2810 bool retval = (PySwigObject_Check(this_attr) != 0);
2811 Py_DECREF(this_attr);
2812 return retval;
2813 }
2814
2815 PyErr_Clear();
2816 return false;
2817 }
2818
2819
2820 // Export a C API in a struct. Other modules will be able to load this from
2821 // the wx._core_ module and will then have safe access to these functions,
2822 // even if they are located in another shared library.
2823 static wxPyCoreAPI API = {
2824
2825 wxPyCheckSwigType,
2826 wxPyConstructObject,
2827 wxPyConvertSwigPtr,
2828 wxPyMakeSwigPtr,
2829
2830 wxPyBeginAllowThreads,
2831 wxPyEndAllowThreads,
2832 wxPyBeginBlockThreads,
2833 wxPyEndBlockThreads,
2834
2835 wxPy_ConvertList,
2836
2837 wxString_in_helper,
2838 Py2wxString,
2839 wx2PyString,
2840
2841 byte_LIST_helper,
2842 int_LIST_helper,
2843 long_LIST_helper,
2844 string_LIST_helper,
2845 wxPoint_LIST_helper,
2846 wxBitmap_LIST_helper,
2847 wxString_LIST_helper,
2848 wxAcceleratorEntry_LIST_helper,
2849
2850 wxSize_helper,
2851 wxPoint_helper,
2852 wxRealPoint_helper,
2853 wxRect_helper,
2854 wxColour_helper,
2855 wxPoint2D_helper,
2856
2857 wxPySimple_typecheck,
2858 wxColour_typecheck,
2859
2860 wxPyCBH_setCallbackInfo,
2861 wxPyCBH_findCallback,
2862 wxPyCBH_callCallback,
2863 wxPyCBH_callCallbackObj,
2864 wxPyCBH_delete,
2865
2866 wxPyMake_wxObject,
2867 wxPyMake_wxSizer,
2868 wxPyPtrTypeMap_Add,
2869 wxPy2int_seq_helper,
2870 wxPy4int_seq_helper,
2871 wxArrayString2PyList_helper,
2872 wxArrayInt2PyList_helper,
2873
2874 wxPyClientData_dtor,
2875 wxPyUserData_dtor,
2876 wxPyOORClientData_dtor,
2877
2878 wxPyCBInputStream_create,
2879 wxPyCBInputStream_copy,
2880
2881 wxPyInstance_Check,
2882 wxPySwigInstance_Check,
2883
2884 wxPyCheckForApp
2885
2886 };
2887
2888 #endif
2889
2890
2891 #if !WXWIN_COMPATIBILITY_2_4
2892 #define wxHIDE_READONLY 0
2893 #endif
2894
2895
2896 #define SWIG_From_long PyInt_FromLong
2897
2898
2899 SWIGINTERNINLINE PyObject *
2900 SWIG_From_int (int value)
2901 {
2902 return SWIG_From_long (value);
2903 }
2904
2905 static const wxString wxPyEmptyString(wxEmptyString);
2906 SWIGINTERN wxString wxObject_GetClassName(wxObject *self){
2907 return self->GetClassInfo()->GetClassName();
2908 }
2909 SWIGINTERN void wxObject_Destroy(wxObject *self){
2910 delete self;
2911 }
2912
2913 #ifndef __WXMAC__
2914 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
2915 #endif
2916
2917
2918 #include <limits.h>
2919 #ifndef LLONG_MIN
2920 # define LLONG_MIN LONG_LONG_MIN
2921 #endif
2922 #ifndef LLONG_MAX
2923 # define LLONG_MAX LONG_LONG_MAX
2924 #endif
2925 #ifndef ULLONG_MAX
2926 # define ULLONG_MAX ULONG_LONG_MAX
2927 #endif
2928
2929
2930 SWIGINTERN int
2931 SWIG_AsVal_long (PyObject* obj, long* val)
2932 {
2933 if (PyNumber_Check(obj)) {
2934 if (val) *val = PyInt_AsLong(obj);
2935 return SWIG_OK;
2936 }
2937 return SWIG_TypeError;
2938 }
2939
2940
2941 SWIGINTERN int
2942 SWIG_AsVal_int (PyObject * obj, int *val)
2943 {
2944 long v;
2945 int res = SWIG_AsVal_long (obj, &v);
2946 if (SWIG_IsOK(res)) {
2947 if ((v < INT_MIN || v > INT_MAX)) {
2948 return SWIG_OverflowError;
2949 } else {
2950 if (val) *val = static_cast< int >(v);
2951 }
2952 }
2953 return res;
2954 }
2955
2956 SWIGINTERN bool wxSize___eq__(wxSize *self,PyObject *other){
2957 wxSize temp, *obj = &temp;
2958 if ( other == Py_None ) return false;
2959 if ( ! wxSize_helper(other, &obj) ) {
2960 PyErr_Clear();
2961 return false;
2962 }
2963 return self->operator==(*obj);
2964 }
2965 SWIGINTERN bool wxSize___ne__(wxSize *self,PyObject *other){
2966 wxSize temp, *obj = &temp;
2967 if ( other == Py_None ) return true;
2968 if ( ! wxSize_helper(other, &obj)) {
2969 PyErr_Clear();
2970 return true;
2971 }
2972 return self->operator!=(*obj);
2973 }
2974 SWIGINTERN PyObject *wxSize_Get(wxSize *self){
2975 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2976 PyObject* tup = PyTuple_New(2);
2977 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
2978 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
2979 wxPyEndBlockThreads(blocked);
2980 return tup;
2981 }
2982
2983 SWIGINTERN int
2984 SWIG_AsVal_double (PyObject *obj, double* val)
2985 {
2986 if (PyNumber_Check(obj)) {
2987 if (val) *val = PyFloat_AsDouble(obj);
2988 return SWIG_OK;
2989 }
2990 return SWIG_TypeError;
2991 }
2992
2993
2994 #define SWIG_From_double PyFloat_FromDouble
2995
2996 SWIGINTERN bool wxRealPoint___eq__(wxRealPoint *self,PyObject *other){
2997 wxRealPoint temp, *obj = &temp;
2998 if ( other == Py_None ) return false;
2999 if ( ! wxRealPoint_helper(other, &obj) ) {
3000 PyErr_Clear();
3001 return false;
3002 }
3003 return self->operator==(*obj);
3004 }
3005 SWIGINTERN bool wxRealPoint___ne__(wxRealPoint *self,PyObject *other){
3006 wxRealPoint temp, *obj = &temp;
3007 if ( other == Py_None ) return true;
3008 if ( ! wxRealPoint_helper(other, &obj)) {
3009 PyErr_Clear();
3010 return true;
3011 }
3012 return self->operator!=(*obj);
3013 }
3014 SWIGINTERN void wxRealPoint_Set(wxRealPoint *self,double x,double y){
3015 self->x = x;
3016 self->y = y;
3017 }
3018 SWIGINTERN PyObject *wxRealPoint_Get(wxRealPoint *self){
3019 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3020 PyObject* tup = PyTuple_New(2);
3021 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
3022 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
3023 wxPyEndBlockThreads(blocked);
3024 return tup;
3025 }
3026 SWIGINTERN bool wxPoint___eq__(wxPoint *self,PyObject *other){
3027 wxPoint temp, *obj = &temp;
3028 if ( other == Py_None ) return false;
3029 if ( ! wxPoint_helper(other, &obj) ) {
3030 PyErr_Clear();
3031 return false;
3032 }
3033 return self->operator==(*obj);
3034 }
3035 SWIGINTERN bool wxPoint___ne__(wxPoint *self,PyObject *other){
3036 wxPoint temp, *obj = &temp;
3037 if ( other == Py_None ) return true;
3038 if ( ! wxPoint_helper(other, &obj)) {
3039 PyErr_Clear();
3040 return true;
3041 }
3042 return self->operator!=(*obj);
3043 }
3044 SWIGINTERN void wxPoint_Set(wxPoint *self,long x,long y){
3045 self->x = x;
3046 self->y = y;
3047 }
3048 SWIGINTERN PyObject *wxPoint_Get(wxPoint *self){
3049 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3050 PyObject* tup = PyTuple_New(2);
3051 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3052 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3053 wxPyEndBlockThreads(blocked);
3054 return tup;
3055 }
3056 SWIGINTERN bool wxRect___eq__(wxRect *self,PyObject *other){
3057 wxRect temp, *obj = &temp;
3058 if ( other == Py_None ) return false;
3059 if ( ! wxRect_helper(other, &obj) ) {
3060 PyErr_Clear();
3061 return false;
3062 }
3063 return self->operator==(*obj);
3064 }
3065 SWIGINTERN bool wxRect___ne__(wxRect *self,PyObject *other){
3066 wxRect temp, *obj = &temp;
3067 if ( other == Py_None ) return true;
3068 if ( ! wxRect_helper(other, &obj)) {
3069 PyErr_Clear();
3070 return true;
3071 }
3072 return self->operator!=(*obj);
3073 }
3074 SWIGINTERN void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
3075 self->x = x;
3076 self->y = y;
3077 self->width = width;
3078 self->height = height;
3079 }
3080 SWIGINTERN PyObject *wxRect_Get(wxRect *self){
3081 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3082 PyObject* tup = PyTuple_New(4);
3083 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3084 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3085 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
3086 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
3087 wxPyEndBlockThreads(blocked);
3088 return tup;
3089 }
3090
3091 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
3092 wxRegion reg1(*r1);
3093 wxRegion reg2(*r2);
3094 wxRect dest(0,0,0,0);
3095 PyObject* obj;
3096
3097 reg1.Intersect(reg2);
3098 dest = reg1.GetBox();
3099
3100 if (dest != wxRect(0,0,0,0)) {
3101 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3102 wxRect* newRect = new wxRect(dest);
3103 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
3104 wxPyEndBlockThreads(blocked);
3105 return obj;
3106 }
3107 Py_INCREF(Py_None);
3108 return Py_None;
3109 }
3110
3111 SWIGINTERN bool wxPoint2D___eq__(wxPoint2D *self,PyObject *other){
3112 wxPoint2D temp, *obj = &temp;
3113 if ( other == Py_None ) return false;
3114 if ( ! wxPoint2D_helper(other, &obj) ) {
3115 PyErr_Clear();
3116 return false;
3117 }
3118 return self->operator==(*obj);
3119 }
3120 SWIGINTERN bool wxPoint2D___ne__(wxPoint2D *self,PyObject *other){
3121 wxPoint2D temp, *obj = &temp;
3122 if ( other == Py_None ) return true;
3123 if ( ! wxPoint2D_helper(other, &obj)) {
3124 PyErr_Clear();
3125 return true;
3126 }
3127 return self->operator!=(*obj);
3128 }
3129 SWIGINTERN void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
3130 self->m_x = x;
3131 self->m_y = y;
3132 }
3133 SWIGINTERN PyObject *wxPoint2D_Get(wxPoint2D *self){
3134 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3135 PyObject* tup = PyTuple_New(2);
3136 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3137 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3138 wxPyEndBlockThreads(blocked);
3139 return tup;
3140 }
3141
3142 #include "wx/wxPython/pyistream.h"
3143
3144 SWIGINTERN wxPyInputStream *new_wxPyInputStream(PyObject *p){
3145 wxInputStream* wxis = wxPyCBInputStream::create(p);
3146 if (wxis)
3147 return new wxPyInputStream(wxis);
3148 else
3149 return NULL;
3150 }
3151
3152 SWIGINTERN swig_type_info*
3153 SWIG_pchar_descriptor()
3154 {
3155 static int init = 0;
3156 static swig_type_info* info = 0;
3157 if (!init) {
3158 info = SWIG_TypeQuery("_p_char");
3159 init = 1;
3160 }
3161 return info;
3162 }
3163
3164
3165 SWIGINTERNINLINE PyObject *
3166 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3167 {
3168 if (carray) {
3169 if (size > INT_MAX) {
3170 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3171 return pchar_descriptor ?
3172 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3173 } else {
3174 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3175 }
3176 } else {
3177 return SWIG_Py_Void();
3178 }
3179 }
3180
3181
3182 SWIGINTERNINLINE PyObject *
3183 SWIG_From_char (char c)
3184 {
3185 return SWIG_FromCharPtrAndSize(&c,1);
3186 }
3187
3188
3189 SWIGINTERNINLINE PyObject*
3190 SWIG_From_unsigned_SS_long (unsigned long value)
3191 {
3192 return (value > LONG_MAX) ?
3193 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3194 }
3195
3196
3197 SWIGINTERNINLINE PyObject *
3198 SWIG_From_size_t (size_t value)
3199 {
3200 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3201 }
3202
3203
3204 SWIGINTERN int
3205 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3206 {
3207 if (PyString_Check(obj)) {
3208 char *cstr; int len;
3209 PyString_AsStringAndSize(obj, &cstr, &len);
3210 if (cptr) {
3211 if (alloc) {
3212 /*
3213 In python the user should not be able to modify the inner
3214 string representation. To warranty that, if you define
3215 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3216 buffer is always returned.
3217
3218 The default behavior is just to return the pointer value,
3219 so, be careful.
3220 */
3221 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3222 if (*alloc != SWIG_OLDOBJ)
3223 #else
3224 if (*alloc == SWIG_NEWOBJ)
3225 #endif
3226 {
3227 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3228 *alloc = SWIG_NEWOBJ;
3229 }
3230 else {
3231 *cptr = cstr;
3232 *alloc = SWIG_OLDOBJ;
3233 }
3234 } else {
3235 *cptr = PyString_AsString(obj);
3236 }
3237 }
3238 if (psize) *psize = len + 1;
3239 return SWIG_OK;
3240 } else {
3241 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3242 if (pchar_descriptor) {
3243 void* vptr = 0;
3244 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3245 if (cptr) *cptr = (char *) vptr;
3246 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3247 if (alloc) *alloc = SWIG_OLDOBJ;
3248 return SWIG_OK;
3249 }
3250 }
3251 }
3252 return SWIG_TypeError;
3253 }
3254
3255
3256 SWIGINTERN int
3257 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3258 {
3259 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3260 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3261 if (SWIG_IsOK(res)) {
3262 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3263 if (csize <= size) {
3264 if (val) {
3265 if (csize) memcpy(val, cptr, csize*sizeof(char));
3266 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3267 }
3268 if (alloc == SWIG_NEWOBJ) {
3269 delete[] cptr;
3270 res = SWIG_DelNewMask(res);
3271 }
3272 return res;
3273 }
3274 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3275 }
3276 return SWIG_TypeError;
3277 }
3278
3279
3280 SWIGINTERN int
3281 SWIG_AsVal_char (PyObject * obj, char *val)
3282 {
3283 int res = SWIG_AsCharArray(obj, val, 1);
3284 if (!SWIG_IsOK(res)) {
3285 long v;
3286 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3287 if (SWIG_IsOK(res)) {
3288 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3289 if (val) *val = static_cast< char >(v);
3290 } else {
3291 res = SWIG_OverflowError;
3292 }
3293 }
3294 }
3295 return res;
3296 }
3297
3298 SWIGINTERN void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
3299 // We use only strings for the streams, not unicode
3300 PyObject* str = PyObject_Str(obj);
3301 if (! str) {
3302 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
3303 return;
3304 }
3305 self->Write(PyString_AS_STRING(str),
3306 PyString_GET_SIZE(str));
3307 Py_DECREF(str);
3308 }
3309
3310 #include "wx/wxPython/pyistream.h"
3311
3312
3313 class wxPyFileSystemHandler : public wxFileSystemHandler
3314 {
3315 public:
3316 wxPyFileSystemHandler() : wxFileSystemHandler() {}
3317
3318 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
3319 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
3320 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
3321 DEC_PYCALLBACK_STRING__pure(FindNext);
3322
3323 wxString GetProtocol(const wxString& location) {
3324 return wxFileSystemHandler::GetProtocol(location);
3325 }
3326
3327 wxString GetLeftLocation(const wxString& location) {
3328 return wxFileSystemHandler::GetLeftLocation(location);
3329 }
3330
3331 wxString GetAnchor(const wxString& location) {
3332 return wxFileSystemHandler::GetAnchor(location);
3333 }
3334
3335 wxString GetRightLocation(const wxString& location) {
3336 return wxFileSystemHandler::GetRightLocation(location);
3337 }
3338
3339 wxString GetMimeTypeFromExt(const wxString& location) {
3340 return wxFileSystemHandler::GetMimeTypeFromExt(location);
3341 }
3342
3343 PYPRIVATE;
3344 };
3345
3346
3347 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
3348 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
3349 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
3350 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
3351
3352
3353 SWIGINTERN int
3354 SWIG_AsVal_bool (PyObject *obj, bool *val)
3355 {
3356 if (obj == Py_True) {
3357 if (val) *val = true;
3358 return SWIG_OK;
3359 } else if (obj == Py_False) {
3360 if (val) *val = false;
3361 return SWIG_OK;
3362 } else {
3363 long v = 0;
3364 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3365 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3366 return res;
3367 }
3368 }
3369
3370 SWIGINTERN wxString wxFileSystem_URLToFileName(wxString const &url){
3371 wxFileName fname = wxFileSystem::URLToFileName(url);
3372 return fname.GetFullPath();
3373 }
3374
3375 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
3376 wxImage& image,
3377 long type) {
3378 wxMemoryFSHandler::AddFile(filename, image, type);
3379 }
3380
3381 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
3382 const wxBitmap& bitmap,
3383 long type) {
3384 wxMemoryFSHandler::AddFile(filename, bitmap, type);
3385 }
3386
3387 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
3388 PyObject* data) {
3389 if (! PyString_Check(data)) {
3390 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
3391 "Expected string object"));
3392 return;
3393 }
3394
3395 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3396 void* ptr = (void*)PyString_AsString(data);
3397 size_t size = PyString_Size(data);
3398 wxPyEndBlockThreads(blocked);
3399
3400 wxMemoryFSHandler::AddFile(filename, ptr, size);
3401 }
3402
3403
3404 #include "wx/wxPython/pyistream.h"
3405
3406
3407 SWIGINTERN int
3408 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3409 {
3410 long v = 0;
3411 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3412 return SWIG_TypeError;
3413 }
3414 else if (val)
3415 *val = (unsigned long)v;
3416 return SWIG_OK;
3417 }
3418
3419
3420 SWIGINTERN int
3421 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
3422 {
3423 unsigned long v;
3424 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3425 if (SWIG_IsOK(res)) {
3426 if ((v > UCHAR_MAX)) {
3427 return SWIG_OverflowError;
3428 } else {
3429 if (val) *val = static_cast< unsigned char >(v);
3430 }
3431 }
3432 return res;
3433 }
3434
3435
3436 SWIGINTERNINLINE PyObject *
3437 SWIG_From_unsigned_SS_char (unsigned char value)
3438 {
3439 return SWIG_From_unsigned_SS_long (value);
3440 }
3441
3442 SWIGINTERN unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
3443 wxImageHistogramEntry e = (*self)[key];
3444 return e.value;
3445 }
3446 SWIGINTERN unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
3447 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
3448 wxImageHistogramEntry e = (*self)[key];
3449 return e.value;
3450 }
3451 SWIGINTERN unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
3452 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
3453 colour.Green(),
3454 colour.Blue());
3455 wxImageHistogramEntry e = (*self)[key];
3456 return e.value;
3457 }
3458
3459 typedef unsigned char* buffer;
3460
3461
3462 // Pull the nested class out to the top level for SWIG's sake
3463 #define wxImage_RGBValue wxImage::RGBValue
3464 #define wxImage_HSVValue wxImage::HSVValue
3465
3466 SWIGINTERN wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
3467 if (width > 0 && height > 0)
3468 return new wxImage(width, height, clear);
3469 else
3470 return new wxImage;
3471 }
3472 SWIGINTERN wxImage *new_wxImage(wxBitmap const &bitmap){
3473 return new wxImage(bitmap.ConvertToImage());
3474 }
3475 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
3476 if (DATASIZE != width*height*3) {
3477 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3478 return NULL;
3479 }
3480
3481 // Copy the source data so the wxImage can clean it up later
3482 buffer copy = (buffer)malloc(DATASIZE);
3483 if (copy == NULL) {
3484 wxPyBLOCK_THREADS(PyErr_NoMemory());
3485 return NULL;
3486 }
3487 memcpy(copy, data, DATASIZE);
3488 return new wxImage(width, height, copy, false);
3489 }
3490 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
3491 if (DATASIZE != width*height*3) {
3492 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3493 return NULL;
3494 }
3495 if (ALPHASIZE != width*height) {
3496 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3497 return NULL;
3498 }
3499
3500 // Copy the source data so the wxImage can clean it up later
3501 buffer dcopy = (buffer)malloc(DATASIZE);
3502 if (dcopy == NULL) {
3503 wxPyBLOCK_THREADS(PyErr_NoMemory());
3504 return NULL;
3505 }
3506 memcpy(dcopy, data, DATASIZE);
3507
3508 buffer acopy = (buffer)malloc(ALPHASIZE);
3509 if (acopy == NULL) {
3510 wxPyBLOCK_THREADS(PyErr_NoMemory());
3511 return NULL;
3512 }
3513 memcpy(acopy, alpha, ALPHASIZE);
3514
3515 return new wxImage(width, height, dcopy, acopy, false);
3516 }
3517 SWIGINTERN wxSize wxImage_GetSize(wxImage *self){
3518 wxSize size(self->GetWidth(), self->GetHeight());
3519 return size;
3520 }
3521 SWIGINTERN PyObject *wxImage_GetData(wxImage *self){
3522 buffer data = self->GetData();
3523 int len = self->GetWidth() * self->GetHeight() * 3;
3524 PyObject* rv;
3525 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
3526 return rv;
3527 }
3528 SWIGINTERN void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
3529 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3530 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3531 return;
3532 }
3533 buffer copy = (buffer)malloc(DATASIZE);
3534 if (copy == NULL) {
3535 wxPyBLOCK_THREADS(PyErr_NoMemory());
3536 return;
3537 }
3538 memcpy(copy, data, DATASIZE);
3539 self->SetData(copy, false);
3540 // wxImage takes ownership of copy...
3541 }
3542 SWIGINTERN PyObject *wxImage_GetDataBuffer(wxImage *self){
3543 buffer data = self->GetData();
3544 int len = self->GetWidth() * self->GetHeight() * 3;
3545 PyObject* rv;
3546 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3547 return rv;
3548 }
3549 SWIGINTERN void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
3550 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3551 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3552 return;
3553 }
3554 self->SetData(data, true);
3555 }
3556 SWIGINTERN PyObject *wxImage_GetAlphaData(wxImage *self){
3557 buffer data = self->GetAlpha();
3558 if (! data) {
3559 RETURN_NONE();
3560 } else {
3561 int len = self->GetWidth() * self->GetHeight();
3562 PyObject* rv;
3563 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
3564 return rv;
3565 }
3566 }
3567 SWIGINTERN void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
3568 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3569 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3570 return;
3571 }
3572 buffer acopy = (buffer)malloc(ALPHASIZE);
3573 if (acopy == NULL) {
3574 wxPyBLOCK_THREADS(PyErr_NoMemory());
3575 return;
3576 }
3577 memcpy(acopy, alpha, ALPHASIZE);
3578 self->SetAlpha(acopy, false);
3579 // wxImage takes ownership of acopy...
3580 }
3581 SWIGINTERN PyObject *wxImage_GetAlphaBuffer(wxImage *self){
3582 buffer data = self->GetAlpha();
3583 int len = self->GetWidth() * self->GetHeight();
3584 PyObject* rv;
3585 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3586 return rv;
3587 }
3588 SWIGINTERN void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
3589 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3590 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3591 return;
3592 }
3593 self->SetAlpha(alpha, true);
3594 }
3595 SWIGINTERN PyObject *wxImage_GetHandlers(){
3596 wxList& list = wxImage::GetHandlers();
3597 return wxPy_ConvertList(&list);
3598 }
3599 SWIGINTERN wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
3600 wxBitmap bitmap(*self, depth);
3601 return bitmap;
3602 }
3603 SWIGINTERN wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
3604 wxImage mono = self->ConvertToMono( red, green, blue );
3605 wxBitmap bitmap( mono, 1 );
3606 return bitmap;
3607 }
3608 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
3609 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3610 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3611 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3612 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
3613 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3614 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
3615 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
3616 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
3617 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3618 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3619 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3620 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
3621 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3622 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
3623
3624 #include <wx/quantize.h>
3625
3626 SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
3627 return wxQuantize::Quantize(src, dest,
3628 //NULL, // palette
3629 desiredNoColours,
3630 NULL, // eightBitData
3631 flags);
3632 }
3633 SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
3634 if (PyCallable_Check(func)) {
3635 self->Connect(id, lastId, eventType,
3636 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3637 new wxPyCallback(func));
3638 }
3639 else if (func == Py_None) {
3640 self->Disconnect(id, lastId, eventType,
3641 (wxObjectEventFunction)
3642 &wxPyCallback::EventThunker);
3643 }
3644 else {
3645 wxPyBLOCK_THREADS(
3646 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3647 }
3648 }
3649 SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
3650 return self->Disconnect(id, lastId, eventType,
3651 (wxObjectEventFunction)
3652 &wxPyCallback::EventThunker);
3653 }
3654 SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
3655 if (_self && _self != Py_None) {
3656 self->SetClientObject(new wxPyOORClientData(_self, incref));
3657 }
3658 else {
3659 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3660 if (data) {
3661 self->SetClientObject(NULL); // This will delete it too
3662 }
3663 }
3664 }
3665
3666 #if ! wxUSE_HOTKEY
3667 #define wxEVT_HOTKEY -9999
3668 #endif
3669
3670 SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3671 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3672 if (data) {
3673 Py_INCREF(data->m_obj);
3674 return data->m_obj;
3675 } else {
3676 Py_INCREF(Py_None);
3677 return Py_None;
3678 }
3679 }
3680 SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3681 wxPyClientData* data = new wxPyClientData(clientData);
3682 self->SetClientObject(data);
3683 }
3684 SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
3685 #if wxUSE_UNICODE
3686 return self->GetUnicodeKey();
3687 #else
3688 return 0;
3689 #endif
3690 }
3691
3692 SWIGINTERNINLINE PyObject *
3693 SWIG_From_unsigned_SS_int (unsigned int value)
3694 {
3695 return SWIG_From_unsigned_SS_long (value);
3696 }
3697
3698
3699 SWIGINTERN int
3700 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3701 {
3702 unsigned long v;
3703 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3704 if (SWIG_IsOK(res)) {
3705 if ((v > UINT_MAX)) {
3706 return SWIG_OverflowError;
3707 } else {
3708 if (val) *val = static_cast< unsigned int >(v);
3709 }
3710 }
3711 return res;
3712 }
3713
3714 SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
3715 self->m_size = size;
3716 }
3717 SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
3718 int count = self->GetNumberOfFiles();
3719 wxString* files = self->GetFiles();
3720 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3721 PyObject* list = PyList_New(count);
3722
3723 if (!list) {
3724 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
3725 wxPyEndBlockThreads(blocked);
3726 return NULL;
3727 }
3728
3729 for (int i=0; i<count; i++) {
3730 PyList_SetItem(list, i, wx2PyString(files[i]));
3731 }
3732 wxPyEndBlockThreads(blocked);
3733 return list;
3734 }
3735
3736
3737 SWIGINTERN wxPyApp *new_wxPyApp(){
3738 wxPythonApp = new wxPyApp();
3739 return wxPythonApp;
3740 }
3741 SWIGINTERN int wxPyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
3742
3743 void wxApp_CleanUp() {
3744 __wxPyCleanup();
3745 }
3746
3747
3748 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
3749
3750
3751
3752
3753
3754 SWIGINTERNINLINE PyObject *
3755 SWIG_FromCharPtr(const char *cptr)
3756 {
3757 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3758 }
3759
3760
3761 #if 0 // #ifdef __WXMAC__
3762
3763 // A dummy class that raises an exception if used...
3764 class wxEventLoop
3765 {
3766 public:
3767 wxEventLoop() { wxPyRaiseNotImplemented(); }
3768 int Run() { return 0; }
3769 void Exit(int rc = 0) {}
3770 bool Pending() const { return false; }
3771 bool Dispatch() { return false; }
3772 bool IsRunning() const { return false; }
3773 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3774 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3775 };
3776
3777 #else
3778
3779 #include <wx/evtloop.h>
3780
3781 #endif
3782
3783
3784
3785 static const wxString wxPyPanelNameStr(wxPanelNameStr);
3786 SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3787 SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3788 SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
3789 wxWindowList& list = self->GetChildren();
3790 return wxPy_ConvertList(&list);
3791 }
3792 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3793 #if wxUSE_HOTKEY
3794 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3795 #else
3796 return false;
3797 #endif
3798 }
3799 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3800
3801
3802
3803 return false;
3804
3805 }
3806 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3807 return wxPyGetWinHandle(self);
3808 }
3809 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3810 self->AssociateHandle((WXWidget)handle);
3811 }
3812 SWIGINTERN void wxWindow_DragAcceptFiles(wxWindow *self,bool accept){}
3813
3814 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3815 return wxWindow::FindWindowById(id, parent);
3816 }
3817
3818 wxWindow* wxFindWindowByName( const wxString& name,
3819 const wxWindow *parent = NULL ) {
3820 return wxWindow::FindWindowByName(name, parent);
3821 }
3822
3823 wxWindow* wxFindWindowByLabel( const wxString& label,
3824 const wxWindow *parent = NULL ) {
3825 return wxWindow::FindWindowByLabel(label, parent);
3826 }
3827
3828
3829 #ifdef __WXMSW__
3830 #include <wx/msw/private.h> // to get wxGetWindowId
3831 #endif
3832
3833
3834 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3835 #ifdef __WXMSW__
3836 WXHWND hWnd = (WXHWND)_hWnd;
3837 long id = wxGetWindowId(hWnd);
3838 wxWindow* win = new wxWindow;
3839 if (parent)
3840 parent->AddChild(win);
3841 win->SetEventHandler(win);
3842 win->SetHWND(hWnd);
3843 win->SetId(id);
3844 win->SubclassWin(hWnd);
3845 win->AdoptAttributesFromHWND();
3846 win->SetupColours();
3847 return win;
3848 #else
3849 wxPyRaiseNotImplemented();
3850 return NULL;
3851 #endif
3852 }
3853
3854
3855 PyObject* GetTopLevelWindows() {
3856 return wxPy_ConvertList(&wxTopLevelWindows);
3857 }
3858
3859
3860 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3861 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3862 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3863
3864 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3865
3866
3867 SWIGINTERNINLINE int
3868 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3869 {
3870 unsigned long v;
3871 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3872 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3873 return res;
3874 }
3875
3876 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3877 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3878 wxMenuItemList& list = self->GetMenuItems();
3879 return wxPy_ConvertList(&list);
3880 }
3881 SWIGINTERN void wxMenuBar_SetAutoWindowMenu(bool enable){}
3882 SWIGINTERN bool wxMenuBar_GetAutoWindowMenu(){ return false; }
3883 SWIGINTERN void wxMenuItem_SetFont(wxMenuItem *self,wxFont const &font){}
3884 SWIGINTERN wxFont wxMenuItem_GetFont(wxMenuItem *self){ return wxNullFont; }
3885 SWIGINTERN void wxMenuItem_SetTextColour(wxMenuItem *self,wxColour const &colText){}
3886 SWIGINTERN wxColour wxMenuItem_GetTextColour(wxMenuItem *self){ return wxNullColour; }
3887 SWIGINTERN void wxMenuItem_SetBackgroundColour(wxMenuItem *self,wxColour const &colBack){}
3888 SWIGINTERN wxColour wxMenuItem_GetBackgroundColour(wxMenuItem *self){ return wxNullColour; }
3889 SWIGINTERN void wxMenuItem_SetBitmaps(wxMenuItem *self,wxBitmap const &bmpChecked,wxBitmap const &bmpUnchecked=wxNullBitmap){ self->SetBitmap( bmpChecked ); }
3890 SWIGINTERN void wxMenuItem_SetDisabledBitmap(wxMenuItem *self,wxBitmap const &bmpDisabled){}
3891 SWIGINTERN wxBitmap const &wxMenuItem_GetDisabledBitmap(wxMenuItem const *self){ return wxNullBitmap; }
3892 SWIGINTERN void wxMenuItem_SetMarginWidth(wxMenuItem *self,int nWidth){}
3893 SWIGINTERN int wxMenuItem_GetMarginWidth(wxMenuItem *self){ return 0; }
3894 SWIGINTERN int wxMenuItem_GetDefaultMarginWidth(){ return 0; }
3895 SWIGINTERN bool wxMenuItem_IsOwnerDrawn(wxMenuItem *self){ return false; }
3896 SWIGINTERN void wxMenuItem_SetOwnerDrawn(wxMenuItem *self,bool ownerDrawn=true){}
3897 SWIGINTERN void wxMenuItem_ResetOwnerDrawn(wxMenuItem *self){}
3898 static const wxString wxPyControlNameStr(wxControlNameStr);
3899 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
3900 if (clientData) {
3901 wxPyClientData* data = new wxPyClientData(clientData);
3902 return self->Append(item, data);
3903 } else
3904 return self->Append(item);
3905 }
3906 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,unsigned int pos,PyObject *clientData=NULL){
3907 if (clientData) {
3908 wxPyClientData* data = new wxPyClientData(clientData);
3909 return self->Insert(item, pos, data);
3910 } else
3911 return self->Insert(item, pos);
3912 }
3913 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,unsigned int n){
3914 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
3915 if (data) {
3916 Py_INCREF(data->m_obj);
3917 return data->m_obj;
3918 } else {
3919 Py_INCREF(Py_None);
3920 return Py_None;
3921 }
3922 }
3923 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,unsigned int n,PyObject *clientData){
3924 wxPyClientData* data = new wxPyClientData(clientData);
3925 self->SetClientObject(n, data);
3926 }
3927
3928
3929 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
3930 wxPyUserData* data = NULL;
3931 if ( userData ) {
3932 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3933 data = new wxPyUserData(userData);
3934 wxPyEndBlockThreads(blocked);
3935 }
3936 return new wxSizerItem(window, proportion, flag, border, data);
3937 }
3938 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
3939 wxPyUserData* data = NULL;
3940 if ( userData ) {
3941 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3942 data = new wxPyUserData(userData);
3943 wxPyEndBlockThreads(blocked);
3944 }
3945 return new wxSizerItem(width, height, proportion, flag, border, data);
3946 }
3947 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
3948 wxPyUserData* data = NULL;
3949 if ( userData ) {
3950 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3951 data = new wxPyUserData(userData);
3952 wxPyEndBlockThreads(blocked);
3953 }
3954 return new wxSizerItem(sizer, proportion, flag, border, data);
3955 }
3956
3957 #include <float.h>
3958
3959
3960 SWIGINTERN int
3961 SWIG_AsVal_float (PyObject * obj, float *val)
3962 {
3963 double v;
3964 int res = SWIG_AsVal_double (obj, &v);
3965 if (SWIG_IsOK(res)) {
3966 if ((v < -FLT_MAX || v > FLT_MAX)) {
3967 return SWIG_OverflowError;
3968 } else {
3969 if (val) *val = static_cast< float >(v);
3970 }
3971 }
3972 return res;
3973 }
3974
3975
3976 SWIGINTERNINLINE PyObject *
3977 SWIG_From_float (float value)
3978 {
3979 return SWIG_From_double (value);
3980 }
3981
3982 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
3983 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
3984 if (data) {
3985 Py_INCREF(data->m_obj);
3986 return data->m_obj;
3987 } else {
3988 Py_INCREF(Py_None);
3989 return Py_None;
3990 }
3991 }
3992 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
3993 wxPyUserData* data = NULL;
3994 if ( userData ) {
3995 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3996 data = new wxPyUserData(userData);
3997 wxPyEndBlockThreads(blocked);
3998 }
3999 self->SetUserData(data);
4000 }
4001
4002 // Figure out the type of the sizer item
4003
4004 struct wxPySizerItemInfo {
4005 wxPySizerItemInfo()
4006 : window(NULL), sizer(NULL), gotSize(false),
4007 size(wxDefaultSize), gotPos(false), pos(-1)
4008 {}
4009
4010 wxWindow* window;
4011 wxSizer* sizer;
4012 bool gotSize;
4013 wxSize size;
4014 bool gotPos;
4015 int pos;
4016 };
4017
4018 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
4019
4020 wxPySizerItemInfo info;
4021 wxSize size;
4022 wxSize* sizePtr = &size;
4023
4024 // Find out what the type of the item is
4025 // try wxWindow
4026 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
4027 PyErr_Clear();
4028 info.window = NULL;
4029
4030 // try wxSizer
4031 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
4032 PyErr_Clear();
4033 info.sizer = NULL;
4034
4035 // try wxSize or (w,h)
4036 if ( checkSize && wxSize_helper(item, &sizePtr)) {
4037 info.size = *sizePtr;
4038 info.gotSize = true;
4039 }
4040
4041 // or a single int
4042 if (checkIdx && PyInt_Check(item)) {
4043 info.pos = PyInt_AsLong(item);
4044 info.gotPos = true;
4045 }
4046 }
4047 }
4048
4049 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
4050 // no expected type, figure out what kind of error message to generate
4051 if ( !checkSize && !checkIdx )
4052 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
4053 else if ( checkSize && !checkIdx )
4054 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
4055 else if ( !checkSize && checkIdx)
4056 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
4057 else
4058 // can this one happen?
4059 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
4060 }
4061
4062 return info;
4063 }
4064
4065 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
4066 if (!self->GetClientObject())
4067 self->SetClientObject(new wxPyOORClientData(_self));
4068 }
4069 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4070
4071 wxPyUserData* data = NULL;
4072 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4073 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4074 if ( userData && (info.window || info.sizer || info.gotSize) )
4075 data = new wxPyUserData(userData);
4076 if ( info.sizer )
4077 PyObject_SetAttrString(item,"thisown",Py_False);
4078 wxPyEndBlockThreads(blocked);
4079
4080 // Now call the real Add method if a valid item type was found
4081 if ( info.window )
4082 return self->Add(info.window, proportion, flag, border, data);
4083 else if ( info.sizer )
4084 return self->Add(info.sizer, proportion, flag, border, data);
4085 else if (info.gotSize)
4086 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4087 proportion, flag, border, data);
4088 else
4089 return NULL;
4090 }
4091 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4092
4093 wxPyUserData* data = NULL;
4094 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4095 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4096 if ( userData && (info.window || info.sizer || info.gotSize) )
4097 data = new wxPyUserData(userData);
4098 if ( info.sizer )
4099 PyObject_SetAttrString(item,"thisown",Py_False);
4100 wxPyEndBlockThreads(blocked);
4101
4102 // Now call the real Insert method if a valid item type was found
4103 if ( info.window )
4104 return self->Insert(before, info.window, proportion, flag, border, data);
4105 else if ( info.sizer )
4106 return self->Insert(before, info.sizer, proportion, flag, border, data);
4107 else if (info.gotSize)
4108 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4109 proportion, flag, border, data);
4110 else
4111 return NULL;
4112 }
4113 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4114
4115 wxPyUserData* data = NULL;
4116 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4117 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4118 if ( userData && (info.window || info.sizer || info.gotSize) )
4119 data = new wxPyUserData(userData);
4120 if ( info.sizer )
4121 PyObject_SetAttrString(item,"thisown",Py_False);
4122 wxPyEndBlockThreads(blocked);
4123
4124 // Now call the real Prepend method if a valid item type was found
4125 if ( info.window )
4126 return self->Prepend(info.window, proportion, flag, border, data);
4127 else if ( info.sizer )
4128 return self->Prepend(info.sizer, proportion, flag, border, data);
4129 else if (info.gotSize)
4130 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4131 proportion, flag, border, data);
4132 else
4133 return NULL;
4134 }
4135 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4136 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4137 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4138 wxPyEndBlockThreads(blocked);
4139 if ( info.window )
4140 return self->Remove(info.window);
4141 else if ( info.sizer )
4142 return self->Remove(info.sizer);
4143 else if ( info.gotPos )
4144 return self->Remove(info.pos);
4145 else
4146 return false;
4147 }
4148 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4149 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4150 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4151 wxPyEndBlockThreads(blocked);
4152 if ( info.window )
4153 return self->Detach(info.window);
4154 else if ( info.sizer )
4155 return self->Detach(info.sizer);
4156 else if ( info.gotPos )
4157 return self->Detach(info.pos);
4158 else
4159 return false;
4160 }
4161 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
4162 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4163 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4164 wxPyEndBlockThreads(blocked);
4165 if ( info.window )
4166 return self->GetItem(info.window);
4167 else if ( info.sizer )
4168 return self->GetItem(info.sizer);
4169 else if ( info.gotPos )
4170 return self->GetItem(info.pos);
4171 else
4172 return NULL;
4173 }
4174 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4175 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4176 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4177 wxPyEndBlockThreads(blocked);
4178 if ( info.window )
4179 self->SetItemMinSize(info.window, size);
4180 else if ( info.sizer )
4181 self->SetItemMinSize(info.sizer, size);
4182 else if ( info.gotPos )
4183 self->SetItemMinSize(info.pos, size);
4184 }
4185 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4186 wxSizerItemList& list = self->GetChildren();
4187 return wxPy_ConvertList(&list);
4188 }
4189 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4190 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4191 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4192 wxPyEndBlockThreads(blocked);
4193 if ( info.window )
4194 return self->Show(info.window, show, recursive);
4195 else if ( info.sizer )
4196 return self->Show(info.sizer, show, recursive);
4197 else if ( info.gotPos )
4198 return self->Show(info.pos, show);
4199 else
4200 return false;
4201 }
4202 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4203 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4204 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4205 wxPyEndBlockThreads(blocked);
4206 if ( info.window )
4207 return self->IsShown(info.window);
4208 else if ( info.sizer )
4209 return self->IsShown(info.sizer);
4210 else if ( info.gotPos )
4211 return self->IsShown(info.pos);
4212 else
4213 return false;
4214 }
4215
4216 // See pyclasses.h
4217 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4218 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4219 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4220
4221
4222
4223
4224 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4225 {
4226 if (source == Py_None) {
4227 **obj = wxGBPosition(-1,-1);
4228 return true;
4229 }
4230 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4231 }
4232
4233 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4234 {
4235 if (source == Py_None) {
4236 **obj = wxGBSpan(-1,-1);
4237 return true;
4238 }
4239 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4240 }
4241
4242
4243 SWIGINTERN bool wxGBPosition___eq__(wxGBPosition *self,PyObject *other){
4244 wxGBPosition temp, *obj = &temp;
4245 if ( other == Py_None ) return false;
4246 if ( ! wxGBPosition_helper(other, &obj) ) {
4247 PyErr_Clear();
4248 return false;
4249 }
4250 return self->operator==(*obj);
4251 }
4252 SWIGINTERN bool wxGBPosition___ne__(wxGBPosition *self,PyObject *other){
4253 wxGBPosition temp, *obj = &temp;
4254 if ( other == Py_None ) return true;
4255 if ( ! wxGBPosition_helper(other, &obj)) {
4256 PyErr_Clear();
4257 return true;
4258 }
4259 return self->operator!=(*obj);
4260 }
4261 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4262 self->SetRow(row);
4263 self->SetCol(col);
4264 }
4265 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4266 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4267 PyObject* tup = PyTuple_New(2);
4268 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4269 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4270 wxPyEndBlockThreads(blocked);
4271 return tup;
4272 }
4273 SWIGINTERN bool wxGBSpan___eq__(wxGBSpan *self,PyObject *other){
4274 wxGBSpan temp, *obj = &temp;
4275 if ( other == Py_None ) return false;
4276 if ( ! wxGBSpan_helper(other, &obj) ) {
4277 PyErr_Clear();
4278 return false;
4279 }
4280 return self->operator==(*obj);
4281 }
4282 SWIGINTERN bool wxGBSpan___ne__(wxGBSpan *self,PyObject *other){
4283 wxGBSpan temp, *obj = &temp;
4284 if ( other == Py_None ) return true;
4285 if ( ! wxGBSpan_helper(other, &obj)) {
4286 PyErr_Clear();
4287 return true;
4288 }
4289 return self->operator!=(*obj);
4290 }
4291 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4292 self->SetRowspan(rowspan);
4293 self->SetColspan(colspan);
4294 }
4295 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4296 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4297 PyObject* tup = PyTuple_New(2);
4298 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4299 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4300 wxPyEndBlockThreads(blocked);
4301 return tup;
4302 }
4303 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4304 wxPyUserData* data = NULL;
4305 if ( userData ) {
4306 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4307 data = new wxPyUserData(userData);
4308 wxPyEndBlockThreads(blocked);
4309 }
4310 return new wxGBSizerItem(window, pos, span, flag, border, data);
4311 }
4312 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4313 wxPyUserData* data = NULL;
4314 if ( userData ) {
4315 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4316 data = new wxPyUserData(userData);
4317 wxPyEndBlockThreads(blocked);
4318 }
4319 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4320 }
4321 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4322 wxPyUserData* data = NULL;
4323 if ( userData ) {
4324 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4325 data = new wxPyUserData(userData);
4326 wxPyEndBlockThreads(blocked);
4327 }
4328 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4329 }
4330 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4331 int row, col;
4332 self->GetEndPos(row, col);
4333 return wxGBPosition(row, col);
4334 }
4335 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4336
4337 wxPyUserData* data = NULL;
4338 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4339 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4340 if ( userData && (info.window || info.sizer || info.gotSize) )
4341 data = new wxPyUserData(userData);
4342 if ( info.sizer )
4343 PyObject_SetAttrString(item,"thisown",Py_False);
4344 wxPyEndBlockThreads(blocked);
4345
4346 // Now call the real Add method if a valid item type was found
4347 if ( info.window )
4348 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4349 else if ( info.sizer )
4350 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4351 else if (info.gotSize)
4352 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4353 pos, span, flag, border, data);
4354 return NULL;
4355 }
4356
4357
4358 #ifdef __cplusplus
4359 extern "C" {
4360 #endif
4361 SWIGINTERN int EmptyString_set(PyObject *) {
4362 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4363 return 1;
4364 }
4365
4366
4367 SWIGINTERN PyObject *EmptyString_get(void) {
4368 PyObject *pyobj = 0;
4369
4370 {
4371 #if wxUSE_UNICODE
4372 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4373 #else
4374 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4375 #endif
4376 }
4377 return pyobj;
4378 }
4379
4380
4381 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4382 PyObject *resultobj = 0;
4383 wxObject *arg1 = (wxObject *) 0 ;
4384 wxString result;
4385 void *argp1 = 0 ;
4386 int res1 = 0 ;
4387 PyObject *swig_obj[1] ;
4388
4389 if (!args) SWIG_fail;
4390 swig_obj[0] = args;
4391 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4392 if (!SWIG_IsOK(res1)) {
4393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4394 }
4395 arg1 = reinterpret_cast< wxObject * >(argp1);
4396 {
4397 PyThreadState* __tstate = wxPyBeginAllowThreads();
4398 result = wxObject_GetClassName(arg1);
4399 wxPyEndAllowThreads(__tstate);
4400 if (PyErr_Occurred()) SWIG_fail;
4401 }
4402 {
4403 #if wxUSE_UNICODE
4404 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4405 #else
4406 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4407 #endif
4408 }
4409 return resultobj;
4410 fail:
4411 return NULL;
4412 }
4413
4414
4415 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4416 PyObject *resultobj = 0;
4417 wxObject *arg1 = (wxObject *) 0 ;
4418 void *argp1 = 0 ;
4419 int res1 = 0 ;
4420 PyObject *swig_obj[1] ;
4421
4422 if (!args) SWIG_fail;
4423 swig_obj[0] = args;
4424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4425 if (!SWIG_IsOK(res1)) {
4426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4427 }
4428 arg1 = reinterpret_cast< wxObject * >(argp1);
4429 {
4430 PyThreadState* __tstate = wxPyBeginAllowThreads();
4431 wxObject_Destroy(arg1);
4432 wxPyEndAllowThreads(__tstate);
4433 if (PyErr_Occurred()) SWIG_fail;
4434 }
4435 resultobj = SWIG_Py_Void();
4436 return resultobj;
4437 fail:
4438 return NULL;
4439 }
4440
4441
4442 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4443 PyObject *obj;
4444 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4445 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4446 return SWIG_Py_Void();
4447 }
4448
4449 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4450 PyObject *resultobj = 0;
4451 wxSize *arg1 = (wxSize *) 0 ;
4452 int arg2 ;
4453 void *argp1 = 0 ;
4454 int res1 = 0 ;
4455 int val2 ;
4456 int ecode2 = 0 ;
4457 PyObject *swig_obj[2] ;
4458
4459 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4460 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4461 if (!SWIG_IsOK(res1)) {
4462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4463 }
4464 arg1 = reinterpret_cast< wxSize * >(argp1);
4465 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4466 if (!SWIG_IsOK(ecode2)) {
4467 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4468 }
4469 arg2 = static_cast< int >(val2);
4470 if (arg1) (arg1)->x = arg2;
4471
4472 resultobj = SWIG_Py_Void();
4473 return resultobj;
4474 fail:
4475 return NULL;
4476 }
4477
4478
4479 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4480 PyObject *resultobj = 0;
4481 wxSize *arg1 = (wxSize *) 0 ;
4482 int result;
4483 void *argp1 = 0 ;
4484 int res1 = 0 ;
4485 PyObject *swig_obj[1] ;
4486
4487 if (!args) SWIG_fail;
4488 swig_obj[0] = args;
4489 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4490 if (!SWIG_IsOK(res1)) {
4491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4492 }
4493 arg1 = reinterpret_cast< wxSize * >(argp1);
4494 result = (int) ((arg1)->x);
4495 resultobj = SWIG_From_int(static_cast< int >(result));
4496 return resultobj;
4497 fail:
4498 return NULL;
4499 }
4500
4501
4502 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4503 PyObject *resultobj = 0;
4504 wxSize *arg1 = (wxSize *) 0 ;
4505 int arg2 ;
4506 void *argp1 = 0 ;
4507 int res1 = 0 ;
4508 int val2 ;
4509 int ecode2 = 0 ;
4510 PyObject *swig_obj[2] ;
4511
4512 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4513 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4514 if (!SWIG_IsOK(res1)) {
4515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4516 }
4517 arg1 = reinterpret_cast< wxSize * >(argp1);
4518 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4519 if (!SWIG_IsOK(ecode2)) {
4520 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4521 }
4522 arg2 = static_cast< int >(val2);
4523 if (arg1) (arg1)->y = arg2;
4524
4525 resultobj = SWIG_Py_Void();
4526 return resultobj;
4527 fail:
4528 return NULL;
4529 }
4530
4531
4532 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4533 PyObject *resultobj = 0;
4534 wxSize *arg1 = (wxSize *) 0 ;
4535 int result;
4536 void *argp1 = 0 ;
4537 int res1 = 0 ;
4538 PyObject *swig_obj[1] ;
4539
4540 if (!args) SWIG_fail;
4541 swig_obj[0] = args;
4542 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4543 if (!SWIG_IsOK(res1)) {
4544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4545 }
4546 arg1 = reinterpret_cast< wxSize * >(argp1);
4547 result = (int) ((arg1)->y);
4548 resultobj = SWIG_From_int(static_cast< int >(result));
4549 return resultobj;
4550 fail:
4551 return NULL;
4552 }
4553
4554
4555 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4556 PyObject *resultobj = 0;
4557 int arg1 = (int) 0 ;
4558 int arg2 = (int) 0 ;
4559 wxSize *result = 0 ;
4560 int val1 ;
4561 int ecode1 = 0 ;
4562 int val2 ;
4563 int ecode2 = 0 ;
4564 PyObject * obj0 = 0 ;
4565 PyObject * obj1 = 0 ;
4566 char * kwnames[] = {
4567 (char *) "w",(char *) "h", NULL
4568 };
4569
4570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4571 if (obj0) {
4572 ecode1 = SWIG_AsVal_int(obj0, &val1);
4573 if (!SWIG_IsOK(ecode1)) {
4574 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4575 }
4576 arg1 = static_cast< int >(val1);
4577 }
4578 if (obj1) {
4579 ecode2 = SWIG_AsVal_int(obj1, &val2);
4580 if (!SWIG_IsOK(ecode2)) {
4581 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4582 }
4583 arg2 = static_cast< int >(val2);
4584 }
4585 {
4586 PyThreadState* __tstate = wxPyBeginAllowThreads();
4587 result = (wxSize *)new wxSize(arg1,arg2);
4588 wxPyEndAllowThreads(__tstate);
4589 if (PyErr_Occurred()) SWIG_fail;
4590 }
4591 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4592 return resultobj;
4593 fail:
4594 return NULL;
4595 }
4596
4597
4598 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4599 PyObject *resultobj = 0;
4600 wxSize *arg1 = (wxSize *) 0 ;
4601 void *argp1 = 0 ;
4602 int res1 = 0 ;
4603 PyObject *swig_obj[1] ;
4604
4605 if (!args) SWIG_fail;
4606 swig_obj[0] = args;
4607 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4608 if (!SWIG_IsOK(res1)) {
4609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4610 }
4611 arg1 = reinterpret_cast< wxSize * >(argp1);
4612 {
4613 PyThreadState* __tstate = wxPyBeginAllowThreads();
4614 delete arg1;
4615
4616 wxPyEndAllowThreads(__tstate);
4617 if (PyErr_Occurred()) SWIG_fail;
4618 }
4619 resultobj = SWIG_Py_Void();
4620 return resultobj;
4621 fail:
4622 return NULL;
4623 }
4624
4625
4626 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4627 PyObject *resultobj = 0;
4628 wxSize *arg1 = (wxSize *) 0 ;
4629 PyObject *arg2 = (PyObject *) 0 ;
4630 bool result;
4631 void *argp1 = 0 ;
4632 int res1 = 0 ;
4633 PyObject * obj0 = 0 ;
4634 PyObject * obj1 = 0 ;
4635 char * kwnames[] = {
4636 (char *) "self",(char *) "other", NULL
4637 };
4638
4639 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4640 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4641 if (!SWIG_IsOK(res1)) {
4642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4643 }
4644 arg1 = reinterpret_cast< wxSize * >(argp1);
4645 arg2 = obj1;
4646 {
4647 result = (bool)wxSize___eq__(arg1,arg2);
4648 if (PyErr_Occurred()) SWIG_fail;
4649 }
4650 {
4651 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4652 }
4653 return resultobj;
4654 fail:
4655 return NULL;
4656 }
4657
4658
4659 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4660 PyObject *resultobj = 0;
4661 wxSize *arg1 = (wxSize *) 0 ;
4662 PyObject *arg2 = (PyObject *) 0 ;
4663 bool result;
4664 void *argp1 = 0 ;
4665 int res1 = 0 ;
4666 PyObject * obj0 = 0 ;
4667 PyObject * obj1 = 0 ;
4668 char * kwnames[] = {
4669 (char *) "self",(char *) "other", NULL
4670 };
4671
4672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4673 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4674 if (!SWIG_IsOK(res1)) {
4675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4676 }
4677 arg1 = reinterpret_cast< wxSize * >(argp1);
4678 arg2 = obj1;
4679 {
4680 result = (bool)wxSize___ne__(arg1,arg2);
4681 if (PyErr_Occurred()) SWIG_fail;
4682 }
4683 {
4684 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4685 }
4686 return resultobj;
4687 fail:
4688 return NULL;
4689 }
4690
4691
4692 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4693 PyObject *resultobj = 0;
4694 wxSize *arg1 = (wxSize *) 0 ;
4695 wxSize *arg2 = 0 ;
4696 wxSize result;
4697 void *argp1 = 0 ;
4698 int res1 = 0 ;
4699 wxSize temp2 ;
4700 PyObject * obj0 = 0 ;
4701 PyObject * obj1 = 0 ;
4702 char * kwnames[] = {
4703 (char *) "self",(char *) "sz", NULL
4704 };
4705
4706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4707 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4708 if (!SWIG_IsOK(res1)) {
4709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4710 }
4711 arg1 = reinterpret_cast< wxSize * >(argp1);
4712 {
4713 arg2 = &temp2;
4714 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4715 }
4716 {
4717 PyThreadState* __tstate = wxPyBeginAllowThreads();
4718 result = (arg1)->operator +((wxSize const &)*arg2);
4719 wxPyEndAllowThreads(__tstate);
4720 if (PyErr_Occurred()) SWIG_fail;
4721 }
4722 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4723 return resultobj;
4724 fail:
4725 return NULL;
4726 }
4727
4728
4729 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4730 PyObject *resultobj = 0;
4731 wxSize *arg1 = (wxSize *) 0 ;
4732 wxSize *arg2 = 0 ;
4733 wxSize result;
4734 void *argp1 = 0 ;
4735 int res1 = 0 ;
4736 wxSize temp2 ;
4737 PyObject * obj0 = 0 ;
4738 PyObject * obj1 = 0 ;
4739 char * kwnames[] = {
4740 (char *) "self",(char *) "sz", NULL
4741 };
4742
4743 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4744 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4745 if (!SWIG_IsOK(res1)) {
4746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4747 }
4748 arg1 = reinterpret_cast< wxSize * >(argp1);
4749 {
4750 arg2 = &temp2;
4751 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4752 }
4753 {
4754 PyThreadState* __tstate = wxPyBeginAllowThreads();
4755 result = (arg1)->operator -((wxSize const &)*arg2);
4756 wxPyEndAllowThreads(__tstate);
4757 if (PyErr_Occurred()) SWIG_fail;
4758 }
4759 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4760 return resultobj;
4761 fail:
4762 return NULL;
4763 }
4764
4765
4766 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4767 PyObject *resultobj = 0;
4768 wxSize *arg1 = (wxSize *) 0 ;
4769 wxSize *arg2 = 0 ;
4770 void *argp1 = 0 ;
4771 int res1 = 0 ;
4772 wxSize temp2 ;
4773 PyObject * obj0 = 0 ;
4774 PyObject * obj1 = 0 ;
4775 char * kwnames[] = {
4776 (char *) "self",(char *) "sz", NULL
4777 };
4778
4779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4780 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4781 if (!SWIG_IsOK(res1)) {
4782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4783 }
4784 arg1 = reinterpret_cast< wxSize * >(argp1);
4785 {
4786 arg2 = &temp2;
4787 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4788 }
4789 {
4790 PyThreadState* __tstate = wxPyBeginAllowThreads();
4791 (arg1)->IncTo((wxSize const &)*arg2);
4792 wxPyEndAllowThreads(__tstate);
4793 if (PyErr_Occurred()) SWIG_fail;
4794 }
4795 resultobj = SWIG_Py_Void();
4796 return resultobj;
4797 fail:
4798 return NULL;
4799 }
4800
4801
4802 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4803 PyObject *resultobj = 0;
4804 wxSize *arg1 = (wxSize *) 0 ;
4805 wxSize *arg2 = 0 ;
4806 void *argp1 = 0 ;
4807 int res1 = 0 ;
4808 wxSize temp2 ;
4809 PyObject * obj0 = 0 ;
4810 PyObject * obj1 = 0 ;
4811 char * kwnames[] = {
4812 (char *) "self",(char *) "sz", NULL
4813 };
4814
4815 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
4816 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4817 if (!SWIG_IsOK(res1)) {
4818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
4819 }
4820 arg1 = reinterpret_cast< wxSize * >(argp1);
4821 {
4822 arg2 = &temp2;
4823 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4824 }
4825 {
4826 PyThreadState* __tstate = wxPyBeginAllowThreads();
4827 (arg1)->DecTo((wxSize const &)*arg2);
4828 wxPyEndAllowThreads(__tstate);
4829 if (PyErr_Occurred()) SWIG_fail;
4830 }
4831 resultobj = SWIG_Py_Void();
4832 return resultobj;
4833 fail:
4834 return NULL;
4835 }
4836
4837
4838 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4839 PyObject *resultobj = 0;
4840 wxSize *arg1 = (wxSize *) 0 ;
4841 int arg2 ;
4842 int arg3 ;
4843 void *argp1 = 0 ;
4844 int res1 = 0 ;
4845 int val2 ;
4846 int ecode2 = 0 ;
4847 int val3 ;
4848 int ecode3 = 0 ;
4849 PyObject * obj0 = 0 ;
4850 PyObject * obj1 = 0 ;
4851 PyObject * obj2 = 0 ;
4852 char * kwnames[] = {
4853 (char *) "self",(char *) "w",(char *) "h", NULL
4854 };
4855
4856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4857 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4858 if (!SWIG_IsOK(res1)) {
4859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
4860 }
4861 arg1 = reinterpret_cast< wxSize * >(argp1);
4862 ecode2 = SWIG_AsVal_int(obj1, &val2);
4863 if (!SWIG_IsOK(ecode2)) {
4864 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
4865 }
4866 arg2 = static_cast< int >(val2);
4867 ecode3 = SWIG_AsVal_int(obj2, &val3);
4868 if (!SWIG_IsOK(ecode3)) {
4869 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
4870 }
4871 arg3 = static_cast< int >(val3);
4872 {
4873 PyThreadState* __tstate = wxPyBeginAllowThreads();
4874 (arg1)->Set(arg2,arg3);
4875 wxPyEndAllowThreads(__tstate);
4876 if (PyErr_Occurred()) SWIG_fail;
4877 }
4878 resultobj = SWIG_Py_Void();
4879 return resultobj;
4880 fail:
4881 return NULL;
4882 }
4883
4884
4885 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4886 PyObject *resultobj = 0;
4887 wxSize *arg1 = (wxSize *) 0 ;
4888 int arg2 ;
4889 void *argp1 = 0 ;
4890 int res1 = 0 ;
4891 int val2 ;
4892 int ecode2 = 0 ;
4893 PyObject * obj0 = 0 ;
4894 PyObject * obj1 = 0 ;
4895 char * kwnames[] = {
4896 (char *) "self",(char *) "w", NULL
4897 };
4898
4899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
4900 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4901 if (!SWIG_IsOK(res1)) {
4902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
4903 }
4904 arg1 = reinterpret_cast< wxSize * >(argp1);
4905 ecode2 = SWIG_AsVal_int(obj1, &val2);
4906 if (!SWIG_IsOK(ecode2)) {
4907 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
4908 }
4909 arg2 = static_cast< int >(val2);
4910 {
4911 PyThreadState* __tstate = wxPyBeginAllowThreads();
4912 (arg1)->SetWidth(arg2);
4913 wxPyEndAllowThreads(__tstate);
4914 if (PyErr_Occurred()) SWIG_fail;
4915 }
4916 resultobj = SWIG_Py_Void();
4917 return resultobj;
4918 fail:
4919 return NULL;
4920 }
4921
4922
4923 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4924 PyObject *resultobj = 0;
4925 wxSize *arg1 = (wxSize *) 0 ;
4926 int arg2 ;
4927 void *argp1 = 0 ;
4928 int res1 = 0 ;
4929 int val2 ;
4930 int ecode2 = 0 ;
4931 PyObject * obj0 = 0 ;
4932 PyObject * obj1 = 0 ;
4933 char * kwnames[] = {
4934 (char *) "self",(char *) "h", NULL
4935 };
4936
4937 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
4938 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4939 if (!SWIG_IsOK(res1)) {
4940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
4941 }
4942 arg1 = reinterpret_cast< wxSize * >(argp1);
4943 ecode2 = SWIG_AsVal_int(obj1, &val2);
4944 if (!SWIG_IsOK(ecode2)) {
4945 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
4946 }
4947 arg2 = static_cast< int >(val2);
4948 {
4949 PyThreadState* __tstate = wxPyBeginAllowThreads();
4950 (arg1)->SetHeight(arg2);
4951 wxPyEndAllowThreads(__tstate);
4952 if (PyErr_Occurred()) SWIG_fail;
4953 }
4954 resultobj = SWIG_Py_Void();
4955 return resultobj;
4956 fail:
4957 return NULL;
4958 }
4959
4960
4961 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4962 PyObject *resultobj = 0;
4963 wxSize *arg1 = (wxSize *) 0 ;
4964 int result;
4965 void *argp1 = 0 ;
4966 int res1 = 0 ;
4967 PyObject *swig_obj[1] ;
4968
4969 if (!args) SWIG_fail;
4970 swig_obj[0] = args;
4971 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4972 if (!SWIG_IsOK(res1)) {
4973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
4974 }
4975 arg1 = reinterpret_cast< wxSize * >(argp1);
4976 {
4977 PyThreadState* __tstate = wxPyBeginAllowThreads();
4978 result = (int)((wxSize const *)arg1)->GetWidth();
4979 wxPyEndAllowThreads(__tstate);
4980 if (PyErr_Occurred()) SWIG_fail;
4981 }
4982 resultobj = SWIG_From_int(static_cast< int >(result));
4983 return resultobj;
4984 fail:
4985 return NULL;
4986 }
4987
4988
4989 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4990 PyObject *resultobj = 0;
4991 wxSize *arg1 = (wxSize *) 0 ;
4992 int result;
4993 void *argp1 = 0 ;
4994 int res1 = 0 ;
4995 PyObject *swig_obj[1] ;
4996
4997 if (!args) SWIG_fail;
4998 swig_obj[0] = args;
4999 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5000 if (!SWIG_IsOK(res1)) {
5001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
5002 }
5003 arg1 = reinterpret_cast< wxSize * >(argp1);
5004 {
5005 PyThreadState* __tstate = wxPyBeginAllowThreads();
5006 result = (int)((wxSize const *)arg1)->GetHeight();
5007 wxPyEndAllowThreads(__tstate);
5008 if (PyErr_Occurred()) SWIG_fail;
5009 }
5010 resultobj = SWIG_From_int(static_cast< int >(result));
5011 return resultobj;
5012 fail:
5013 return NULL;
5014 }
5015
5016
5017 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5018 PyObject *resultobj = 0;
5019 wxSize *arg1 = (wxSize *) 0 ;
5020 bool result;
5021 void *argp1 = 0 ;
5022 int res1 = 0 ;
5023 PyObject *swig_obj[1] ;
5024
5025 if (!args) SWIG_fail;
5026 swig_obj[0] = args;
5027 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5028 if (!SWIG_IsOK(res1)) {
5029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
5030 }
5031 arg1 = reinterpret_cast< wxSize * >(argp1);
5032 {
5033 PyThreadState* __tstate = wxPyBeginAllowThreads();
5034 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
5035 wxPyEndAllowThreads(__tstate);
5036 if (PyErr_Occurred()) SWIG_fail;
5037 }
5038 {
5039 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5040 }
5041 return resultobj;
5042 fail:
5043 return NULL;
5044 }
5045
5046
5047 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5048 PyObject *resultobj = 0;
5049 wxSize *arg1 = (wxSize *) 0 ;
5050 wxSize *arg2 = 0 ;
5051 void *argp1 = 0 ;
5052 int res1 = 0 ;
5053 wxSize temp2 ;
5054 PyObject * obj0 = 0 ;
5055 PyObject * obj1 = 0 ;
5056 char * kwnames[] = {
5057 (char *) "self",(char *) "size", NULL
5058 };
5059
5060 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
5061 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5062 if (!SWIG_IsOK(res1)) {
5063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
5064 }
5065 arg1 = reinterpret_cast< wxSize * >(argp1);
5066 {
5067 arg2 = &temp2;
5068 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5069 }
5070 {
5071 PyThreadState* __tstate = wxPyBeginAllowThreads();
5072 (arg1)->SetDefaults((wxSize const &)*arg2);
5073 wxPyEndAllowThreads(__tstate);
5074 if (PyErr_Occurred()) SWIG_fail;
5075 }
5076 resultobj = SWIG_Py_Void();
5077 return resultobj;
5078 fail:
5079 return NULL;
5080 }
5081
5082
5083 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5084 PyObject *resultobj = 0;
5085 wxSize *arg1 = (wxSize *) 0 ;
5086 PyObject *result = 0 ;
5087 void *argp1 = 0 ;
5088 int res1 = 0 ;
5089 PyObject *swig_obj[1] ;
5090
5091 if (!args) SWIG_fail;
5092 swig_obj[0] = args;
5093 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5094 if (!SWIG_IsOK(res1)) {
5095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
5096 }
5097 arg1 = reinterpret_cast< wxSize * >(argp1);
5098 {
5099 PyThreadState* __tstate = wxPyBeginAllowThreads();
5100 result = (PyObject *)wxSize_Get(arg1);
5101 wxPyEndAllowThreads(__tstate);
5102 if (PyErr_Occurred()) SWIG_fail;
5103 }
5104 resultobj = result;
5105 return resultobj;
5106 fail:
5107 return NULL;
5108 }
5109
5110
5111 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5112 PyObject *obj;
5113 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5114 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5115 return SWIG_Py_Void();
5116 }
5117
5118 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5119 return SWIG_Python_InitShadowInstance(args);
5120 }
5121
5122 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5123 PyObject *resultobj = 0;
5124 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5125 double arg2 ;
5126 void *argp1 = 0 ;
5127 int res1 = 0 ;
5128 double val2 ;
5129 int ecode2 = 0 ;
5130 PyObject *swig_obj[2] ;
5131
5132 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5133 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5134 if (!SWIG_IsOK(res1)) {
5135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5136 }
5137 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5138 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5139 if (!SWIG_IsOK(ecode2)) {
5140 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5141 }
5142 arg2 = static_cast< double >(val2);
5143 if (arg1) (arg1)->x = arg2;
5144
5145 resultobj = SWIG_Py_Void();
5146 return resultobj;
5147 fail:
5148 return NULL;
5149 }
5150
5151
5152 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5153 PyObject *resultobj = 0;
5154 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5155 double result;
5156 void *argp1 = 0 ;
5157 int res1 = 0 ;
5158 PyObject *swig_obj[1] ;
5159
5160 if (!args) SWIG_fail;
5161 swig_obj[0] = args;
5162 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5163 if (!SWIG_IsOK(res1)) {
5164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5165 }
5166 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5167 result = (double) ((arg1)->x);
5168 resultobj = SWIG_From_double(static_cast< double >(result));
5169 return resultobj;
5170 fail:
5171 return NULL;
5172 }
5173
5174
5175 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5176 PyObject *resultobj = 0;
5177 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5178 double arg2 ;
5179 void *argp1 = 0 ;
5180 int res1 = 0 ;
5181 double val2 ;
5182 int ecode2 = 0 ;
5183 PyObject *swig_obj[2] ;
5184
5185 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5186 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5187 if (!SWIG_IsOK(res1)) {
5188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5189 }
5190 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5191 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5192 if (!SWIG_IsOK(ecode2)) {
5193 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5194 }
5195 arg2 = static_cast< double >(val2);
5196 if (arg1) (arg1)->y = arg2;
5197
5198 resultobj = SWIG_Py_Void();
5199 return resultobj;
5200 fail:
5201 return NULL;
5202 }
5203
5204
5205 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5206 PyObject *resultobj = 0;
5207 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5208 double result;
5209 void *argp1 = 0 ;
5210 int res1 = 0 ;
5211 PyObject *swig_obj[1] ;
5212
5213 if (!args) SWIG_fail;
5214 swig_obj[0] = args;
5215 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5216 if (!SWIG_IsOK(res1)) {
5217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5218 }
5219 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5220 result = (double) ((arg1)->y);
5221 resultobj = SWIG_From_double(static_cast< double >(result));
5222 return resultobj;
5223 fail:
5224 return NULL;
5225 }
5226
5227
5228 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5229 PyObject *resultobj = 0;
5230 double arg1 = (double) 0.0 ;
5231 double arg2 = (double) 0.0 ;
5232 wxRealPoint *result = 0 ;
5233 double val1 ;
5234 int ecode1 = 0 ;
5235 double val2 ;
5236 int ecode2 = 0 ;
5237 PyObject * obj0 = 0 ;
5238 PyObject * obj1 = 0 ;
5239 char * kwnames[] = {
5240 (char *) "x",(char *) "y", NULL
5241 };
5242
5243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5244 if (obj0) {
5245 ecode1 = SWIG_AsVal_double(obj0, &val1);
5246 if (!SWIG_IsOK(ecode1)) {
5247 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5248 }
5249 arg1 = static_cast< double >(val1);
5250 }
5251 if (obj1) {
5252 ecode2 = SWIG_AsVal_double(obj1, &val2);
5253 if (!SWIG_IsOK(ecode2)) {
5254 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5255 }
5256 arg2 = static_cast< double >(val2);
5257 }
5258 {
5259 PyThreadState* __tstate = wxPyBeginAllowThreads();
5260 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5261 wxPyEndAllowThreads(__tstate);
5262 if (PyErr_Occurred()) SWIG_fail;
5263 }
5264 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5265 return resultobj;
5266 fail:
5267 return NULL;
5268 }
5269
5270
5271 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5272 PyObject *resultobj = 0;
5273 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5274 void *argp1 = 0 ;
5275 int res1 = 0 ;
5276 PyObject *swig_obj[1] ;
5277
5278 if (!args) SWIG_fail;
5279 swig_obj[0] = args;
5280 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5281 if (!SWIG_IsOK(res1)) {
5282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5283 }
5284 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5285 {
5286 PyThreadState* __tstate = wxPyBeginAllowThreads();
5287 delete arg1;
5288
5289 wxPyEndAllowThreads(__tstate);
5290 if (PyErr_Occurred()) SWIG_fail;
5291 }
5292 resultobj = SWIG_Py_Void();
5293 return resultobj;
5294 fail:
5295 return NULL;
5296 }
5297
5298
5299 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5300 PyObject *resultobj = 0;
5301 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5302 PyObject *arg2 = (PyObject *) 0 ;
5303 bool result;
5304 void *argp1 = 0 ;
5305 int res1 = 0 ;
5306 PyObject * obj0 = 0 ;
5307 PyObject * obj1 = 0 ;
5308 char * kwnames[] = {
5309 (char *) "self",(char *) "other", NULL
5310 };
5311
5312 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5313 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5314 if (!SWIG_IsOK(res1)) {
5315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5316 }
5317 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5318 arg2 = obj1;
5319 {
5320 result = (bool)wxRealPoint___eq__(arg1,arg2);
5321 if (PyErr_Occurred()) SWIG_fail;
5322 }
5323 {
5324 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5325 }
5326 return resultobj;
5327 fail:
5328 return NULL;
5329 }
5330
5331
5332 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5333 PyObject *resultobj = 0;
5334 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5335 PyObject *arg2 = (PyObject *) 0 ;
5336 bool result;
5337 void *argp1 = 0 ;
5338 int res1 = 0 ;
5339 PyObject * obj0 = 0 ;
5340 PyObject * obj1 = 0 ;
5341 char * kwnames[] = {
5342 (char *) "self",(char *) "other", NULL
5343 };
5344
5345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5346 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5347 if (!SWIG_IsOK(res1)) {
5348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5349 }
5350 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5351 arg2 = obj1;
5352 {
5353 result = (bool)wxRealPoint___ne__(arg1,arg2);
5354 if (PyErr_Occurred()) SWIG_fail;
5355 }
5356 {
5357 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5358 }
5359 return resultobj;
5360 fail:
5361 return NULL;
5362 }
5363
5364
5365 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5366 PyObject *resultobj = 0;
5367 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5368 wxRealPoint *arg2 = 0 ;
5369 wxRealPoint result;
5370 void *argp1 = 0 ;
5371 int res1 = 0 ;
5372 wxRealPoint temp2 ;
5373 PyObject * obj0 = 0 ;
5374 PyObject * obj1 = 0 ;
5375 char * kwnames[] = {
5376 (char *) "self",(char *) "pt", NULL
5377 };
5378
5379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5380 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5381 if (!SWIG_IsOK(res1)) {
5382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5383 }
5384 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5385 {
5386 arg2 = &temp2;
5387 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5388 }
5389 {
5390 PyThreadState* __tstate = wxPyBeginAllowThreads();
5391 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5392 wxPyEndAllowThreads(__tstate);
5393 if (PyErr_Occurred()) SWIG_fail;
5394 }
5395 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5396 return resultobj;
5397 fail:
5398 return NULL;
5399 }
5400
5401
5402 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5403 PyObject *resultobj = 0;
5404 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5405 wxRealPoint *arg2 = 0 ;
5406 wxRealPoint result;
5407 void *argp1 = 0 ;
5408 int res1 = 0 ;
5409 wxRealPoint temp2 ;
5410 PyObject * obj0 = 0 ;
5411 PyObject * obj1 = 0 ;
5412 char * kwnames[] = {
5413 (char *) "self",(char *) "pt", NULL
5414 };
5415
5416 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5417 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5418 if (!SWIG_IsOK(res1)) {
5419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5420 }
5421 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5422 {
5423 arg2 = &temp2;
5424 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5425 }
5426 {
5427 PyThreadState* __tstate = wxPyBeginAllowThreads();
5428 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5429 wxPyEndAllowThreads(__tstate);
5430 if (PyErr_Occurred()) SWIG_fail;
5431 }
5432 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5433 return resultobj;
5434 fail:
5435 return NULL;
5436 }
5437
5438
5439 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5440 PyObject *resultobj = 0;
5441 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5442 double arg2 ;
5443 double arg3 ;
5444 void *argp1 = 0 ;
5445 int res1 = 0 ;
5446 double val2 ;
5447 int ecode2 = 0 ;
5448 double val3 ;
5449 int ecode3 = 0 ;
5450 PyObject * obj0 = 0 ;
5451 PyObject * obj1 = 0 ;
5452 PyObject * obj2 = 0 ;
5453 char * kwnames[] = {
5454 (char *) "self",(char *) "x",(char *) "y", NULL
5455 };
5456
5457 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5458 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5459 if (!SWIG_IsOK(res1)) {
5460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5461 }
5462 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5463 ecode2 = SWIG_AsVal_double(obj1, &val2);
5464 if (!SWIG_IsOK(ecode2)) {
5465 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5466 }
5467 arg2 = static_cast< double >(val2);
5468 ecode3 = SWIG_AsVal_double(obj2, &val3);
5469 if (!SWIG_IsOK(ecode3)) {
5470 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5471 }
5472 arg3 = static_cast< double >(val3);
5473 {
5474 PyThreadState* __tstate = wxPyBeginAllowThreads();
5475 wxRealPoint_Set(arg1,arg2,arg3);
5476 wxPyEndAllowThreads(__tstate);
5477 if (PyErr_Occurred()) SWIG_fail;
5478 }
5479 resultobj = SWIG_Py_Void();
5480 return resultobj;
5481 fail:
5482 return NULL;
5483 }
5484
5485
5486 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5487 PyObject *resultobj = 0;
5488 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5489 PyObject *result = 0 ;
5490 void *argp1 = 0 ;
5491 int res1 = 0 ;
5492 PyObject *swig_obj[1] ;
5493
5494 if (!args) SWIG_fail;
5495 swig_obj[0] = args;
5496 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5497 if (!SWIG_IsOK(res1)) {
5498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5499 }
5500 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5501 {
5502 PyThreadState* __tstate = wxPyBeginAllowThreads();
5503 result = (PyObject *)wxRealPoint_Get(arg1);
5504 wxPyEndAllowThreads(__tstate);
5505 if (PyErr_Occurred()) SWIG_fail;
5506 }
5507 resultobj = result;
5508 return resultobj;
5509 fail:
5510 return NULL;
5511 }
5512
5513
5514 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5515 PyObject *obj;
5516 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5517 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5518 return SWIG_Py_Void();
5519 }
5520
5521 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5522 return SWIG_Python_InitShadowInstance(args);
5523 }
5524
5525 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5526 PyObject *resultobj = 0;
5527 wxPoint *arg1 = (wxPoint *) 0 ;
5528 int arg2 ;
5529 void *argp1 = 0 ;
5530 int res1 = 0 ;
5531 int val2 ;
5532 int ecode2 = 0 ;
5533 PyObject *swig_obj[2] ;
5534
5535 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5537 if (!SWIG_IsOK(res1)) {
5538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5539 }
5540 arg1 = reinterpret_cast< wxPoint * >(argp1);
5541 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5542 if (!SWIG_IsOK(ecode2)) {
5543 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5544 }
5545 arg2 = static_cast< int >(val2);
5546 if (arg1) (arg1)->x = arg2;
5547
5548 resultobj = SWIG_Py_Void();
5549 return resultobj;
5550 fail:
5551 return NULL;
5552 }
5553
5554
5555 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5556 PyObject *resultobj = 0;
5557 wxPoint *arg1 = (wxPoint *) 0 ;
5558 int result;
5559 void *argp1 = 0 ;
5560 int res1 = 0 ;
5561 PyObject *swig_obj[1] ;
5562
5563 if (!args) SWIG_fail;
5564 swig_obj[0] = args;
5565 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5566 if (!SWIG_IsOK(res1)) {
5567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5568 }
5569 arg1 = reinterpret_cast< wxPoint * >(argp1);
5570 result = (int) ((arg1)->x);
5571 resultobj = SWIG_From_int(static_cast< int >(result));
5572 return resultobj;
5573 fail:
5574 return NULL;
5575 }
5576
5577
5578 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5579 PyObject *resultobj = 0;
5580 wxPoint *arg1 = (wxPoint *) 0 ;
5581 int arg2 ;
5582 void *argp1 = 0 ;
5583 int res1 = 0 ;
5584 int val2 ;
5585 int ecode2 = 0 ;
5586 PyObject *swig_obj[2] ;
5587
5588 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5590 if (!SWIG_IsOK(res1)) {
5591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5592 }
5593 arg1 = reinterpret_cast< wxPoint * >(argp1);
5594 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5595 if (!SWIG_IsOK(ecode2)) {
5596 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5597 }
5598 arg2 = static_cast< int >(val2);
5599 if (arg1) (arg1)->y = arg2;
5600
5601 resultobj = SWIG_Py_Void();
5602 return resultobj;
5603 fail:
5604 return NULL;
5605 }
5606
5607
5608 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5609 PyObject *resultobj = 0;
5610 wxPoint *arg1 = (wxPoint *) 0 ;
5611 int result;
5612 void *argp1 = 0 ;
5613 int res1 = 0 ;
5614 PyObject *swig_obj[1] ;
5615
5616 if (!args) SWIG_fail;
5617 swig_obj[0] = args;
5618 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5619 if (!SWIG_IsOK(res1)) {
5620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5621 }
5622 arg1 = reinterpret_cast< wxPoint * >(argp1);
5623 result = (int) ((arg1)->y);
5624 resultobj = SWIG_From_int(static_cast< int >(result));
5625 return resultobj;
5626 fail:
5627 return NULL;
5628 }
5629
5630
5631 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5632 PyObject *resultobj = 0;
5633 int arg1 = (int) 0 ;
5634 int arg2 = (int) 0 ;
5635 wxPoint *result = 0 ;
5636 int val1 ;
5637 int ecode1 = 0 ;
5638 int val2 ;
5639 int ecode2 = 0 ;
5640 PyObject * obj0 = 0 ;
5641 PyObject * obj1 = 0 ;
5642 char * kwnames[] = {
5643 (char *) "x",(char *) "y", NULL
5644 };
5645
5646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5647 if (obj0) {
5648 ecode1 = SWIG_AsVal_int(obj0, &val1);
5649 if (!SWIG_IsOK(ecode1)) {
5650 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5651 }
5652 arg1 = static_cast< int >(val1);
5653 }
5654 if (obj1) {
5655 ecode2 = SWIG_AsVal_int(obj1, &val2);
5656 if (!SWIG_IsOK(ecode2)) {
5657 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5658 }
5659 arg2 = static_cast< int >(val2);
5660 }
5661 {
5662 PyThreadState* __tstate = wxPyBeginAllowThreads();
5663 result = (wxPoint *)new wxPoint(arg1,arg2);
5664 wxPyEndAllowThreads(__tstate);
5665 if (PyErr_Occurred()) SWIG_fail;
5666 }
5667 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5668 return resultobj;
5669 fail:
5670 return NULL;
5671 }
5672
5673
5674 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5675 PyObject *resultobj = 0;
5676 wxPoint *arg1 = (wxPoint *) 0 ;
5677 void *argp1 = 0 ;
5678 int res1 = 0 ;
5679 PyObject *swig_obj[1] ;
5680
5681 if (!args) SWIG_fail;
5682 swig_obj[0] = args;
5683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5684 if (!SWIG_IsOK(res1)) {
5685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5686 }
5687 arg1 = reinterpret_cast< wxPoint * >(argp1);
5688 {
5689 PyThreadState* __tstate = wxPyBeginAllowThreads();
5690 delete arg1;
5691
5692 wxPyEndAllowThreads(__tstate);
5693 if (PyErr_Occurred()) SWIG_fail;
5694 }
5695 resultobj = SWIG_Py_Void();
5696 return resultobj;
5697 fail:
5698 return NULL;
5699 }
5700
5701
5702 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5703 PyObject *resultobj = 0;
5704 wxPoint *arg1 = (wxPoint *) 0 ;
5705 PyObject *arg2 = (PyObject *) 0 ;
5706 bool result;
5707 void *argp1 = 0 ;
5708 int res1 = 0 ;
5709 PyObject * obj0 = 0 ;
5710 PyObject * obj1 = 0 ;
5711 char * kwnames[] = {
5712 (char *) "self",(char *) "other", NULL
5713 };
5714
5715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5716 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5717 if (!SWIG_IsOK(res1)) {
5718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
5719 }
5720 arg1 = reinterpret_cast< wxPoint * >(argp1);
5721 arg2 = obj1;
5722 {
5723 result = (bool)wxPoint___eq__(arg1,arg2);
5724 if (PyErr_Occurred()) SWIG_fail;
5725 }
5726 {
5727 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5728 }
5729 return resultobj;
5730 fail:
5731 return NULL;
5732 }
5733
5734
5735 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5736 PyObject *resultobj = 0;
5737 wxPoint *arg1 = (wxPoint *) 0 ;
5738 PyObject *arg2 = (PyObject *) 0 ;
5739 bool result;
5740 void *argp1 = 0 ;
5741 int res1 = 0 ;
5742 PyObject * obj0 = 0 ;
5743 PyObject * obj1 = 0 ;
5744 char * kwnames[] = {
5745 (char *) "self",(char *) "other", NULL
5746 };
5747
5748 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5749 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5750 if (!SWIG_IsOK(res1)) {
5751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
5752 }
5753 arg1 = reinterpret_cast< wxPoint * >(argp1);
5754 arg2 = obj1;
5755 {
5756 result = (bool)wxPoint___ne__(arg1,arg2);
5757 if (PyErr_Occurred()) SWIG_fail;
5758 }
5759 {
5760 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5761 }
5762 return resultobj;
5763 fail:
5764 return NULL;
5765 }
5766
5767
5768 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5769 PyObject *resultobj = 0;
5770 wxPoint *arg1 = (wxPoint *) 0 ;
5771 wxPoint *arg2 = 0 ;
5772 wxPoint result;
5773 void *argp1 = 0 ;
5774 int res1 = 0 ;
5775 wxPoint temp2 ;
5776 PyObject * obj0 = 0 ;
5777 PyObject * obj1 = 0 ;
5778 char * kwnames[] = {
5779 (char *) "self",(char *) "pt", NULL
5780 };
5781
5782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5783 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5784 if (!SWIG_IsOK(res1)) {
5785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
5786 }
5787 arg1 = reinterpret_cast< wxPoint * >(argp1);
5788 {
5789 arg2 = &temp2;
5790 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5791 }
5792 {
5793 PyThreadState* __tstate = wxPyBeginAllowThreads();
5794 result = (arg1)->operator +((wxPoint const &)*arg2);
5795 wxPyEndAllowThreads(__tstate);
5796 if (PyErr_Occurred()) SWIG_fail;
5797 }
5798 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5799 return resultobj;
5800 fail:
5801 return NULL;
5802 }
5803
5804
5805 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5806 PyObject *resultobj = 0;
5807 wxPoint *arg1 = (wxPoint *) 0 ;
5808 wxPoint *arg2 = 0 ;
5809 wxPoint result;
5810 void *argp1 = 0 ;
5811 int res1 = 0 ;
5812 wxPoint temp2 ;
5813 PyObject * obj0 = 0 ;
5814 PyObject * obj1 = 0 ;
5815 char * kwnames[] = {
5816 (char *) "self",(char *) "pt", NULL
5817 };
5818
5819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5820 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5821 if (!SWIG_IsOK(res1)) {
5822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5823 }
5824 arg1 = reinterpret_cast< wxPoint * >(argp1);
5825 {
5826 arg2 = &temp2;
5827 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5828 }
5829 {
5830 PyThreadState* __tstate = wxPyBeginAllowThreads();
5831 result = (arg1)->operator -((wxPoint const &)*arg2);
5832 wxPyEndAllowThreads(__tstate);
5833 if (PyErr_Occurred()) SWIG_fail;
5834 }
5835 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5836 return resultobj;
5837 fail:
5838 return NULL;
5839 }
5840
5841
5842 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5843 PyObject *resultobj = 0;
5844 wxPoint *arg1 = (wxPoint *) 0 ;
5845 wxPoint *arg2 = 0 ;
5846 wxPoint *result = 0 ;
5847 void *argp1 = 0 ;
5848 int res1 = 0 ;
5849 wxPoint temp2 ;
5850 PyObject * obj0 = 0 ;
5851 PyObject * obj1 = 0 ;
5852 char * kwnames[] = {
5853 (char *) "self",(char *) "pt", NULL
5854 };
5855
5856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
5857 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5858 if (!SWIG_IsOK(res1)) {
5859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
5860 }
5861 arg1 = reinterpret_cast< wxPoint * >(argp1);
5862 {
5863 arg2 = &temp2;
5864 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5865 }
5866 {
5867 PyThreadState* __tstate = wxPyBeginAllowThreads();
5868 {
5869 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
5870 result = (wxPoint *) &_result_ref;
5871 }
5872 wxPyEndAllowThreads(__tstate);
5873 if (PyErr_Occurred()) SWIG_fail;
5874 }
5875 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5876 return resultobj;
5877 fail:
5878 return NULL;
5879 }
5880
5881
5882 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5883 PyObject *resultobj = 0;
5884 wxPoint *arg1 = (wxPoint *) 0 ;
5885 wxPoint *arg2 = 0 ;
5886 wxPoint *result = 0 ;
5887 void *argp1 = 0 ;
5888 int res1 = 0 ;
5889 wxPoint temp2 ;
5890 PyObject * obj0 = 0 ;
5891 PyObject * obj1 = 0 ;
5892 char * kwnames[] = {
5893 (char *) "self",(char *) "pt", NULL
5894 };
5895
5896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
5897 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5898 if (!SWIG_IsOK(res1)) {
5899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5900 }
5901 arg1 = reinterpret_cast< wxPoint * >(argp1);
5902 {
5903 arg2 = &temp2;
5904 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5905 }
5906 {
5907 PyThreadState* __tstate = wxPyBeginAllowThreads();
5908 {
5909 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
5910 result = (wxPoint *) &_result_ref;
5911 }
5912 wxPyEndAllowThreads(__tstate);
5913 if (PyErr_Occurred()) SWIG_fail;
5914 }
5915 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5916 return resultobj;
5917 fail:
5918 return NULL;
5919 }
5920
5921
5922 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5923 PyObject *resultobj = 0;
5924 wxPoint *arg1 = (wxPoint *) 0 ;
5925 long arg2 ;
5926 long arg3 ;
5927 void *argp1 = 0 ;
5928 int res1 = 0 ;
5929 long val2 ;
5930 int ecode2 = 0 ;
5931 long val3 ;
5932 int ecode3 = 0 ;
5933 PyObject * obj0 = 0 ;
5934 PyObject * obj1 = 0 ;
5935 PyObject * obj2 = 0 ;
5936 char * kwnames[] = {
5937 (char *) "self",(char *) "x",(char *) "y", NULL
5938 };
5939
5940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5941 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5942 if (!SWIG_IsOK(res1)) {
5943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
5944 }
5945 arg1 = reinterpret_cast< wxPoint * >(argp1);
5946 ecode2 = SWIG_AsVal_long(obj1, &val2);
5947 if (!SWIG_IsOK(ecode2)) {
5948 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
5949 }
5950 arg2 = static_cast< long >(val2);
5951 ecode3 = SWIG_AsVal_long(obj2, &val3);
5952 if (!SWIG_IsOK(ecode3)) {
5953 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
5954 }
5955 arg3 = static_cast< long >(val3);
5956 {
5957 PyThreadState* __tstate = wxPyBeginAllowThreads();
5958 wxPoint_Set(arg1,arg2,arg3);
5959 wxPyEndAllowThreads(__tstate);
5960 if (PyErr_Occurred()) SWIG_fail;
5961 }
5962 resultobj = SWIG_Py_Void();
5963 return resultobj;
5964 fail:
5965 return NULL;
5966 }
5967
5968
5969 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5970 PyObject *resultobj = 0;
5971 wxPoint *arg1 = (wxPoint *) 0 ;
5972 PyObject *result = 0 ;
5973 void *argp1 = 0 ;
5974 int res1 = 0 ;
5975 PyObject *swig_obj[1] ;
5976
5977 if (!args) SWIG_fail;
5978 swig_obj[0] = args;
5979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5980 if (!SWIG_IsOK(res1)) {
5981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
5982 }
5983 arg1 = reinterpret_cast< wxPoint * >(argp1);
5984 {
5985 PyThreadState* __tstate = wxPyBeginAllowThreads();
5986 result = (PyObject *)wxPoint_Get(arg1);
5987 wxPyEndAllowThreads(__tstate);
5988 if (PyErr_Occurred()) SWIG_fail;
5989 }
5990 resultobj = result;
5991 return resultobj;
5992 fail:
5993 return NULL;
5994 }
5995
5996
5997 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5998 PyObject *obj;
5999 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6000 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
6001 return SWIG_Py_Void();
6002 }
6003
6004 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6005 return SWIG_Python_InitShadowInstance(args);
6006 }
6007
6008 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6009 PyObject *resultobj = 0;
6010 int arg1 = (int) 0 ;
6011 int arg2 = (int) 0 ;
6012 int arg3 = (int) 0 ;
6013 int arg4 = (int) 0 ;
6014 wxRect *result = 0 ;
6015 int val1 ;
6016 int ecode1 = 0 ;
6017 int val2 ;
6018 int ecode2 = 0 ;
6019 int val3 ;
6020 int ecode3 = 0 ;
6021 int val4 ;
6022 int ecode4 = 0 ;
6023 PyObject * obj0 = 0 ;
6024 PyObject * obj1 = 0 ;
6025 PyObject * obj2 = 0 ;
6026 PyObject * obj3 = 0 ;
6027 char * kwnames[] = {
6028 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6029 };
6030
6031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6032 if (obj0) {
6033 ecode1 = SWIG_AsVal_int(obj0, &val1);
6034 if (!SWIG_IsOK(ecode1)) {
6035 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
6036 }
6037 arg1 = static_cast< int >(val1);
6038 }
6039 if (obj1) {
6040 ecode2 = SWIG_AsVal_int(obj1, &val2);
6041 if (!SWIG_IsOK(ecode2)) {
6042 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
6043 }
6044 arg2 = static_cast< int >(val2);
6045 }
6046 if (obj2) {
6047 ecode3 = SWIG_AsVal_int(obj2, &val3);
6048 if (!SWIG_IsOK(ecode3)) {
6049 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
6050 }
6051 arg3 = static_cast< int >(val3);
6052 }
6053 if (obj3) {
6054 ecode4 = SWIG_AsVal_int(obj3, &val4);
6055 if (!SWIG_IsOK(ecode4)) {
6056 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
6057 }
6058 arg4 = static_cast< int >(val4);
6059 }
6060 {
6061 PyThreadState* __tstate = wxPyBeginAllowThreads();
6062 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
6063 wxPyEndAllowThreads(__tstate);
6064 if (PyErr_Occurred()) SWIG_fail;
6065 }
6066 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
6067 return resultobj;
6068 fail:
6069 return NULL;
6070 }
6071
6072
6073 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6074 PyObject *resultobj = 0;
6075 wxPoint *arg1 = 0 ;
6076 wxPoint *arg2 = 0 ;
6077 wxRect *result = 0 ;
6078 wxPoint temp1 ;
6079 wxPoint temp2 ;
6080 PyObject * obj0 = 0 ;
6081 PyObject * obj1 = 0 ;
6082 char * kwnames[] = {
6083 (char *) "topLeft",(char *) "bottomRight", NULL
6084 };
6085
6086 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
6087 {
6088 arg1 = &temp1;
6089 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6090 }
6091 {
6092 arg2 = &temp2;
6093 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6094 }
6095 {
6096 PyThreadState* __tstate = wxPyBeginAllowThreads();
6097 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6098 wxPyEndAllowThreads(__tstate);
6099 if (PyErr_Occurred()) SWIG_fail;
6100 }
6101 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6102 return resultobj;
6103 fail:
6104 return NULL;
6105 }
6106
6107
6108 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6109 PyObject *resultobj = 0;
6110 wxPoint *arg1 = 0 ;
6111 wxSize *arg2 = 0 ;
6112 wxRect *result = 0 ;
6113 wxPoint temp1 ;
6114 wxSize temp2 ;
6115 PyObject * obj0 = 0 ;
6116 PyObject * obj1 = 0 ;
6117 char * kwnames[] = {
6118 (char *) "pos",(char *) "size", NULL
6119 };
6120
6121 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6122 {
6123 arg1 = &temp1;
6124 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6125 }
6126 {
6127 arg2 = &temp2;
6128 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6129 }
6130 {
6131 PyThreadState* __tstate = wxPyBeginAllowThreads();
6132 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6133 wxPyEndAllowThreads(__tstate);
6134 if (PyErr_Occurred()) SWIG_fail;
6135 }
6136 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6137 return resultobj;
6138 fail:
6139 return NULL;
6140 }
6141
6142
6143 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6144 PyObject *resultobj = 0;
6145 wxSize *arg1 = 0 ;
6146 wxRect *result = 0 ;
6147 wxSize temp1 ;
6148 PyObject * obj0 = 0 ;
6149 char * kwnames[] = {
6150 (char *) "size", NULL
6151 };
6152
6153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6154 {
6155 arg1 = &temp1;
6156 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6157 }
6158 {
6159 PyThreadState* __tstate = wxPyBeginAllowThreads();
6160 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6161 wxPyEndAllowThreads(__tstate);
6162 if (PyErr_Occurred()) SWIG_fail;
6163 }
6164 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6165 return resultobj;
6166 fail:
6167 return NULL;
6168 }
6169
6170
6171 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6172 PyObject *resultobj = 0;
6173 wxRect *arg1 = (wxRect *) 0 ;
6174 void *argp1 = 0 ;
6175 int res1 = 0 ;
6176 PyObject *swig_obj[1] ;
6177
6178 if (!args) SWIG_fail;
6179 swig_obj[0] = args;
6180 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6181 if (!SWIG_IsOK(res1)) {
6182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6183 }
6184 arg1 = reinterpret_cast< wxRect * >(argp1);
6185 {
6186 PyThreadState* __tstate = wxPyBeginAllowThreads();
6187 delete arg1;
6188
6189 wxPyEndAllowThreads(__tstate);
6190 if (PyErr_Occurred()) SWIG_fail;
6191 }
6192 resultobj = SWIG_Py_Void();
6193 return resultobj;
6194 fail:
6195 return NULL;
6196 }
6197
6198
6199 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6200 PyObject *resultobj = 0;
6201 wxRect *arg1 = (wxRect *) 0 ;
6202 int result;
6203 void *argp1 = 0 ;
6204 int res1 = 0 ;
6205 PyObject *swig_obj[1] ;
6206
6207 if (!args) SWIG_fail;
6208 swig_obj[0] = args;
6209 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6210 if (!SWIG_IsOK(res1)) {
6211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6212 }
6213 arg1 = reinterpret_cast< wxRect * >(argp1);
6214 {
6215 PyThreadState* __tstate = wxPyBeginAllowThreads();
6216 result = (int)((wxRect const *)arg1)->GetX();
6217 wxPyEndAllowThreads(__tstate);
6218 if (PyErr_Occurred()) SWIG_fail;
6219 }
6220 resultobj = SWIG_From_int(static_cast< int >(result));
6221 return resultobj;
6222 fail:
6223 return NULL;
6224 }
6225
6226
6227 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6228 PyObject *resultobj = 0;
6229 wxRect *arg1 = (wxRect *) 0 ;
6230 int arg2 ;
6231 void *argp1 = 0 ;
6232 int res1 = 0 ;
6233 int val2 ;
6234 int ecode2 = 0 ;
6235 PyObject * obj0 = 0 ;
6236 PyObject * obj1 = 0 ;
6237 char * kwnames[] = {
6238 (char *) "self",(char *) "x", NULL
6239 };
6240
6241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6243 if (!SWIG_IsOK(res1)) {
6244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6245 }
6246 arg1 = reinterpret_cast< wxRect * >(argp1);
6247 ecode2 = SWIG_AsVal_int(obj1, &val2);
6248 if (!SWIG_IsOK(ecode2)) {
6249 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6250 }
6251 arg2 = static_cast< int >(val2);
6252 {
6253 PyThreadState* __tstate = wxPyBeginAllowThreads();
6254 (arg1)->SetX(arg2);
6255 wxPyEndAllowThreads(__tstate);
6256 if (PyErr_Occurred()) SWIG_fail;
6257 }
6258 resultobj = SWIG_Py_Void();
6259 return resultobj;
6260 fail:
6261 return NULL;
6262 }
6263
6264
6265 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6266 PyObject *resultobj = 0;
6267 wxRect *arg1 = (wxRect *) 0 ;
6268 int result;
6269 void *argp1 = 0 ;
6270 int res1 = 0 ;
6271 PyObject *swig_obj[1] ;
6272
6273 if (!args) SWIG_fail;
6274 swig_obj[0] = args;
6275 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6276 if (!SWIG_IsOK(res1)) {
6277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6278 }
6279 arg1 = reinterpret_cast< wxRect * >(argp1);
6280 {
6281 PyThreadState* __tstate = wxPyBeginAllowThreads();
6282 result = (int)(arg1)->GetY();
6283 wxPyEndAllowThreads(__tstate);
6284 if (PyErr_Occurred()) SWIG_fail;
6285 }
6286 resultobj = SWIG_From_int(static_cast< int >(result));
6287 return resultobj;
6288 fail:
6289 return NULL;
6290 }
6291
6292
6293 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6294 PyObject *resultobj = 0;
6295 wxRect *arg1 = (wxRect *) 0 ;
6296 int arg2 ;
6297 void *argp1 = 0 ;
6298 int res1 = 0 ;
6299 int val2 ;
6300 int ecode2 = 0 ;
6301 PyObject * obj0 = 0 ;
6302 PyObject * obj1 = 0 ;
6303 char * kwnames[] = {
6304 (char *) "self",(char *) "y", NULL
6305 };
6306
6307 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6308 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6309 if (!SWIG_IsOK(res1)) {
6310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6311 }
6312 arg1 = reinterpret_cast< wxRect * >(argp1);
6313 ecode2 = SWIG_AsVal_int(obj1, &val2);
6314 if (!SWIG_IsOK(ecode2)) {
6315 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6316 }
6317 arg2 = static_cast< int >(val2);
6318 {
6319 PyThreadState* __tstate = wxPyBeginAllowThreads();
6320 (arg1)->SetY(arg2);
6321 wxPyEndAllowThreads(__tstate);
6322 if (PyErr_Occurred()) SWIG_fail;
6323 }
6324 resultobj = SWIG_Py_Void();
6325 return resultobj;
6326 fail:
6327 return NULL;
6328 }
6329
6330
6331 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6332 PyObject *resultobj = 0;
6333 wxRect *arg1 = (wxRect *) 0 ;
6334 int result;
6335 void *argp1 = 0 ;
6336 int res1 = 0 ;
6337 PyObject *swig_obj[1] ;
6338
6339 if (!args) SWIG_fail;
6340 swig_obj[0] = args;
6341 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6342 if (!SWIG_IsOK(res1)) {
6343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6344 }
6345 arg1 = reinterpret_cast< wxRect * >(argp1);
6346 {
6347 PyThreadState* __tstate = wxPyBeginAllowThreads();
6348 result = (int)((wxRect const *)arg1)->GetWidth();
6349 wxPyEndAllowThreads(__tstate);
6350 if (PyErr_Occurred()) SWIG_fail;
6351 }
6352 resultobj = SWIG_From_int(static_cast< int >(result));
6353 return resultobj;
6354 fail:
6355 return NULL;
6356 }
6357
6358
6359 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6360 PyObject *resultobj = 0;
6361 wxRect *arg1 = (wxRect *) 0 ;
6362 int arg2 ;
6363 void *argp1 = 0 ;
6364 int res1 = 0 ;
6365 int val2 ;
6366 int ecode2 = 0 ;
6367 PyObject * obj0 = 0 ;
6368 PyObject * obj1 = 0 ;
6369 char * kwnames[] = {
6370 (char *) "self",(char *) "w", NULL
6371 };
6372
6373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6374 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6375 if (!SWIG_IsOK(res1)) {
6376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6377 }
6378 arg1 = reinterpret_cast< wxRect * >(argp1);
6379 ecode2 = SWIG_AsVal_int(obj1, &val2);
6380 if (!SWIG_IsOK(ecode2)) {
6381 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6382 }
6383 arg2 = static_cast< int >(val2);
6384 {
6385 PyThreadState* __tstate = wxPyBeginAllowThreads();
6386 (arg1)->SetWidth(arg2);
6387 wxPyEndAllowThreads(__tstate);
6388 if (PyErr_Occurred()) SWIG_fail;
6389 }
6390 resultobj = SWIG_Py_Void();
6391 return resultobj;
6392 fail:
6393 return NULL;
6394 }
6395
6396
6397 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6398 PyObject *resultobj = 0;
6399 wxRect *arg1 = (wxRect *) 0 ;
6400 int result;
6401 void *argp1 = 0 ;
6402 int res1 = 0 ;
6403 PyObject *swig_obj[1] ;
6404
6405 if (!args) SWIG_fail;
6406 swig_obj[0] = args;
6407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6408 if (!SWIG_IsOK(res1)) {
6409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6410 }
6411 arg1 = reinterpret_cast< wxRect * >(argp1);
6412 {
6413 PyThreadState* __tstate = wxPyBeginAllowThreads();
6414 result = (int)((wxRect const *)arg1)->GetHeight();
6415 wxPyEndAllowThreads(__tstate);
6416 if (PyErr_Occurred()) SWIG_fail;
6417 }
6418 resultobj = SWIG_From_int(static_cast< int >(result));
6419 return resultobj;
6420 fail:
6421 return NULL;
6422 }
6423
6424
6425 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6426 PyObject *resultobj = 0;
6427 wxRect *arg1 = (wxRect *) 0 ;
6428 int arg2 ;
6429 void *argp1 = 0 ;
6430 int res1 = 0 ;
6431 int val2 ;
6432 int ecode2 = 0 ;
6433 PyObject * obj0 = 0 ;
6434 PyObject * obj1 = 0 ;
6435 char * kwnames[] = {
6436 (char *) "self",(char *) "h", NULL
6437 };
6438
6439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6440 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6441 if (!SWIG_IsOK(res1)) {
6442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6443 }
6444 arg1 = reinterpret_cast< wxRect * >(argp1);
6445 ecode2 = SWIG_AsVal_int(obj1, &val2);
6446 if (!SWIG_IsOK(ecode2)) {
6447 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6448 }
6449 arg2 = static_cast< int >(val2);
6450 {
6451 PyThreadState* __tstate = wxPyBeginAllowThreads();
6452 (arg1)->SetHeight(arg2);
6453 wxPyEndAllowThreads(__tstate);
6454 if (PyErr_Occurred()) SWIG_fail;
6455 }
6456 resultobj = SWIG_Py_Void();
6457 return resultobj;
6458 fail:
6459 return NULL;
6460 }
6461
6462
6463 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6464 PyObject *resultobj = 0;
6465 wxRect *arg1 = (wxRect *) 0 ;
6466 wxPoint result;
6467 void *argp1 = 0 ;
6468 int res1 = 0 ;
6469 PyObject *swig_obj[1] ;
6470
6471 if (!args) SWIG_fail;
6472 swig_obj[0] = args;
6473 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6474 if (!SWIG_IsOK(res1)) {
6475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6476 }
6477 arg1 = reinterpret_cast< wxRect * >(argp1);
6478 {
6479 PyThreadState* __tstate = wxPyBeginAllowThreads();
6480 result = ((wxRect const *)arg1)->GetPosition();
6481 wxPyEndAllowThreads(__tstate);
6482 if (PyErr_Occurred()) SWIG_fail;
6483 }
6484 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6485 return resultobj;
6486 fail:
6487 return NULL;
6488 }
6489
6490
6491 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6492 PyObject *resultobj = 0;
6493 wxRect *arg1 = (wxRect *) 0 ;
6494 wxPoint *arg2 = 0 ;
6495 void *argp1 = 0 ;
6496 int res1 = 0 ;
6497 wxPoint temp2 ;
6498 PyObject * obj0 = 0 ;
6499 PyObject * obj1 = 0 ;
6500 char * kwnames[] = {
6501 (char *) "self",(char *) "p", NULL
6502 };
6503
6504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6505 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6506 if (!SWIG_IsOK(res1)) {
6507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6508 }
6509 arg1 = reinterpret_cast< wxRect * >(argp1);
6510 {
6511 arg2 = &temp2;
6512 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6513 }
6514 {
6515 PyThreadState* __tstate = wxPyBeginAllowThreads();
6516 (arg1)->SetPosition((wxPoint const &)*arg2);
6517 wxPyEndAllowThreads(__tstate);
6518 if (PyErr_Occurred()) SWIG_fail;
6519 }
6520 resultobj = SWIG_Py_Void();
6521 return resultobj;
6522 fail:
6523 return NULL;
6524 }
6525
6526
6527 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6528 PyObject *resultobj = 0;
6529 wxRect *arg1 = (wxRect *) 0 ;
6530 wxSize result;
6531 void *argp1 = 0 ;
6532 int res1 = 0 ;
6533 PyObject *swig_obj[1] ;
6534
6535 if (!args) SWIG_fail;
6536 swig_obj[0] = args;
6537 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6538 if (!SWIG_IsOK(res1)) {
6539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6540 }
6541 arg1 = reinterpret_cast< wxRect * >(argp1);
6542 {
6543 PyThreadState* __tstate = wxPyBeginAllowThreads();
6544 result = ((wxRect const *)arg1)->GetSize();
6545 wxPyEndAllowThreads(__tstate);
6546 if (PyErr_Occurred()) SWIG_fail;
6547 }
6548 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6549 return resultobj;
6550 fail:
6551 return NULL;
6552 }
6553
6554
6555 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6556 PyObject *resultobj = 0;
6557 wxRect *arg1 = (wxRect *) 0 ;
6558 wxSize *arg2 = 0 ;
6559 void *argp1 = 0 ;
6560 int res1 = 0 ;
6561 wxSize temp2 ;
6562 PyObject * obj0 = 0 ;
6563 PyObject * obj1 = 0 ;
6564 char * kwnames[] = {
6565 (char *) "self",(char *) "s", NULL
6566 };
6567
6568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6569 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6570 if (!SWIG_IsOK(res1)) {
6571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6572 }
6573 arg1 = reinterpret_cast< wxRect * >(argp1);
6574 {
6575 arg2 = &temp2;
6576 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6577 }
6578 {
6579 PyThreadState* __tstate = wxPyBeginAllowThreads();
6580 (arg1)->SetSize((wxSize const &)*arg2);
6581 wxPyEndAllowThreads(__tstate);
6582 if (PyErr_Occurred()) SWIG_fail;
6583 }
6584 resultobj = SWIG_Py_Void();
6585 return resultobj;
6586 fail:
6587 return NULL;
6588 }
6589
6590
6591 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6592 PyObject *resultobj = 0;
6593 wxRect *arg1 = (wxRect *) 0 ;
6594 bool result;
6595 void *argp1 = 0 ;
6596 int res1 = 0 ;
6597 PyObject *swig_obj[1] ;
6598
6599 if (!args) SWIG_fail;
6600 swig_obj[0] = args;
6601 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6602 if (!SWIG_IsOK(res1)) {
6603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6604 }
6605 arg1 = reinterpret_cast< wxRect * >(argp1);
6606 {
6607 PyThreadState* __tstate = wxPyBeginAllowThreads();
6608 result = (bool)((wxRect const *)arg1)->IsEmpty();
6609 wxPyEndAllowThreads(__tstate);
6610 if (PyErr_Occurred()) SWIG_fail;
6611 }
6612 {
6613 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6614 }
6615 return resultobj;
6616 fail:
6617 return NULL;
6618 }
6619
6620
6621 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6622 PyObject *resultobj = 0;
6623 wxRect *arg1 = (wxRect *) 0 ;
6624 wxPoint result;
6625 void *argp1 = 0 ;
6626 int res1 = 0 ;
6627 PyObject *swig_obj[1] ;
6628
6629 if (!args) SWIG_fail;
6630 swig_obj[0] = args;
6631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6632 if (!SWIG_IsOK(res1)) {
6633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6634 }
6635 arg1 = reinterpret_cast< wxRect * >(argp1);
6636 {
6637 PyThreadState* __tstate = wxPyBeginAllowThreads();
6638 result = ((wxRect const *)arg1)->GetTopLeft();
6639 wxPyEndAllowThreads(__tstate);
6640 if (PyErr_Occurred()) SWIG_fail;
6641 }
6642 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6643 return resultobj;
6644 fail:
6645 return NULL;
6646 }
6647
6648
6649 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6650 PyObject *resultobj = 0;
6651 wxRect *arg1 = (wxRect *) 0 ;
6652 wxPoint *arg2 = 0 ;
6653 void *argp1 = 0 ;
6654 int res1 = 0 ;
6655 wxPoint temp2 ;
6656 PyObject * obj0 = 0 ;
6657 PyObject * obj1 = 0 ;
6658 char * kwnames[] = {
6659 (char *) "self",(char *) "p", NULL
6660 };
6661
6662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6664 if (!SWIG_IsOK(res1)) {
6665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6666 }
6667 arg1 = reinterpret_cast< wxRect * >(argp1);
6668 {
6669 arg2 = &temp2;
6670 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6671 }
6672 {
6673 PyThreadState* __tstate = wxPyBeginAllowThreads();
6674 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6675 wxPyEndAllowThreads(__tstate);
6676 if (PyErr_Occurred()) SWIG_fail;
6677 }
6678 resultobj = SWIG_Py_Void();
6679 return resultobj;
6680 fail:
6681 return NULL;
6682 }
6683
6684
6685 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6686 PyObject *resultobj = 0;
6687 wxRect *arg1 = (wxRect *) 0 ;
6688 wxPoint result;
6689 void *argp1 = 0 ;
6690 int res1 = 0 ;
6691 PyObject *swig_obj[1] ;
6692
6693 if (!args) SWIG_fail;
6694 swig_obj[0] = args;
6695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6696 if (!SWIG_IsOK(res1)) {
6697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6698 }
6699 arg1 = reinterpret_cast< wxRect * >(argp1);
6700 {
6701 PyThreadState* __tstate = wxPyBeginAllowThreads();
6702 result = ((wxRect const *)arg1)->GetBottomRight();
6703 wxPyEndAllowThreads(__tstate);
6704 if (PyErr_Occurred()) SWIG_fail;
6705 }
6706 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6707 return resultobj;
6708 fail:
6709 return NULL;
6710 }
6711
6712
6713 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6714 PyObject *resultobj = 0;
6715 wxRect *arg1 = (wxRect *) 0 ;
6716 wxPoint *arg2 = 0 ;
6717 void *argp1 = 0 ;
6718 int res1 = 0 ;
6719 wxPoint temp2 ;
6720 PyObject * obj0 = 0 ;
6721 PyObject * obj1 = 0 ;
6722 char * kwnames[] = {
6723 (char *) "self",(char *) "p", NULL
6724 };
6725
6726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6727 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6728 if (!SWIG_IsOK(res1)) {
6729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6730 }
6731 arg1 = reinterpret_cast< wxRect * >(argp1);
6732 {
6733 arg2 = &temp2;
6734 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6735 }
6736 {
6737 PyThreadState* __tstate = wxPyBeginAllowThreads();
6738 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6739 wxPyEndAllowThreads(__tstate);
6740 if (PyErr_Occurred()) SWIG_fail;
6741 }
6742 resultobj = SWIG_Py_Void();
6743 return resultobj;
6744 fail:
6745 return NULL;
6746 }
6747
6748
6749 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6750 PyObject *resultobj = 0;
6751 wxRect *arg1 = (wxRect *) 0 ;
6752 int result;
6753 void *argp1 = 0 ;
6754 int res1 = 0 ;
6755 PyObject *swig_obj[1] ;
6756
6757 if (!args) SWIG_fail;
6758 swig_obj[0] = args;
6759 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6760 if (!SWIG_IsOK(res1)) {
6761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6762 }
6763 arg1 = reinterpret_cast< wxRect * >(argp1);
6764 {
6765 PyThreadState* __tstate = wxPyBeginAllowThreads();
6766 result = (int)((wxRect const *)arg1)->GetLeft();
6767 wxPyEndAllowThreads(__tstate);
6768 if (PyErr_Occurred()) SWIG_fail;
6769 }
6770 resultobj = SWIG_From_int(static_cast< int >(result));
6771 return resultobj;
6772 fail:
6773 return NULL;
6774 }
6775
6776
6777 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6778 PyObject *resultobj = 0;
6779 wxRect *arg1 = (wxRect *) 0 ;
6780 int result;
6781 void *argp1 = 0 ;
6782 int res1 = 0 ;
6783 PyObject *swig_obj[1] ;
6784
6785 if (!args) SWIG_fail;
6786 swig_obj[0] = args;
6787 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6788 if (!SWIG_IsOK(res1)) {
6789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
6790 }
6791 arg1 = reinterpret_cast< wxRect * >(argp1);
6792 {
6793 PyThreadState* __tstate = wxPyBeginAllowThreads();
6794 result = (int)((wxRect const *)arg1)->GetTop();
6795 wxPyEndAllowThreads(__tstate);
6796 if (PyErr_Occurred()) SWIG_fail;
6797 }
6798 resultobj = SWIG_From_int(static_cast< int >(result));
6799 return resultobj;
6800 fail:
6801 return NULL;
6802 }
6803
6804
6805 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6806 PyObject *resultobj = 0;
6807 wxRect *arg1 = (wxRect *) 0 ;
6808 int result;
6809 void *argp1 = 0 ;
6810 int res1 = 0 ;
6811 PyObject *swig_obj[1] ;
6812
6813 if (!args) SWIG_fail;
6814 swig_obj[0] = args;
6815 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6816 if (!SWIG_IsOK(res1)) {
6817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
6818 }
6819 arg1 = reinterpret_cast< wxRect * >(argp1);
6820 {
6821 PyThreadState* __tstate = wxPyBeginAllowThreads();
6822 result = (int)((wxRect const *)arg1)->GetBottom();
6823 wxPyEndAllowThreads(__tstate);
6824 if (PyErr_Occurred()) SWIG_fail;
6825 }
6826 resultobj = SWIG_From_int(static_cast< int >(result));
6827 return resultobj;
6828 fail:
6829 return NULL;
6830 }
6831
6832
6833 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6834 PyObject *resultobj = 0;
6835 wxRect *arg1 = (wxRect *) 0 ;
6836 int result;
6837 void *argp1 = 0 ;
6838 int res1 = 0 ;
6839 PyObject *swig_obj[1] ;
6840
6841 if (!args) SWIG_fail;
6842 swig_obj[0] = args;
6843 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6844 if (!SWIG_IsOK(res1)) {
6845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6846 }
6847 arg1 = reinterpret_cast< wxRect * >(argp1);
6848 {
6849 PyThreadState* __tstate = wxPyBeginAllowThreads();
6850 result = (int)((wxRect const *)arg1)->GetRight();
6851 wxPyEndAllowThreads(__tstate);
6852 if (PyErr_Occurred()) SWIG_fail;
6853 }
6854 resultobj = SWIG_From_int(static_cast< int >(result));
6855 return resultobj;
6856 fail:
6857 return NULL;
6858 }
6859
6860
6861 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6862 PyObject *resultobj = 0;
6863 wxRect *arg1 = (wxRect *) 0 ;
6864 int arg2 ;
6865 void *argp1 = 0 ;
6866 int res1 = 0 ;
6867 int val2 ;
6868 int ecode2 = 0 ;
6869 PyObject * obj0 = 0 ;
6870 PyObject * obj1 = 0 ;
6871 char * kwnames[] = {
6872 (char *) "self",(char *) "left", NULL
6873 };
6874
6875 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6876 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6877 if (!SWIG_IsOK(res1)) {
6878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6879 }
6880 arg1 = reinterpret_cast< wxRect * >(argp1);
6881 ecode2 = SWIG_AsVal_int(obj1, &val2);
6882 if (!SWIG_IsOK(ecode2)) {
6883 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
6884 }
6885 arg2 = static_cast< int >(val2);
6886 {
6887 PyThreadState* __tstate = wxPyBeginAllowThreads();
6888 (arg1)->SetLeft(arg2);
6889 wxPyEndAllowThreads(__tstate);
6890 if (PyErr_Occurred()) SWIG_fail;
6891 }
6892 resultobj = SWIG_Py_Void();
6893 return resultobj;
6894 fail:
6895 return NULL;
6896 }
6897
6898
6899 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6900 PyObject *resultobj = 0;
6901 wxRect *arg1 = (wxRect *) 0 ;
6902 int arg2 ;
6903 void *argp1 = 0 ;
6904 int res1 = 0 ;
6905 int val2 ;
6906 int ecode2 = 0 ;
6907 PyObject * obj0 = 0 ;
6908 PyObject * obj1 = 0 ;
6909 char * kwnames[] = {
6910 (char *) "self",(char *) "right", NULL
6911 };
6912
6913 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
6914 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6915 if (!SWIG_IsOK(res1)) {
6916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
6917 }
6918 arg1 = reinterpret_cast< wxRect * >(argp1);
6919 ecode2 = SWIG_AsVal_int(obj1, &val2);
6920 if (!SWIG_IsOK(ecode2)) {
6921 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
6922 }
6923 arg2 = static_cast< int >(val2);
6924 {
6925 PyThreadState* __tstate = wxPyBeginAllowThreads();
6926 (arg1)->SetRight(arg2);
6927 wxPyEndAllowThreads(__tstate);
6928 if (PyErr_Occurred()) SWIG_fail;
6929 }
6930 resultobj = SWIG_Py_Void();
6931 return resultobj;
6932 fail:
6933 return NULL;
6934 }
6935
6936
6937 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6938 PyObject *resultobj = 0;
6939 wxRect *arg1 = (wxRect *) 0 ;
6940 int arg2 ;
6941 void *argp1 = 0 ;
6942 int res1 = 0 ;
6943 int val2 ;
6944 int ecode2 = 0 ;
6945 PyObject * obj0 = 0 ;
6946 PyObject * obj1 = 0 ;
6947 char * kwnames[] = {
6948 (char *) "self",(char *) "top", NULL
6949 };
6950
6951 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
6952 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6953 if (!SWIG_IsOK(res1)) {
6954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
6955 }
6956 arg1 = reinterpret_cast< wxRect * >(argp1);
6957 ecode2 = SWIG_AsVal_int(obj1, &val2);
6958 if (!SWIG_IsOK(ecode2)) {
6959 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
6960 }
6961 arg2 = static_cast< int >(val2);
6962 {
6963 PyThreadState* __tstate = wxPyBeginAllowThreads();
6964 (arg1)->SetTop(arg2);
6965 wxPyEndAllowThreads(__tstate);
6966 if (PyErr_Occurred()) SWIG_fail;
6967 }
6968 resultobj = SWIG_Py_Void();
6969 return resultobj;
6970 fail:
6971 return NULL;
6972 }
6973
6974
6975 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6976 PyObject *resultobj = 0;
6977 wxRect *arg1 = (wxRect *) 0 ;
6978 int arg2 ;
6979 void *argp1 = 0 ;
6980 int res1 = 0 ;
6981 int val2 ;
6982 int ecode2 = 0 ;
6983 PyObject * obj0 = 0 ;
6984 PyObject * obj1 = 0 ;
6985 char * kwnames[] = {
6986 (char *) "self",(char *) "bottom", NULL
6987 };
6988
6989 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
6990 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6991 if (!SWIG_IsOK(res1)) {
6992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
6993 }
6994 arg1 = reinterpret_cast< wxRect * >(argp1);
6995 ecode2 = SWIG_AsVal_int(obj1, &val2);
6996 if (!SWIG_IsOK(ecode2)) {
6997 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
6998 }
6999 arg2 = static_cast< int >(val2);
7000 {
7001 PyThreadState* __tstate = wxPyBeginAllowThreads();
7002 (arg1)->SetBottom(arg2);
7003 wxPyEndAllowThreads(__tstate);
7004 if (PyErr_Occurred()) SWIG_fail;
7005 }
7006 resultobj = SWIG_Py_Void();
7007 return resultobj;
7008 fail:
7009 return NULL;
7010 }
7011
7012
7013 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7014 PyObject *resultobj = 0;
7015 wxRect *arg1 = (wxRect *) 0 ;
7016 int arg2 ;
7017 int arg3 ;
7018 wxRect *result = 0 ;
7019 void *argp1 = 0 ;
7020 int res1 = 0 ;
7021 int val2 ;
7022 int ecode2 = 0 ;
7023 int val3 ;
7024 int ecode3 = 0 ;
7025 PyObject * obj0 = 0 ;
7026 PyObject * obj1 = 0 ;
7027 PyObject * obj2 = 0 ;
7028 char * kwnames[] = {
7029 (char *) "self",(char *) "dx",(char *) "dy", NULL
7030 };
7031
7032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7033 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7034 if (!SWIG_IsOK(res1)) {
7035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
7036 }
7037 arg1 = reinterpret_cast< wxRect * >(argp1);
7038 ecode2 = SWIG_AsVal_int(obj1, &val2);
7039 if (!SWIG_IsOK(ecode2)) {
7040 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
7041 }
7042 arg2 = static_cast< int >(val2);
7043 ecode3 = SWIG_AsVal_int(obj2, &val3);
7044 if (!SWIG_IsOK(ecode3)) {
7045 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
7046 }
7047 arg3 = static_cast< int >(val3);
7048 {
7049 PyThreadState* __tstate = wxPyBeginAllowThreads();
7050 {
7051 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
7052 result = (wxRect *) &_result_ref;
7053 }
7054 wxPyEndAllowThreads(__tstate);
7055 if (PyErr_Occurred()) SWIG_fail;
7056 }
7057 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7058 return resultobj;
7059 fail:
7060 return NULL;
7061 }
7062
7063
7064 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7065 PyObject *resultobj = 0;
7066 wxRect *arg1 = (wxRect *) 0 ;
7067 int arg2 ;
7068 int arg3 ;
7069 wxRect *result = 0 ;
7070 void *argp1 = 0 ;
7071 int res1 = 0 ;
7072 int val2 ;
7073 int ecode2 = 0 ;
7074 int val3 ;
7075 int ecode3 = 0 ;
7076 PyObject * obj0 = 0 ;
7077 PyObject * obj1 = 0 ;
7078 PyObject * obj2 = 0 ;
7079 char * kwnames[] = {
7080 (char *) "self",(char *) "dx",(char *) "dy", NULL
7081 };
7082
7083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7085 if (!SWIG_IsOK(res1)) {
7086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
7087 }
7088 arg1 = reinterpret_cast< wxRect * >(argp1);
7089 ecode2 = SWIG_AsVal_int(obj1, &val2);
7090 if (!SWIG_IsOK(ecode2)) {
7091 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7092 }
7093 arg2 = static_cast< int >(val2);
7094 ecode3 = SWIG_AsVal_int(obj2, &val3);
7095 if (!SWIG_IsOK(ecode3)) {
7096 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7097 }
7098 arg3 = static_cast< int >(val3);
7099 {
7100 PyThreadState* __tstate = wxPyBeginAllowThreads();
7101 {
7102 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7103 result = (wxRect *) &_result_ref;
7104 }
7105 wxPyEndAllowThreads(__tstate);
7106 if (PyErr_Occurred()) SWIG_fail;
7107 }
7108 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7109 return resultobj;
7110 fail:
7111 return NULL;
7112 }
7113
7114
7115 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7116 PyObject *resultobj = 0;
7117 wxRect *arg1 = (wxRect *) 0 ;
7118 int arg2 ;
7119 int arg3 ;
7120 void *argp1 = 0 ;
7121 int res1 = 0 ;
7122 int val2 ;
7123 int ecode2 = 0 ;
7124 int val3 ;
7125 int ecode3 = 0 ;
7126 PyObject * obj0 = 0 ;
7127 PyObject * obj1 = 0 ;
7128 PyObject * obj2 = 0 ;
7129 char * kwnames[] = {
7130 (char *) "self",(char *) "dx",(char *) "dy", NULL
7131 };
7132
7133 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7134 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7135 if (!SWIG_IsOK(res1)) {
7136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7137 }
7138 arg1 = reinterpret_cast< wxRect * >(argp1);
7139 ecode2 = SWIG_AsVal_int(obj1, &val2);
7140 if (!SWIG_IsOK(ecode2)) {
7141 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7142 }
7143 arg2 = static_cast< int >(val2);
7144 ecode3 = SWIG_AsVal_int(obj2, &val3);
7145 if (!SWIG_IsOK(ecode3)) {
7146 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7147 }
7148 arg3 = static_cast< int >(val3);
7149 {
7150 PyThreadState* __tstate = wxPyBeginAllowThreads();
7151 (arg1)->Offset(arg2,arg3);
7152 wxPyEndAllowThreads(__tstate);
7153 if (PyErr_Occurred()) SWIG_fail;
7154 }
7155 resultobj = SWIG_Py_Void();
7156 return resultobj;
7157 fail:
7158 return NULL;
7159 }
7160
7161
7162 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7163 PyObject *resultobj = 0;
7164 wxRect *arg1 = (wxRect *) 0 ;
7165 wxPoint *arg2 = 0 ;
7166 void *argp1 = 0 ;
7167 int res1 = 0 ;
7168 wxPoint temp2 ;
7169 PyObject * obj0 = 0 ;
7170 PyObject * obj1 = 0 ;
7171 char * kwnames[] = {
7172 (char *) "self",(char *) "pt", NULL
7173 };
7174
7175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7177 if (!SWIG_IsOK(res1)) {
7178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7179 }
7180 arg1 = reinterpret_cast< wxRect * >(argp1);
7181 {
7182 arg2 = &temp2;
7183 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7184 }
7185 {
7186 PyThreadState* __tstate = wxPyBeginAllowThreads();
7187 (arg1)->Offset((wxPoint const &)*arg2);
7188 wxPyEndAllowThreads(__tstate);
7189 if (PyErr_Occurred()) SWIG_fail;
7190 }
7191 resultobj = SWIG_Py_Void();
7192 return resultobj;
7193 fail:
7194 return NULL;
7195 }
7196
7197
7198 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7199 PyObject *resultobj = 0;
7200 wxRect *arg1 = (wxRect *) 0 ;
7201 wxRect *arg2 = 0 ;
7202 wxRect result;
7203 void *argp1 = 0 ;
7204 int res1 = 0 ;
7205 wxRect temp2 ;
7206 PyObject * obj0 = 0 ;
7207 PyObject * obj1 = 0 ;
7208 char * kwnames[] = {
7209 (char *) "self",(char *) "rect", NULL
7210 };
7211
7212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7214 if (!SWIG_IsOK(res1)) {
7215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7216 }
7217 arg1 = reinterpret_cast< wxRect * >(argp1);
7218 {
7219 arg2 = &temp2;
7220 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7221 }
7222 {
7223 PyThreadState* __tstate = wxPyBeginAllowThreads();
7224 result = (arg1)->Intersect((wxRect const &)*arg2);
7225 wxPyEndAllowThreads(__tstate);
7226 if (PyErr_Occurred()) SWIG_fail;
7227 }
7228 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7229 return resultobj;
7230 fail:
7231 return NULL;
7232 }
7233
7234
7235 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7236 PyObject *resultobj = 0;
7237 wxRect *arg1 = (wxRect *) 0 ;
7238 wxRect *arg2 = 0 ;
7239 wxRect result;
7240 void *argp1 = 0 ;
7241 int res1 = 0 ;
7242 wxRect temp2 ;
7243 PyObject * obj0 = 0 ;
7244 PyObject * obj1 = 0 ;
7245 char * kwnames[] = {
7246 (char *) "self",(char *) "rect", NULL
7247 };
7248
7249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7250 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7251 if (!SWIG_IsOK(res1)) {
7252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7253 }
7254 arg1 = reinterpret_cast< wxRect * >(argp1);
7255 {
7256 arg2 = &temp2;
7257 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7258 }
7259 {
7260 PyThreadState* __tstate = wxPyBeginAllowThreads();
7261 result = (arg1)->Union((wxRect const &)*arg2);
7262 wxPyEndAllowThreads(__tstate);
7263 if (PyErr_Occurred()) SWIG_fail;
7264 }
7265 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7266 return resultobj;
7267 fail:
7268 return NULL;
7269 }
7270
7271
7272 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7273 PyObject *resultobj = 0;
7274 wxRect *arg1 = (wxRect *) 0 ;
7275 wxRect *arg2 = 0 ;
7276 wxRect result;
7277 void *argp1 = 0 ;
7278 int res1 = 0 ;
7279 wxRect temp2 ;
7280 PyObject * obj0 = 0 ;
7281 PyObject * obj1 = 0 ;
7282 char * kwnames[] = {
7283 (char *) "self",(char *) "rect", NULL
7284 };
7285
7286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7287 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7288 if (!SWIG_IsOK(res1)) {
7289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7290 }
7291 arg1 = reinterpret_cast< wxRect * >(argp1);
7292 {
7293 arg2 = &temp2;
7294 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7295 }
7296 {
7297 PyThreadState* __tstate = wxPyBeginAllowThreads();
7298 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7299 wxPyEndAllowThreads(__tstate);
7300 if (PyErr_Occurred()) SWIG_fail;
7301 }
7302 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7303 return resultobj;
7304 fail:
7305 return NULL;
7306 }
7307
7308
7309 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7310 PyObject *resultobj = 0;
7311 wxRect *arg1 = (wxRect *) 0 ;
7312 wxRect *arg2 = 0 ;
7313 wxRect *result = 0 ;
7314 void *argp1 = 0 ;
7315 int res1 = 0 ;
7316 wxRect temp2 ;
7317 PyObject * obj0 = 0 ;
7318 PyObject * obj1 = 0 ;
7319 char * kwnames[] = {
7320 (char *) "self",(char *) "rect", NULL
7321 };
7322
7323 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7324 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7325 if (!SWIG_IsOK(res1)) {
7326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7327 }
7328 arg1 = reinterpret_cast< wxRect * >(argp1);
7329 {
7330 arg2 = &temp2;
7331 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7332 }
7333 {
7334 PyThreadState* __tstate = wxPyBeginAllowThreads();
7335 {
7336 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7337 result = (wxRect *) &_result_ref;
7338 }
7339 wxPyEndAllowThreads(__tstate);
7340 if (PyErr_Occurred()) SWIG_fail;
7341 }
7342 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7343 return resultobj;
7344 fail:
7345 return NULL;
7346 }
7347
7348
7349 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7350 PyObject *resultobj = 0;
7351 wxRect *arg1 = (wxRect *) 0 ;
7352 PyObject *arg2 = (PyObject *) 0 ;
7353 bool result;
7354 void *argp1 = 0 ;
7355 int res1 = 0 ;
7356 PyObject * obj0 = 0 ;
7357 PyObject * obj1 = 0 ;
7358 char * kwnames[] = {
7359 (char *) "self",(char *) "other", NULL
7360 };
7361
7362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7363 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7364 if (!SWIG_IsOK(res1)) {
7365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect *""'");
7366 }
7367 arg1 = reinterpret_cast< wxRect * >(argp1);
7368 arg2 = obj1;
7369 {
7370 result = (bool)wxRect___eq__(arg1,arg2);
7371 if (PyErr_Occurred()) SWIG_fail;
7372 }
7373 {
7374 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7375 }
7376 return resultobj;
7377 fail:
7378 return NULL;
7379 }
7380
7381
7382 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7383 PyObject *resultobj = 0;
7384 wxRect *arg1 = (wxRect *) 0 ;
7385 PyObject *arg2 = (PyObject *) 0 ;
7386 bool result;
7387 void *argp1 = 0 ;
7388 int res1 = 0 ;
7389 PyObject * obj0 = 0 ;
7390 PyObject * obj1 = 0 ;
7391 char * kwnames[] = {
7392 (char *) "self",(char *) "other", NULL
7393 };
7394
7395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7396 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7397 if (!SWIG_IsOK(res1)) {
7398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect *""'");
7399 }
7400 arg1 = reinterpret_cast< wxRect * >(argp1);
7401 arg2 = obj1;
7402 {
7403 result = (bool)wxRect___ne__(arg1,arg2);
7404 if (PyErr_Occurred()) SWIG_fail;
7405 }
7406 {
7407 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7408 }
7409 return resultobj;
7410 fail:
7411 return NULL;
7412 }
7413
7414
7415 SWIGINTERN PyObject *_wrap_Rect_InsideXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7416 PyObject *resultobj = 0;
7417 wxRect *arg1 = (wxRect *) 0 ;
7418 int arg2 ;
7419 int arg3 ;
7420 bool result;
7421 void *argp1 = 0 ;
7422 int res1 = 0 ;
7423 int val2 ;
7424 int ecode2 = 0 ;
7425 int val3 ;
7426 int ecode3 = 0 ;
7427 PyObject * obj0 = 0 ;
7428 PyObject * obj1 = 0 ;
7429 PyObject * obj2 = 0 ;
7430 char * kwnames[] = {
7431 (char *) "self",(char *) "x",(char *) "y", NULL
7432 };
7433
7434 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7435 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7436 if (!SWIG_IsOK(res1)) {
7437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_InsideXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7438 }
7439 arg1 = reinterpret_cast< wxRect * >(argp1);
7440 ecode2 = SWIG_AsVal_int(obj1, &val2);
7441 if (!SWIG_IsOK(ecode2)) {
7442 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_InsideXY" "', expected argument " "2"" of type '" "int""'");
7443 }
7444 arg2 = static_cast< int >(val2);
7445 ecode3 = SWIG_AsVal_int(obj2, &val3);
7446 if (!SWIG_IsOK(ecode3)) {
7447 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_InsideXY" "', expected argument " "3"" of type '" "int""'");
7448 }
7449 arg3 = static_cast< int >(val3);
7450 {
7451 PyThreadState* __tstate = wxPyBeginAllowThreads();
7452 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
7453 wxPyEndAllowThreads(__tstate);
7454 if (PyErr_Occurred()) SWIG_fail;
7455 }
7456 {
7457 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7458 }
7459 return resultobj;
7460 fail:
7461 return NULL;
7462 }
7463
7464
7465 SWIGINTERN PyObject *_wrap_Rect_Inside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7466 PyObject *resultobj = 0;
7467 wxRect *arg1 = (wxRect *) 0 ;
7468 wxPoint *arg2 = 0 ;
7469 bool result;
7470 void *argp1 = 0 ;
7471 int res1 = 0 ;
7472 wxPoint temp2 ;
7473 PyObject * obj0 = 0 ;
7474 PyObject * obj1 = 0 ;
7475 char * kwnames[] = {
7476 (char *) "self",(char *) "pt", NULL
7477 };
7478
7479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) SWIG_fail;
7480 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7481 if (!SWIG_IsOK(res1)) {
7482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inside" "', expected argument " "1"" of type '" "wxRect const *""'");
7483 }
7484 arg1 = reinterpret_cast< wxRect * >(argp1);
7485 {
7486 arg2 = &temp2;
7487 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7488 }
7489 {
7490 PyThreadState* __tstate = wxPyBeginAllowThreads();
7491 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
7492 wxPyEndAllowThreads(__tstate);
7493 if (PyErr_Occurred()) SWIG_fail;
7494 }
7495 {
7496 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7497 }
7498 return resultobj;
7499 fail:
7500 return NULL;
7501 }
7502
7503
7504 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7505 PyObject *resultobj = 0;
7506 wxRect *arg1 = (wxRect *) 0 ;
7507 wxRect *arg2 = 0 ;
7508 bool result;
7509 void *argp1 = 0 ;
7510 int res1 = 0 ;
7511 wxRect temp2 ;
7512 PyObject * obj0 = 0 ;
7513 PyObject * obj1 = 0 ;
7514 char * kwnames[] = {
7515 (char *) "self",(char *) "rect", NULL
7516 };
7517
7518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7520 if (!SWIG_IsOK(res1)) {
7521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7522 }
7523 arg1 = reinterpret_cast< wxRect * >(argp1);
7524 {
7525 arg2 = &temp2;
7526 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7527 }
7528 {
7529 PyThreadState* __tstate = wxPyBeginAllowThreads();
7530 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7531 wxPyEndAllowThreads(__tstate);
7532 if (PyErr_Occurred()) SWIG_fail;
7533 }
7534 {
7535 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7536 }
7537 return resultobj;
7538 fail:
7539 return NULL;
7540 }
7541
7542
7543 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7544 PyObject *resultobj = 0;
7545 wxRect *arg1 = (wxRect *) 0 ;
7546 wxRect *arg2 = 0 ;
7547 int arg3 = (int) wxBOTH ;
7548 wxRect result;
7549 void *argp1 = 0 ;
7550 int res1 = 0 ;
7551 wxRect temp2 ;
7552 int val3 ;
7553 int ecode3 = 0 ;
7554 PyObject * obj0 = 0 ;
7555 PyObject * obj1 = 0 ;
7556 PyObject * obj2 = 0 ;
7557 char * kwnames[] = {
7558 (char *) "self",(char *) "r",(char *) "dir", NULL
7559 };
7560
7561 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7562 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7563 if (!SWIG_IsOK(res1)) {
7564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7565 }
7566 arg1 = reinterpret_cast< wxRect * >(argp1);
7567 {
7568 arg2 = &temp2;
7569 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7570 }
7571 if (obj2) {
7572 ecode3 = SWIG_AsVal_int(obj2, &val3);
7573 if (!SWIG_IsOK(ecode3)) {
7574 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7575 }
7576 arg3 = static_cast< int >(val3);
7577 }
7578 {
7579 PyThreadState* __tstate = wxPyBeginAllowThreads();
7580 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7581 wxPyEndAllowThreads(__tstate);
7582 if (PyErr_Occurred()) SWIG_fail;
7583 }
7584 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7585 return resultobj;
7586 fail:
7587 return NULL;
7588 }
7589
7590
7591 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7592 PyObject *resultobj = 0;
7593 wxRect *arg1 = (wxRect *) 0 ;
7594 int arg2 ;
7595 void *argp1 = 0 ;
7596 int res1 = 0 ;
7597 int val2 ;
7598 int ecode2 = 0 ;
7599 PyObject *swig_obj[2] ;
7600
7601 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7602 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7603 if (!SWIG_IsOK(res1)) {
7604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7605 }
7606 arg1 = reinterpret_cast< wxRect * >(argp1);
7607 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7608 if (!SWIG_IsOK(ecode2)) {
7609 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7610 }
7611 arg2 = static_cast< int >(val2);
7612 if (arg1) (arg1)->x = arg2;
7613
7614 resultobj = SWIG_Py_Void();
7615 return resultobj;
7616 fail:
7617 return NULL;
7618 }
7619
7620
7621 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7622 PyObject *resultobj = 0;
7623 wxRect *arg1 = (wxRect *) 0 ;
7624 int result;
7625 void *argp1 = 0 ;
7626 int res1 = 0 ;
7627 PyObject *swig_obj[1] ;
7628
7629 if (!args) SWIG_fail;
7630 swig_obj[0] = args;
7631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7632 if (!SWIG_IsOK(res1)) {
7633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7634 }
7635 arg1 = reinterpret_cast< wxRect * >(argp1);
7636 result = (int) ((arg1)->x);
7637 resultobj = SWIG_From_int(static_cast< int >(result));
7638 return resultobj;
7639 fail:
7640 return NULL;
7641 }
7642
7643
7644 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7645 PyObject *resultobj = 0;
7646 wxRect *arg1 = (wxRect *) 0 ;
7647 int arg2 ;
7648 void *argp1 = 0 ;
7649 int res1 = 0 ;
7650 int val2 ;
7651 int ecode2 = 0 ;
7652 PyObject *swig_obj[2] ;
7653
7654 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7656 if (!SWIG_IsOK(res1)) {
7657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
7658 }
7659 arg1 = reinterpret_cast< wxRect * >(argp1);
7660 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7661 if (!SWIG_IsOK(ecode2)) {
7662 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
7663 }
7664 arg2 = static_cast< int >(val2);
7665 if (arg1) (arg1)->y = arg2;
7666
7667 resultobj = SWIG_Py_Void();
7668 return resultobj;
7669 fail:
7670 return NULL;
7671 }
7672
7673
7674 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7675 PyObject *resultobj = 0;
7676 wxRect *arg1 = (wxRect *) 0 ;
7677 int result;
7678 void *argp1 = 0 ;
7679 int res1 = 0 ;
7680 PyObject *swig_obj[1] ;
7681
7682 if (!args) SWIG_fail;
7683 swig_obj[0] = args;
7684 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7685 if (!SWIG_IsOK(res1)) {
7686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
7687 }
7688 arg1 = reinterpret_cast< wxRect * >(argp1);
7689 result = (int) ((arg1)->y);
7690 resultobj = SWIG_From_int(static_cast< int >(result));
7691 return resultobj;
7692 fail:
7693 return NULL;
7694 }
7695
7696
7697 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7698 PyObject *resultobj = 0;
7699 wxRect *arg1 = (wxRect *) 0 ;
7700 int arg2 ;
7701 void *argp1 = 0 ;
7702 int res1 = 0 ;
7703 int val2 ;
7704 int ecode2 = 0 ;
7705 PyObject *swig_obj[2] ;
7706
7707 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
7708 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7709 if (!SWIG_IsOK(res1)) {
7710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
7711 }
7712 arg1 = reinterpret_cast< wxRect * >(argp1);
7713 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7714 if (!SWIG_IsOK(ecode2)) {
7715 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
7716 }
7717 arg2 = static_cast< int >(val2);
7718 if (arg1) (arg1)->width = arg2;
7719
7720 resultobj = SWIG_Py_Void();
7721 return resultobj;
7722 fail:
7723 return NULL;
7724 }
7725
7726
7727 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7728 PyObject *resultobj = 0;
7729 wxRect *arg1 = (wxRect *) 0 ;
7730 int result;
7731 void *argp1 = 0 ;
7732 int res1 = 0 ;
7733 PyObject *swig_obj[1] ;
7734
7735 if (!args) SWIG_fail;
7736 swig_obj[0] = args;
7737 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7738 if (!SWIG_IsOK(res1)) {
7739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
7740 }
7741 arg1 = reinterpret_cast< wxRect * >(argp1);
7742 result = (int) ((arg1)->width);
7743 resultobj = SWIG_From_int(static_cast< int >(result));
7744 return resultobj;
7745 fail:
7746 return NULL;
7747 }
7748
7749
7750 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7751 PyObject *resultobj = 0;
7752 wxRect *arg1 = (wxRect *) 0 ;
7753 int arg2 ;
7754 void *argp1 = 0 ;
7755 int res1 = 0 ;
7756 int val2 ;
7757 int ecode2 = 0 ;
7758 PyObject *swig_obj[2] ;
7759
7760 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
7761 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7762 if (!SWIG_IsOK(res1)) {
7763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
7764 }
7765 arg1 = reinterpret_cast< wxRect * >(argp1);
7766 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7767 if (!SWIG_IsOK(ecode2)) {
7768 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
7769 }
7770 arg2 = static_cast< int >(val2);
7771 if (arg1) (arg1)->height = arg2;
7772
7773 resultobj = SWIG_Py_Void();
7774 return resultobj;
7775 fail:
7776 return NULL;
7777 }
7778
7779
7780 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7781 PyObject *resultobj = 0;
7782 wxRect *arg1 = (wxRect *) 0 ;
7783 int result;
7784 void *argp1 = 0 ;
7785 int res1 = 0 ;
7786 PyObject *swig_obj[1] ;
7787
7788 if (!args) SWIG_fail;
7789 swig_obj[0] = args;
7790 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7791 if (!SWIG_IsOK(res1)) {
7792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
7793 }
7794 arg1 = reinterpret_cast< wxRect * >(argp1);
7795 result = (int) ((arg1)->height);
7796 resultobj = SWIG_From_int(static_cast< int >(result));
7797 return resultobj;
7798 fail:
7799 return NULL;
7800 }
7801
7802
7803 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7804 PyObject *resultobj = 0;
7805 wxRect *arg1 = (wxRect *) 0 ;
7806 int arg2 = (int) 0 ;
7807 int arg3 = (int) 0 ;
7808 int arg4 = (int) 0 ;
7809 int arg5 = (int) 0 ;
7810 void *argp1 = 0 ;
7811 int res1 = 0 ;
7812 int val2 ;
7813 int ecode2 = 0 ;
7814 int val3 ;
7815 int ecode3 = 0 ;
7816 int val4 ;
7817 int ecode4 = 0 ;
7818 int val5 ;
7819 int ecode5 = 0 ;
7820 PyObject * obj0 = 0 ;
7821 PyObject * obj1 = 0 ;
7822 PyObject * obj2 = 0 ;
7823 PyObject * obj3 = 0 ;
7824 PyObject * obj4 = 0 ;
7825 char * kwnames[] = {
7826 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7827 };
7828
7829 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
7830 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7831 if (!SWIG_IsOK(res1)) {
7832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
7833 }
7834 arg1 = reinterpret_cast< wxRect * >(argp1);
7835 if (obj1) {
7836 ecode2 = SWIG_AsVal_int(obj1, &val2);
7837 if (!SWIG_IsOK(ecode2)) {
7838 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
7839 }
7840 arg2 = static_cast< int >(val2);
7841 }
7842 if (obj2) {
7843 ecode3 = SWIG_AsVal_int(obj2, &val3);
7844 if (!SWIG_IsOK(ecode3)) {
7845 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
7846 }
7847 arg3 = static_cast< int >(val3);
7848 }
7849 if (obj3) {
7850 ecode4 = SWIG_AsVal_int(obj3, &val4);
7851 if (!SWIG_IsOK(ecode4)) {
7852 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
7853 }
7854 arg4 = static_cast< int >(val4);
7855 }
7856 if (obj4) {
7857 ecode5 = SWIG_AsVal_int(obj4, &val5);
7858 if (!SWIG_IsOK(ecode5)) {
7859 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
7860 }
7861 arg5 = static_cast< int >(val5);
7862 }
7863 {
7864 PyThreadState* __tstate = wxPyBeginAllowThreads();
7865 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
7866 wxPyEndAllowThreads(__tstate);
7867 if (PyErr_Occurred()) SWIG_fail;
7868 }
7869 resultobj = SWIG_Py_Void();
7870 return resultobj;
7871 fail:
7872 return NULL;
7873 }
7874
7875
7876 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7877 PyObject *resultobj = 0;
7878 wxRect *arg1 = (wxRect *) 0 ;
7879 PyObject *result = 0 ;
7880 void *argp1 = 0 ;
7881 int res1 = 0 ;
7882 PyObject *swig_obj[1] ;
7883
7884 if (!args) SWIG_fail;
7885 swig_obj[0] = args;
7886 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7887 if (!SWIG_IsOK(res1)) {
7888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
7889 }
7890 arg1 = reinterpret_cast< wxRect * >(argp1);
7891 {
7892 PyThreadState* __tstate = wxPyBeginAllowThreads();
7893 result = (PyObject *)wxRect_Get(arg1);
7894 wxPyEndAllowThreads(__tstate);
7895 if (PyErr_Occurred()) SWIG_fail;
7896 }
7897 resultobj = result;
7898 return resultobj;
7899 fail:
7900 return NULL;
7901 }
7902
7903
7904 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7905 PyObject *obj;
7906 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7907 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
7908 return SWIG_Py_Void();
7909 }
7910
7911 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7912 return SWIG_Python_InitShadowInstance(args);
7913 }
7914
7915 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7916 PyObject *resultobj = 0;
7917 wxRect *arg1 = (wxRect *) 0 ;
7918 wxRect *arg2 = (wxRect *) 0 ;
7919 PyObject *result = 0 ;
7920 void *argp1 = 0 ;
7921 int res1 = 0 ;
7922 void *argp2 = 0 ;
7923 int res2 = 0 ;
7924 PyObject * obj0 = 0 ;
7925 PyObject * obj1 = 0 ;
7926 char * kwnames[] = {
7927 (char *) "r1",(char *) "r2", NULL
7928 };
7929
7930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
7931 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7932 if (!SWIG_IsOK(res1)) {
7933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
7934 }
7935 arg1 = reinterpret_cast< wxRect * >(argp1);
7936 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
7937 if (!SWIG_IsOK(res2)) {
7938 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
7939 }
7940 arg2 = reinterpret_cast< wxRect * >(argp2);
7941 {
7942 if (!wxPyCheckForApp()) SWIG_fail;
7943 PyThreadState* __tstate = wxPyBeginAllowThreads();
7944 result = (PyObject *)wxIntersectRect(arg1,arg2);
7945 wxPyEndAllowThreads(__tstate);
7946 if (PyErr_Occurred()) SWIG_fail;
7947 }
7948 resultobj = result;
7949 return resultobj;
7950 fail:
7951 return NULL;
7952 }
7953
7954
7955 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7956 PyObject *resultobj = 0;
7957 double arg1 = (double) 0.0 ;
7958 double arg2 = (double) 0.0 ;
7959 wxPoint2D *result = 0 ;
7960 double val1 ;
7961 int ecode1 = 0 ;
7962 double val2 ;
7963 int ecode2 = 0 ;
7964 PyObject * obj0 = 0 ;
7965 PyObject * obj1 = 0 ;
7966 char * kwnames[] = {
7967 (char *) "x",(char *) "y", NULL
7968 };
7969
7970 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
7971 if (obj0) {
7972 ecode1 = SWIG_AsVal_double(obj0, &val1);
7973 if (!SWIG_IsOK(ecode1)) {
7974 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
7975 }
7976 arg1 = static_cast< double >(val1);
7977 }
7978 if (obj1) {
7979 ecode2 = SWIG_AsVal_double(obj1, &val2);
7980 if (!SWIG_IsOK(ecode2)) {
7981 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
7982 }
7983 arg2 = static_cast< double >(val2);
7984 }
7985 {
7986 PyThreadState* __tstate = wxPyBeginAllowThreads();
7987 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
7988 wxPyEndAllowThreads(__tstate);
7989 if (PyErr_Occurred()) SWIG_fail;
7990 }
7991 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
7992 return resultobj;
7993 fail:
7994 return NULL;
7995 }
7996
7997
7998 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7999 PyObject *resultobj = 0;
8000 wxPoint2D *arg1 = 0 ;
8001 wxPoint2D *result = 0 ;
8002 wxPoint2D temp1 ;
8003 PyObject * obj0 = 0 ;
8004 char * kwnames[] = {
8005 (char *) "pt", NULL
8006 };
8007
8008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
8009 {
8010 arg1 = &temp1;
8011 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
8012 }
8013 {
8014 PyThreadState* __tstate = wxPyBeginAllowThreads();
8015 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
8016 wxPyEndAllowThreads(__tstate);
8017 if (PyErr_Occurred()) SWIG_fail;
8018 }
8019 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8020 return resultobj;
8021 fail:
8022 return NULL;
8023 }
8024
8025
8026 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8027 PyObject *resultobj = 0;
8028 wxPoint *arg1 = 0 ;
8029 wxPoint2D *result = 0 ;
8030 wxPoint temp1 ;
8031 PyObject * obj0 = 0 ;
8032 char * kwnames[] = {
8033 (char *) "pt", NULL
8034 };
8035
8036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
8037 {
8038 arg1 = &temp1;
8039 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
8040 }
8041 {
8042 PyThreadState* __tstate = wxPyBeginAllowThreads();
8043 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
8044 wxPyEndAllowThreads(__tstate);
8045 if (PyErr_Occurred()) SWIG_fail;
8046 }
8047 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8048 return resultobj;
8049 fail:
8050 return NULL;
8051 }
8052
8053
8054 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8055 PyObject *resultobj = 0;
8056 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8057 int *arg2 = (int *) 0 ;
8058 int *arg3 = (int *) 0 ;
8059 void *argp1 = 0 ;
8060 int res1 = 0 ;
8061 int temp2 ;
8062 int res2 = SWIG_TMPOBJ ;
8063 int temp3 ;
8064 int res3 = SWIG_TMPOBJ ;
8065 PyObject *swig_obj[1] ;
8066
8067 arg2 = &temp2;
8068 arg3 = &temp3;
8069 if (!args) SWIG_fail;
8070 swig_obj[0] = args;
8071 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8072 if (!SWIG_IsOK(res1)) {
8073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8074 }
8075 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8076 {
8077 PyThreadState* __tstate = wxPyBeginAllowThreads();
8078 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8079 wxPyEndAllowThreads(__tstate);
8080 if (PyErr_Occurred()) SWIG_fail;
8081 }
8082 resultobj = SWIG_Py_Void();
8083 if (SWIG_IsTmpObj(res2)) {
8084 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8085 } else {
8086 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8087 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8088 }
8089 if (SWIG_IsTmpObj(res3)) {
8090 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8091 } else {
8092 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8093 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8094 }
8095 return resultobj;
8096 fail:
8097 return NULL;
8098 }
8099
8100
8101 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8102 PyObject *resultobj = 0;
8103 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8104 int *arg2 = (int *) 0 ;
8105 int *arg3 = (int *) 0 ;
8106 void *argp1 = 0 ;
8107 int res1 = 0 ;
8108 int temp2 ;
8109 int res2 = SWIG_TMPOBJ ;
8110 int temp3 ;
8111 int res3 = SWIG_TMPOBJ ;
8112 PyObject *swig_obj[1] ;
8113
8114 arg2 = &temp2;
8115 arg3 = &temp3;
8116 if (!args) SWIG_fail;
8117 swig_obj[0] = args;
8118 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8119 if (!SWIG_IsOK(res1)) {
8120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8121 }
8122 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8123 {
8124 PyThreadState* __tstate = wxPyBeginAllowThreads();
8125 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8126 wxPyEndAllowThreads(__tstate);
8127 if (PyErr_Occurred()) SWIG_fail;
8128 }
8129 resultobj = SWIG_Py_Void();
8130 if (SWIG_IsTmpObj(res2)) {
8131 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8132 } else {
8133 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8134 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8135 }
8136 if (SWIG_IsTmpObj(res3)) {
8137 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8138 } else {
8139 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8140 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8141 }
8142 return resultobj;
8143 fail:
8144 return NULL;
8145 }
8146
8147
8148 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8149 PyObject *resultobj = 0;
8150 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8151 double result;
8152 void *argp1 = 0 ;
8153 int res1 = 0 ;
8154 PyObject *swig_obj[1] ;
8155
8156 if (!args) SWIG_fail;
8157 swig_obj[0] = args;
8158 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8159 if (!SWIG_IsOK(res1)) {
8160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8161 }
8162 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8163 {
8164 PyThreadState* __tstate = wxPyBeginAllowThreads();
8165 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8166 wxPyEndAllowThreads(__tstate);
8167 if (PyErr_Occurred()) SWIG_fail;
8168 }
8169 resultobj = SWIG_From_double(static_cast< double >(result));
8170 return resultobj;
8171 fail:
8172 return NULL;
8173 }
8174
8175
8176 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8177 PyObject *resultobj = 0;
8178 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8179 double result;
8180 void *argp1 = 0 ;
8181 int res1 = 0 ;
8182 PyObject *swig_obj[1] ;
8183
8184 if (!args) SWIG_fail;
8185 swig_obj[0] = args;
8186 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8187 if (!SWIG_IsOK(res1)) {
8188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8189 }
8190 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8191 {
8192 PyThreadState* __tstate = wxPyBeginAllowThreads();
8193 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8194 wxPyEndAllowThreads(__tstate);
8195 if (PyErr_Occurred()) SWIG_fail;
8196 }
8197 resultobj = SWIG_From_double(static_cast< double >(result));
8198 return resultobj;
8199 fail:
8200 return NULL;
8201 }
8202
8203
8204 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8205 PyObject *resultobj = 0;
8206 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8207 double arg2 ;
8208 void *argp1 = 0 ;
8209 int res1 = 0 ;
8210 double val2 ;
8211 int ecode2 = 0 ;
8212 PyObject * obj0 = 0 ;
8213 PyObject * obj1 = 0 ;
8214 char * kwnames[] = {
8215 (char *) "self",(char *) "length", NULL
8216 };
8217
8218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8219 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8220 if (!SWIG_IsOK(res1)) {
8221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8222 }
8223 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8224 ecode2 = SWIG_AsVal_double(obj1, &val2);
8225 if (!SWIG_IsOK(ecode2)) {
8226 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8227 }
8228 arg2 = static_cast< double >(val2);
8229 {
8230 PyThreadState* __tstate = wxPyBeginAllowThreads();
8231 (arg1)->SetVectorLength(arg2);
8232 wxPyEndAllowThreads(__tstate);
8233 if (PyErr_Occurred()) SWIG_fail;
8234 }
8235 resultobj = SWIG_Py_Void();
8236 return resultobj;
8237 fail:
8238 return NULL;
8239 }
8240
8241
8242 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8243 PyObject *resultobj = 0;
8244 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8245 double arg2 ;
8246 void *argp1 = 0 ;
8247 int res1 = 0 ;
8248 double val2 ;
8249 int ecode2 = 0 ;
8250 PyObject * obj0 = 0 ;
8251 PyObject * obj1 = 0 ;
8252 char * kwnames[] = {
8253 (char *) "self",(char *) "degrees", NULL
8254 };
8255
8256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8258 if (!SWIG_IsOK(res1)) {
8259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8260 }
8261 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8262 ecode2 = SWIG_AsVal_double(obj1, &val2);
8263 if (!SWIG_IsOK(ecode2)) {
8264 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8265 }
8266 arg2 = static_cast< double >(val2);
8267 {
8268 PyThreadState* __tstate = wxPyBeginAllowThreads();
8269 (arg1)->SetVectorAngle(arg2);
8270 wxPyEndAllowThreads(__tstate);
8271 if (PyErr_Occurred()) SWIG_fail;
8272 }
8273 resultobj = SWIG_Py_Void();
8274 return resultobj;
8275 fail:
8276 return NULL;
8277 }
8278
8279
8280 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8281 PyObject *resultobj = 0;
8282 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8283 wxPoint2D *arg2 = 0 ;
8284 double result;
8285 void *argp1 = 0 ;
8286 int res1 = 0 ;
8287 wxPoint2D temp2 ;
8288 PyObject * obj0 = 0 ;
8289 PyObject * obj1 = 0 ;
8290 char * kwnames[] = {
8291 (char *) "self",(char *) "pt", NULL
8292 };
8293
8294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8295 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8296 if (!SWIG_IsOK(res1)) {
8297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8298 }
8299 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8300 {
8301 arg2 = &temp2;
8302 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8303 }
8304 {
8305 PyThreadState* __tstate = wxPyBeginAllowThreads();
8306 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8307 wxPyEndAllowThreads(__tstate);
8308 if (PyErr_Occurred()) SWIG_fail;
8309 }
8310 resultobj = SWIG_From_double(static_cast< double >(result));
8311 return resultobj;
8312 fail:
8313 return NULL;
8314 }
8315
8316
8317 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8318 PyObject *resultobj = 0;
8319 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8320 wxPoint2D *arg2 = 0 ;
8321 double result;
8322 void *argp1 = 0 ;
8323 int res1 = 0 ;
8324 wxPoint2D temp2 ;
8325 PyObject * obj0 = 0 ;
8326 PyObject * obj1 = 0 ;
8327 char * kwnames[] = {
8328 (char *) "self",(char *) "pt", NULL
8329 };
8330
8331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8332 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8333 if (!SWIG_IsOK(res1)) {
8334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8335 }
8336 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8337 {
8338 arg2 = &temp2;
8339 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8340 }
8341 {
8342 PyThreadState* __tstate = wxPyBeginAllowThreads();
8343 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8344 wxPyEndAllowThreads(__tstate);
8345 if (PyErr_Occurred()) SWIG_fail;
8346 }
8347 resultobj = SWIG_From_double(static_cast< double >(result));
8348 return resultobj;
8349 fail:
8350 return NULL;
8351 }
8352
8353
8354 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8355 PyObject *resultobj = 0;
8356 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8357 wxPoint2D *arg2 = 0 ;
8358 double result;
8359 void *argp1 = 0 ;
8360 int res1 = 0 ;
8361 wxPoint2D temp2 ;
8362 PyObject * obj0 = 0 ;
8363 PyObject * obj1 = 0 ;
8364 char * kwnames[] = {
8365 (char *) "self",(char *) "vec", NULL
8366 };
8367
8368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8369 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8370 if (!SWIG_IsOK(res1)) {
8371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8372 }
8373 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8374 {
8375 arg2 = &temp2;
8376 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8377 }
8378 {
8379 PyThreadState* __tstate = wxPyBeginAllowThreads();
8380 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8381 wxPyEndAllowThreads(__tstate);
8382 if (PyErr_Occurred()) SWIG_fail;
8383 }
8384 resultobj = SWIG_From_double(static_cast< double >(result));
8385 return resultobj;
8386 fail:
8387 return NULL;
8388 }
8389
8390
8391 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8392 PyObject *resultobj = 0;
8393 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8394 wxPoint2D *arg2 = 0 ;
8395 double result;
8396 void *argp1 = 0 ;
8397 int res1 = 0 ;
8398 wxPoint2D temp2 ;
8399 PyObject * obj0 = 0 ;
8400 PyObject * obj1 = 0 ;
8401 char * kwnames[] = {
8402 (char *) "self",(char *) "vec", NULL
8403 };
8404
8405 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8406 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8407 if (!SWIG_IsOK(res1)) {
8408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8409 }
8410 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8411 {
8412 arg2 = &temp2;
8413 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8414 }
8415 {
8416 PyThreadState* __tstate = wxPyBeginAllowThreads();
8417 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8418 wxPyEndAllowThreads(__tstate);
8419 if (PyErr_Occurred()) SWIG_fail;
8420 }
8421 resultobj = SWIG_From_double(static_cast< double >(result));
8422 return resultobj;
8423 fail:
8424 return NULL;
8425 }
8426
8427
8428 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8429 PyObject *resultobj = 0;
8430 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8431 wxPoint2D result;
8432 void *argp1 = 0 ;
8433 int res1 = 0 ;
8434 PyObject *swig_obj[1] ;
8435
8436 if (!args) SWIG_fail;
8437 swig_obj[0] = args;
8438 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8439 if (!SWIG_IsOK(res1)) {
8440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8441 }
8442 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8443 {
8444 PyThreadState* __tstate = wxPyBeginAllowThreads();
8445 result = (arg1)->operator -();
8446 wxPyEndAllowThreads(__tstate);
8447 if (PyErr_Occurred()) SWIG_fail;
8448 }
8449 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8450 return resultobj;
8451 fail:
8452 return NULL;
8453 }
8454
8455
8456 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8457 PyObject *resultobj = 0;
8458 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8459 wxPoint2D *arg2 = 0 ;
8460 wxPoint2D *result = 0 ;
8461 void *argp1 = 0 ;
8462 int res1 = 0 ;
8463 wxPoint2D temp2 ;
8464 PyObject * obj0 = 0 ;
8465 PyObject * obj1 = 0 ;
8466 char * kwnames[] = {
8467 (char *) "self",(char *) "pt", NULL
8468 };
8469
8470 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8471 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8472 if (!SWIG_IsOK(res1)) {
8473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8474 }
8475 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8476 {
8477 arg2 = &temp2;
8478 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8479 }
8480 {
8481 PyThreadState* __tstate = wxPyBeginAllowThreads();
8482 {
8483 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8484 result = (wxPoint2D *) &_result_ref;
8485 }
8486 wxPyEndAllowThreads(__tstate);
8487 if (PyErr_Occurred()) SWIG_fail;
8488 }
8489 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8490 return resultobj;
8491 fail:
8492 return NULL;
8493 }
8494
8495
8496 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8497 PyObject *resultobj = 0;
8498 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8499 wxPoint2D *arg2 = 0 ;
8500 wxPoint2D *result = 0 ;
8501 void *argp1 = 0 ;
8502 int res1 = 0 ;
8503 wxPoint2D temp2 ;
8504 PyObject * obj0 = 0 ;
8505 PyObject * obj1 = 0 ;
8506 char * kwnames[] = {
8507 (char *) "self",(char *) "pt", NULL
8508 };
8509
8510 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8511 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8512 if (!SWIG_IsOK(res1)) {
8513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8514 }
8515 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8516 {
8517 arg2 = &temp2;
8518 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8519 }
8520 {
8521 PyThreadState* __tstate = wxPyBeginAllowThreads();
8522 {
8523 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8524 result = (wxPoint2D *) &_result_ref;
8525 }
8526 wxPyEndAllowThreads(__tstate);
8527 if (PyErr_Occurred()) SWIG_fail;
8528 }
8529 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8530 return resultobj;
8531 fail:
8532 return NULL;
8533 }
8534
8535
8536 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8537 PyObject *resultobj = 0;
8538 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8539 wxPoint2D *arg2 = 0 ;
8540 wxPoint2D *result = 0 ;
8541 void *argp1 = 0 ;
8542 int res1 = 0 ;
8543 wxPoint2D temp2 ;
8544 PyObject * obj0 = 0 ;
8545 PyObject * obj1 = 0 ;
8546 char * kwnames[] = {
8547 (char *) "self",(char *) "pt", NULL
8548 };
8549
8550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8551 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8552 if (!SWIG_IsOK(res1)) {
8553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8554 }
8555 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8556 {
8557 arg2 = &temp2;
8558 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8559 }
8560 {
8561 PyThreadState* __tstate = wxPyBeginAllowThreads();
8562 {
8563 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8564 result = (wxPoint2D *) &_result_ref;
8565 }
8566 wxPyEndAllowThreads(__tstate);
8567 if (PyErr_Occurred()) SWIG_fail;
8568 }
8569 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8570 return resultobj;
8571 fail:
8572 return NULL;
8573 }
8574
8575
8576 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8577 PyObject *resultobj = 0;
8578 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8579 wxPoint2D *arg2 = 0 ;
8580 wxPoint2D *result = 0 ;
8581 void *argp1 = 0 ;
8582 int res1 = 0 ;
8583 wxPoint2D temp2 ;
8584 PyObject * obj0 = 0 ;
8585 PyObject * obj1 = 0 ;
8586 char * kwnames[] = {
8587 (char *) "self",(char *) "pt", NULL
8588 };
8589
8590 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8591 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8592 if (!SWIG_IsOK(res1)) {
8593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8594 }
8595 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8596 {
8597 arg2 = &temp2;
8598 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8599 }
8600 {
8601 PyThreadState* __tstate = wxPyBeginAllowThreads();
8602 {
8603 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8604 result = (wxPoint2D *) &_result_ref;
8605 }
8606 wxPyEndAllowThreads(__tstate);
8607 if (PyErr_Occurred()) SWIG_fail;
8608 }
8609 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8610 return resultobj;
8611 fail:
8612 return NULL;
8613 }
8614
8615
8616 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8617 PyObject *resultobj = 0;
8618 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8619 PyObject *arg2 = (PyObject *) 0 ;
8620 bool result;
8621 void *argp1 = 0 ;
8622 int res1 = 0 ;
8623 PyObject * obj0 = 0 ;
8624 PyObject * obj1 = 0 ;
8625 char * kwnames[] = {
8626 (char *) "self",(char *) "other", NULL
8627 };
8628
8629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8630 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8631 if (!SWIG_IsOK(res1)) {
8632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8633 }
8634 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8635 arg2 = obj1;
8636 {
8637 result = (bool)wxPoint2D___eq__(arg1,arg2);
8638 if (PyErr_Occurred()) SWIG_fail;
8639 }
8640 {
8641 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8642 }
8643 return resultobj;
8644 fail:
8645 return NULL;
8646 }
8647
8648
8649 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8650 PyObject *resultobj = 0;
8651 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8652 PyObject *arg2 = (PyObject *) 0 ;
8653 bool result;
8654 void *argp1 = 0 ;
8655 int res1 = 0 ;
8656 PyObject * obj0 = 0 ;
8657 PyObject * obj1 = 0 ;
8658 char * kwnames[] = {
8659 (char *) "self",(char *) "other", NULL
8660 };
8661
8662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
8663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8664 if (!SWIG_IsOK(res1)) {
8665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8666 }
8667 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8668 arg2 = obj1;
8669 {
8670 result = (bool)wxPoint2D___ne__(arg1,arg2);
8671 if (PyErr_Occurred()) SWIG_fail;
8672 }
8673 {
8674 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8675 }
8676 return resultobj;
8677 fail:
8678 return NULL;
8679 }
8680
8681
8682 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8683 PyObject *resultobj = 0;
8684 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8685 double arg2 ;
8686 void *argp1 = 0 ;
8687 int res1 = 0 ;
8688 double val2 ;
8689 int ecode2 = 0 ;
8690 PyObject *swig_obj[2] ;
8691
8692 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
8693 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8694 if (!SWIG_IsOK(res1)) {
8695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8696 }
8697 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8698 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8699 if (!SWIG_IsOK(ecode2)) {
8700 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
8701 }
8702 arg2 = static_cast< double >(val2);
8703 if (arg1) (arg1)->m_x = arg2;
8704
8705 resultobj = SWIG_Py_Void();
8706 return resultobj;
8707 fail:
8708 return NULL;
8709 }
8710
8711
8712 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8713 PyObject *resultobj = 0;
8714 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8715 double result;
8716 void *argp1 = 0 ;
8717 int res1 = 0 ;
8718 PyObject *swig_obj[1] ;
8719
8720 if (!args) SWIG_fail;
8721 swig_obj[0] = args;
8722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8723 if (!SWIG_IsOK(res1)) {
8724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8725 }
8726 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8727 result = (double) ((arg1)->m_x);
8728 resultobj = SWIG_From_double(static_cast< double >(result));
8729 return resultobj;
8730 fail:
8731 return NULL;
8732 }
8733
8734
8735 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8736 PyObject *resultobj = 0;
8737 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8738 double arg2 ;
8739 void *argp1 = 0 ;
8740 int res1 = 0 ;
8741 double val2 ;
8742 int ecode2 = 0 ;
8743 PyObject *swig_obj[2] ;
8744
8745 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
8746 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8747 if (!SWIG_IsOK(res1)) {
8748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8749 }
8750 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8751 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8752 if (!SWIG_IsOK(ecode2)) {
8753 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
8754 }
8755 arg2 = static_cast< double >(val2);
8756 if (arg1) (arg1)->m_y = arg2;
8757
8758 resultobj = SWIG_Py_Void();
8759 return resultobj;
8760 fail:
8761 return NULL;
8762 }
8763
8764
8765 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8766 PyObject *resultobj = 0;
8767 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8768 double result;
8769 void *argp1 = 0 ;
8770 int res1 = 0 ;
8771 PyObject *swig_obj[1] ;
8772
8773 if (!args) SWIG_fail;
8774 swig_obj[0] = args;
8775 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8776 if (!SWIG_IsOK(res1)) {
8777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8778 }
8779 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8780 result = (double) ((arg1)->m_y);
8781 resultobj = SWIG_From_double(static_cast< double >(result));
8782 return resultobj;
8783 fail:
8784 return NULL;
8785 }
8786
8787
8788 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8789 PyObject *resultobj = 0;
8790 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8791 double arg2 = (double) 0 ;
8792 double arg3 = (double) 0 ;
8793 void *argp1 = 0 ;
8794 int res1 = 0 ;
8795 double val2 ;
8796 int ecode2 = 0 ;
8797 double val3 ;
8798 int ecode3 = 0 ;
8799 PyObject * obj0 = 0 ;
8800 PyObject * obj1 = 0 ;
8801 PyObject * obj2 = 0 ;
8802 char * kwnames[] = {
8803 (char *) "self",(char *) "x",(char *) "y", NULL
8804 };
8805
8806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8808 if (!SWIG_IsOK(res1)) {
8809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8810 }
8811 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8812 if (obj1) {
8813 ecode2 = SWIG_AsVal_double(obj1, &val2);
8814 if (!SWIG_IsOK(ecode2)) {
8815 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
8816 }
8817 arg2 = static_cast< double >(val2);
8818 }
8819 if (obj2) {
8820 ecode3 = SWIG_AsVal_double(obj2, &val3);
8821 if (!SWIG_IsOK(ecode3)) {
8822 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
8823 }
8824 arg3 = static_cast< double >(val3);
8825 }
8826 {
8827 PyThreadState* __tstate = wxPyBeginAllowThreads();
8828 wxPoint2D_Set(arg1,arg2,arg3);
8829 wxPyEndAllowThreads(__tstate);
8830 if (PyErr_Occurred()) SWIG_fail;
8831 }
8832 resultobj = SWIG_Py_Void();
8833 return resultobj;
8834 fail:
8835 return NULL;
8836 }
8837
8838
8839 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8840 PyObject *resultobj = 0;
8841 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8842 PyObject *result = 0 ;
8843 void *argp1 = 0 ;
8844 int res1 = 0 ;
8845 PyObject *swig_obj[1] ;
8846
8847 if (!args) SWIG_fail;
8848 swig_obj[0] = args;
8849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8850 if (!SWIG_IsOK(res1)) {
8851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8852 }
8853 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8854 {
8855 PyThreadState* __tstate = wxPyBeginAllowThreads();
8856 result = (PyObject *)wxPoint2D_Get(arg1);
8857 wxPyEndAllowThreads(__tstate);
8858 if (PyErr_Occurred()) SWIG_fail;
8859 }
8860 resultobj = result;
8861 return resultobj;
8862 fail:
8863 return NULL;
8864 }
8865
8866
8867 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8868 PyObject *obj;
8869 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8870 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
8871 return SWIG_Py_Void();
8872 }
8873
8874 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8875 return SWIG_Python_InitShadowInstance(args);
8876 }
8877
8878 SWIGINTERN int DefaultPosition_set(PyObject *) {
8879 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
8880 return 1;
8881 }
8882
8883
8884 SWIGINTERN PyObject *DefaultPosition_get(void) {
8885 PyObject *pyobj = 0;
8886
8887 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
8888 return pyobj;
8889 }
8890
8891
8892 SWIGINTERN int DefaultSize_set(PyObject *) {
8893 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
8894 return 1;
8895 }
8896
8897
8898 SWIGINTERN PyObject *DefaultSize_get(void) {
8899 PyObject *pyobj = 0;
8900
8901 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
8902 return pyobj;
8903 }
8904
8905
8906 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8907 PyObject *resultobj = 0;
8908 PyObject *arg1 = (PyObject *) 0 ;
8909 wxPyInputStream *result = 0 ;
8910 PyObject * obj0 = 0 ;
8911 char * kwnames[] = {
8912 (char *) "p", NULL
8913 };
8914
8915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
8916 arg1 = obj0;
8917 {
8918 PyThreadState* __tstate = wxPyBeginAllowThreads();
8919 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
8920 wxPyEndAllowThreads(__tstate);
8921 if (PyErr_Occurred()) SWIG_fail;
8922 }
8923 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
8924 return resultobj;
8925 fail:
8926 return NULL;
8927 }
8928
8929
8930 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8931 PyObject *resultobj = 0;
8932 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8933 void *argp1 = 0 ;
8934 int res1 = 0 ;
8935 PyObject *swig_obj[1] ;
8936
8937 if (!args) SWIG_fail;
8938 swig_obj[0] = args;
8939 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
8940 if (!SWIG_IsOK(res1)) {
8941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8942 }
8943 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8944 {
8945 PyThreadState* __tstate = wxPyBeginAllowThreads();
8946 delete arg1;
8947
8948 wxPyEndAllowThreads(__tstate);
8949 if (PyErr_Occurred()) SWIG_fail;
8950 }
8951 resultobj = SWIG_Py_Void();
8952 return resultobj;
8953 fail:
8954 return NULL;
8955 }
8956
8957
8958 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8959 PyObject *resultobj = 0;
8960 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8961 void *argp1 = 0 ;
8962 int res1 = 0 ;
8963 PyObject *swig_obj[1] ;
8964
8965 if (!args) SWIG_fail;
8966 swig_obj[0] = args;
8967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
8968 if (!SWIG_IsOK(res1)) {
8969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8970 }
8971 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8972 {
8973 PyThreadState* __tstate = wxPyBeginAllowThreads();
8974 (arg1)->close();
8975 wxPyEndAllowThreads(__tstate);
8976 if (PyErr_Occurred()) SWIG_fail;
8977 }
8978 resultobj = SWIG_Py_Void();
8979 return resultobj;
8980 fail:
8981 return NULL;
8982 }
8983
8984
8985 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8986 PyObject *resultobj = 0;
8987 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8988 void *argp1 = 0 ;
8989 int res1 = 0 ;
8990 PyObject *swig_obj[1] ;
8991
8992 if (!args) SWIG_fail;
8993 swig_obj[0] = args;
8994 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
8995 if (!SWIG_IsOK(res1)) {
8996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8997 }
8998 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8999 {
9000 PyThreadState* __tstate = wxPyBeginAllowThreads();
9001 (arg1)->flush();
9002 wxPyEndAllowThreads(__tstate);
9003 if (PyErr_Occurred()) SWIG_fail;
9004 }
9005 resultobj = SWIG_Py_Void();
9006 return resultobj;
9007 fail:
9008 return NULL;
9009 }
9010
9011
9012 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9013 PyObject *resultobj = 0;
9014 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9015 bool result;
9016 void *argp1 = 0 ;
9017 int res1 = 0 ;
9018 PyObject *swig_obj[1] ;
9019
9020 if (!args) SWIG_fail;
9021 swig_obj[0] = args;
9022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9023 if (!SWIG_IsOK(res1)) {
9024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9025 }
9026 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9027 {
9028 PyThreadState* __tstate = wxPyBeginAllowThreads();
9029 result = (bool)(arg1)->eof();
9030 wxPyEndAllowThreads(__tstate);
9031 if (PyErr_Occurred()) SWIG_fail;
9032 }
9033 {
9034 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9035 }
9036 return resultobj;
9037 fail:
9038 return NULL;
9039 }
9040
9041
9042 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9043 PyObject *resultobj = 0;
9044 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9045 int arg2 = (int) -1 ;
9046 PyObject *result = 0 ;
9047 void *argp1 = 0 ;
9048 int res1 = 0 ;
9049 int val2 ;
9050 int ecode2 = 0 ;
9051 PyObject * obj0 = 0 ;
9052 PyObject * obj1 = 0 ;
9053 char * kwnames[] = {
9054 (char *) "self",(char *) "size", NULL
9055 };
9056
9057 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
9058 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9059 if (!SWIG_IsOK(res1)) {
9060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9061 }
9062 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9063 if (obj1) {
9064 ecode2 = SWIG_AsVal_int(obj1, &val2);
9065 if (!SWIG_IsOK(ecode2)) {
9066 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
9067 }
9068 arg2 = static_cast< int >(val2);
9069 }
9070 {
9071 PyThreadState* __tstate = wxPyBeginAllowThreads();
9072 result = (PyObject *)(arg1)->read(arg2);
9073 wxPyEndAllowThreads(__tstate);
9074 if (PyErr_Occurred()) SWIG_fail;
9075 }
9076 resultobj = result;
9077 return resultobj;
9078 fail:
9079 return NULL;
9080 }
9081
9082
9083 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9084 PyObject *resultobj = 0;
9085 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9086 int arg2 = (int) -1 ;
9087 PyObject *result = 0 ;
9088 void *argp1 = 0 ;
9089 int res1 = 0 ;
9090 int val2 ;
9091 int ecode2 = 0 ;
9092 PyObject * obj0 = 0 ;
9093 PyObject * obj1 = 0 ;
9094 char * kwnames[] = {
9095 (char *) "self",(char *) "size", NULL
9096 };
9097
9098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
9099 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9100 if (!SWIG_IsOK(res1)) {
9101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9102 }
9103 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9104 if (obj1) {
9105 ecode2 = SWIG_AsVal_int(obj1, &val2);
9106 if (!SWIG_IsOK(ecode2)) {
9107 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
9108 }
9109 arg2 = static_cast< int >(val2);
9110 }
9111 {
9112 PyThreadState* __tstate = wxPyBeginAllowThreads();
9113 result = (PyObject *)(arg1)->readline(arg2);
9114 wxPyEndAllowThreads(__tstate);
9115 if (PyErr_Occurred()) SWIG_fail;
9116 }
9117 resultobj = result;
9118 return resultobj;
9119 fail:
9120 return NULL;
9121 }
9122
9123
9124 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9125 PyObject *resultobj = 0;
9126 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9127 int arg2 = (int) -1 ;
9128 PyObject *result = 0 ;
9129 void *argp1 = 0 ;
9130 int res1 = 0 ;
9131 int val2 ;
9132 int ecode2 = 0 ;
9133 PyObject * obj0 = 0 ;
9134 PyObject * obj1 = 0 ;
9135 char * kwnames[] = {
9136 (char *) "self",(char *) "sizehint", NULL
9137 };
9138
9139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
9140 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9141 if (!SWIG_IsOK(res1)) {
9142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9143 }
9144 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9145 if (obj1) {
9146 ecode2 = SWIG_AsVal_int(obj1, &val2);
9147 if (!SWIG_IsOK(ecode2)) {
9148 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
9149 }
9150 arg2 = static_cast< int >(val2);
9151 }
9152 {
9153 PyThreadState* __tstate = wxPyBeginAllowThreads();
9154 result = (PyObject *)(arg1)->readlines(arg2);
9155 wxPyEndAllowThreads(__tstate);
9156 if (PyErr_Occurred()) SWIG_fail;
9157 }
9158 resultobj = result;
9159 return resultobj;
9160 fail:
9161 return NULL;
9162 }
9163
9164
9165 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9166 PyObject *resultobj = 0;
9167 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9168 int arg2 ;
9169 int arg3 = (int) 0 ;
9170 void *argp1 = 0 ;
9171 int res1 = 0 ;
9172 int val2 ;
9173 int ecode2 = 0 ;
9174 int val3 ;
9175 int ecode3 = 0 ;
9176 PyObject * obj0 = 0 ;
9177 PyObject * obj1 = 0 ;
9178 PyObject * obj2 = 0 ;
9179 char * kwnames[] = {
9180 (char *) "self",(char *) "offset",(char *) "whence", NULL
9181 };
9182
9183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9184 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9185 if (!SWIG_IsOK(res1)) {
9186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9187 }
9188 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9189 ecode2 = SWIG_AsVal_int(obj1, &val2);
9190 if (!SWIG_IsOK(ecode2)) {
9191 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
9192 }
9193 arg2 = static_cast< int >(val2);
9194 if (obj2) {
9195 ecode3 = SWIG_AsVal_int(obj2, &val3);
9196 if (!SWIG_IsOK(ecode3)) {
9197 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
9198 }
9199 arg3 = static_cast< int >(val3);
9200 }
9201 {
9202 PyThreadState* __tstate = wxPyBeginAllowThreads();
9203 (arg1)->seek(arg2,arg3);
9204 wxPyEndAllowThreads(__tstate);
9205 if (PyErr_Occurred()) SWIG_fail;
9206 }
9207 resultobj = SWIG_Py_Void();
9208 return resultobj;
9209 fail:
9210 return NULL;
9211 }
9212
9213
9214 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9215 PyObject *resultobj = 0;
9216 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9217 int result;
9218 void *argp1 = 0 ;
9219 int res1 = 0 ;
9220 PyObject *swig_obj[1] ;
9221
9222 if (!args) SWIG_fail;
9223 swig_obj[0] = args;
9224 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9225 if (!SWIG_IsOK(res1)) {
9226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9227 }
9228 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9229 {
9230 PyThreadState* __tstate = wxPyBeginAllowThreads();
9231 result = (int)(arg1)->tell();
9232 wxPyEndAllowThreads(__tstate);
9233 if (PyErr_Occurred()) SWIG_fail;
9234 }
9235 resultobj = SWIG_From_int(static_cast< int >(result));
9236 return resultobj;
9237 fail:
9238 return NULL;
9239 }
9240
9241
9242 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9243 PyObject *resultobj = 0;
9244 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9245 char result;
9246 void *argp1 = 0 ;
9247 int res1 = 0 ;
9248 PyObject *swig_obj[1] ;
9249
9250 if (!args) SWIG_fail;
9251 swig_obj[0] = args;
9252 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9253 if (!SWIG_IsOK(res1)) {
9254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9255 }
9256 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9257 {
9258 PyThreadState* __tstate = wxPyBeginAllowThreads();
9259 result = (char)(arg1)->Peek();
9260 wxPyEndAllowThreads(__tstate);
9261 if (PyErr_Occurred()) SWIG_fail;
9262 }
9263 resultobj = SWIG_From_char(static_cast< char >(result));
9264 return resultobj;
9265 fail:
9266 return NULL;
9267 }
9268
9269
9270 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9271 PyObject *resultobj = 0;
9272 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9273 char result;
9274 void *argp1 = 0 ;
9275 int res1 = 0 ;
9276 PyObject *swig_obj[1] ;
9277
9278 if (!args) SWIG_fail;
9279 swig_obj[0] = args;
9280 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9281 if (!SWIG_IsOK(res1)) {
9282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9283 }
9284 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9285 {
9286 PyThreadState* __tstate = wxPyBeginAllowThreads();
9287 result = (char)(arg1)->GetC();
9288 wxPyEndAllowThreads(__tstate);
9289 if (PyErr_Occurred()) SWIG_fail;
9290 }
9291 resultobj = SWIG_From_char(static_cast< char >(result));
9292 return resultobj;
9293 fail:
9294 return NULL;
9295 }
9296
9297
9298 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9299 PyObject *resultobj = 0;
9300 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9301 size_t result;
9302 void *argp1 = 0 ;
9303 int res1 = 0 ;
9304 PyObject *swig_obj[1] ;
9305
9306 if (!args) SWIG_fail;
9307 swig_obj[0] = args;
9308 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9309 if (!SWIG_IsOK(res1)) {
9310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9311 }
9312 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9313 {
9314 PyThreadState* __tstate = wxPyBeginAllowThreads();
9315 result = (size_t)(arg1)->LastRead();
9316 wxPyEndAllowThreads(__tstate);
9317 if (PyErr_Occurred()) SWIG_fail;
9318 }
9319 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9320 return resultobj;
9321 fail:
9322 return NULL;
9323 }
9324
9325
9326 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9327 PyObject *resultobj = 0;
9328 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9329 bool result;
9330 void *argp1 = 0 ;
9331 int res1 = 0 ;
9332 PyObject *swig_obj[1] ;
9333
9334 if (!args) SWIG_fail;
9335 swig_obj[0] = args;
9336 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9337 if (!SWIG_IsOK(res1)) {
9338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9339 }
9340 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9341 {
9342 PyThreadState* __tstate = wxPyBeginAllowThreads();
9343 result = (bool)(arg1)->CanRead();
9344 wxPyEndAllowThreads(__tstate);
9345 if (PyErr_Occurred()) SWIG_fail;
9346 }
9347 {
9348 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9349 }
9350 return resultobj;
9351 fail:
9352 return NULL;
9353 }
9354
9355
9356 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9357 PyObject *resultobj = 0;
9358 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9359 bool result;
9360 void *argp1 = 0 ;
9361 int res1 = 0 ;
9362 PyObject *swig_obj[1] ;
9363
9364 if (!args) SWIG_fail;
9365 swig_obj[0] = args;
9366 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9367 if (!SWIG_IsOK(res1)) {
9368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9369 }
9370 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9371 {
9372 PyThreadState* __tstate = wxPyBeginAllowThreads();
9373 result = (bool)(arg1)->Eof();
9374 wxPyEndAllowThreads(__tstate);
9375 if (PyErr_Occurred()) SWIG_fail;
9376 }
9377 {
9378 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9379 }
9380 return resultobj;
9381 fail:
9382 return NULL;
9383 }
9384
9385
9386 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9387 PyObject *resultobj = 0;
9388 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9389 char arg2 ;
9390 bool result;
9391 void *argp1 = 0 ;
9392 int res1 = 0 ;
9393 char val2 ;
9394 int ecode2 = 0 ;
9395 PyObject * obj0 = 0 ;
9396 PyObject * obj1 = 0 ;
9397 char * kwnames[] = {
9398 (char *) "self",(char *) "c", NULL
9399 };
9400
9401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
9402 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9403 if (!SWIG_IsOK(res1)) {
9404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9405 }
9406 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9407 ecode2 = SWIG_AsVal_char(obj1, &val2);
9408 if (!SWIG_IsOK(ecode2)) {
9409 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
9410 }
9411 arg2 = static_cast< char >(val2);
9412 {
9413 PyThreadState* __tstate = wxPyBeginAllowThreads();
9414 result = (bool)(arg1)->Ungetch(arg2);
9415 wxPyEndAllowThreads(__tstate);
9416 if (PyErr_Occurred()) SWIG_fail;
9417 }
9418 {
9419 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9420 }
9421 return resultobj;
9422 fail:
9423 return NULL;
9424 }
9425
9426
9427 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9428 PyObject *resultobj = 0;
9429 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9430 long arg2 ;
9431 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
9432 long result;
9433 void *argp1 = 0 ;
9434 int res1 = 0 ;
9435 long val2 ;
9436 int ecode2 = 0 ;
9437 int val3 ;
9438 int ecode3 = 0 ;
9439 PyObject * obj0 = 0 ;
9440 PyObject * obj1 = 0 ;
9441 PyObject * obj2 = 0 ;
9442 char * kwnames[] = {
9443 (char *) "self",(char *) "pos",(char *) "mode", NULL
9444 };
9445
9446 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9447 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9448 if (!SWIG_IsOK(res1)) {
9449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9450 }
9451 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9452 ecode2 = SWIG_AsVal_long(obj1, &val2);
9453 if (!SWIG_IsOK(ecode2)) {
9454 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
9455 }
9456 arg2 = static_cast< long >(val2);
9457 if (obj2) {
9458 ecode3 = SWIG_AsVal_int(obj2, &val3);
9459 if (!SWIG_IsOK(ecode3)) {
9460 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
9461 }
9462 arg3 = static_cast< wxSeekMode >(val3);
9463 }
9464 {
9465 PyThreadState* __tstate = wxPyBeginAllowThreads();
9466 result = (long)(arg1)->SeekI(arg2,arg3);
9467 wxPyEndAllowThreads(__tstate);
9468 if (PyErr_Occurred()) SWIG_fail;
9469 }
9470 resultobj = SWIG_From_long(static_cast< long >(result));
9471 return resultobj;
9472 fail:
9473 return NULL;
9474 }
9475
9476
9477 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9478 PyObject *resultobj = 0;
9479 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9480 long result;
9481 void *argp1 = 0 ;
9482 int res1 = 0 ;
9483 PyObject *swig_obj[1] ;
9484
9485 if (!args) SWIG_fail;
9486 swig_obj[0] = args;
9487 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9488 if (!SWIG_IsOK(res1)) {
9489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9490 }
9491 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9492 {
9493 PyThreadState* __tstate = wxPyBeginAllowThreads();
9494 result = (long)(arg1)->TellI();
9495 wxPyEndAllowThreads(__tstate);
9496 if (PyErr_Occurred()) SWIG_fail;
9497 }
9498 resultobj = SWIG_From_long(static_cast< long >(result));
9499 return resultobj;
9500 fail:
9501 return NULL;
9502 }
9503
9504
9505 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9506 PyObject *obj;
9507 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9508 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
9509 return SWIG_Py_Void();
9510 }
9511
9512 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9513 return SWIG_Python_InitShadowInstance(args);
9514 }
9515
9516 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9517 PyObject *resultobj = 0;
9518 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9519 PyObject *arg2 = (PyObject *) 0 ;
9520 void *argp1 = 0 ;
9521 int res1 = 0 ;
9522 PyObject * obj0 = 0 ;
9523 PyObject * obj1 = 0 ;
9524 char * kwnames[] = {
9525 (char *) "self",(char *) "obj", NULL
9526 };
9527
9528 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
9529 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9530 if (!SWIG_IsOK(res1)) {
9531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
9532 }
9533 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9534 arg2 = obj1;
9535 {
9536 PyThreadState* __tstate = wxPyBeginAllowThreads();
9537 wxOutputStream_write(arg1,arg2);
9538 wxPyEndAllowThreads(__tstate);
9539 if (PyErr_Occurred()) SWIG_fail;
9540 }
9541 resultobj = SWIG_Py_Void();
9542 return resultobj;
9543 fail:
9544 return NULL;
9545 }
9546
9547
9548 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9549 PyObject *resultobj = 0;
9550 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9551 size_t result;
9552 void *argp1 = 0 ;
9553 int res1 = 0 ;
9554 PyObject *swig_obj[1] ;
9555
9556 if (!args) SWIG_fail;
9557 swig_obj[0] = args;
9558 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9559 if (!SWIG_IsOK(res1)) {
9560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
9561 }
9562 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9563 {
9564 PyThreadState* __tstate = wxPyBeginAllowThreads();
9565 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
9566 wxPyEndAllowThreads(__tstate);
9567 if (PyErr_Occurred()) SWIG_fail;
9568 }
9569 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9570 return resultobj;
9571 fail:
9572 return NULL;
9573 }
9574
9575
9576 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9577 PyObject *obj;
9578 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9579 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
9580 return SWIG_Py_Void();
9581 }
9582
9583 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9584 PyObject *resultobj = 0;
9585 wxInputStream *arg1 = (wxInputStream *) 0 ;
9586 wxString *arg2 = 0 ;
9587 wxString *arg3 = 0 ;
9588 wxString *arg4 = 0 ;
9589 wxDateTime arg5 ;
9590 wxFSFile *result = 0 ;
9591 wxPyInputStream *temp1 ;
9592 bool temp2 = false ;
9593 bool temp3 = false ;
9594 bool temp4 = false ;
9595 void *argp5 ;
9596 int res5 = 0 ;
9597 PyObject * obj0 = 0 ;
9598 PyObject * obj1 = 0 ;
9599 PyObject * obj2 = 0 ;
9600 PyObject * obj3 = 0 ;
9601 PyObject * obj4 = 0 ;
9602 char * kwnames[] = {
9603 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
9604 };
9605
9606 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9607 {
9608 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
9609 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
9610 } else {
9611 PyErr_Clear(); // clear the failure of the wxPyConvert above
9612 arg1 = wxPyCBInputStream_create(obj0, true);
9613 if (arg1 == NULL) {
9614 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
9615 SWIG_fail;
9616 }
9617 }
9618 }
9619 {
9620 arg2 = wxString_in_helper(obj1);
9621 if (arg2 == NULL) SWIG_fail;
9622 temp2 = true;
9623 }
9624 {
9625 arg3 = wxString_in_helper(obj2);
9626 if (arg3 == NULL) SWIG_fail;
9627 temp3 = true;
9628 }
9629 {
9630 arg4 = wxString_in_helper(obj3);
9631 if (arg4 == NULL) SWIG_fail;
9632 temp4 = true;
9633 }
9634 {
9635 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
9636 if (!SWIG_IsOK(res5)) {
9637 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9638 }
9639 if (!argp5) {
9640 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9641 } else {
9642 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
9643 arg5 = *temp;
9644 if (SWIG_IsNewObj(res5)) delete temp;
9645 }
9646 }
9647 {
9648 PyThreadState* __tstate = wxPyBeginAllowThreads();
9649 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
9650 wxPyEndAllowThreads(__tstate);
9651 if (PyErr_Occurred()) SWIG_fail;
9652 }
9653 {
9654 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
9655 }
9656 {
9657 if (temp2)
9658 delete arg2;
9659 }
9660 {
9661 if (temp3)
9662 delete arg3;
9663 }
9664 {
9665 if (temp4)
9666 delete arg4;
9667 }
9668 return resultobj;
9669 fail:
9670 {
9671 if (temp2)
9672 delete arg2;
9673 }
9674 {
9675 if (temp3)
9676 delete arg3;
9677 }
9678 {
9679 if (temp4)
9680 delete arg4;
9681 }
9682 return NULL;
9683 }
9684
9685
9686 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9687 PyObject *resultobj = 0;
9688 wxFSFile *arg1 = (wxFSFile *) 0 ;
9689 void *argp1 = 0 ;
9690 int res1 = 0 ;
9691 PyObject *swig_obj[1] ;
9692
9693 if (!args) SWIG_fail;
9694 swig_obj[0] = args;
9695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
9696 if (!SWIG_IsOK(res1)) {
9697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
9698 }
9699 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9700 {
9701 PyThreadState* __tstate = wxPyBeginAllowThreads();
9702 delete arg1;
9703
9704 wxPyEndAllowThreads(__tstate);
9705 if (PyErr_Occurred()) SWIG_fail;
9706 }
9707 resultobj = SWIG_Py_Void();
9708 return resultobj;
9709 fail:
9710 return NULL;
9711 }
9712
9713
9714 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9715 PyObject *resultobj = 0;
9716 wxFSFile *arg1 = (wxFSFile *) 0 ;
9717 wxInputStream *result = 0 ;
9718 void *argp1 = 0 ;
9719 int res1 = 0 ;
9720 PyObject *swig_obj[1] ;
9721
9722 if (!args) SWIG_fail;
9723 swig_obj[0] = args;
9724 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9725 if (!SWIG_IsOK(res1)) {
9726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
9727 }
9728 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9729 {
9730 PyThreadState* __tstate = wxPyBeginAllowThreads();
9731 result = (wxInputStream *)(arg1)->GetStream();
9732 wxPyEndAllowThreads(__tstate);
9733 if (PyErr_Occurred()) SWIG_fail;
9734 }
9735 {
9736 wxPyInputStream * _ptr = NULL;
9737
9738 if (result) {
9739 _ptr = new wxPyInputStream(result);
9740 }
9741 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
9742 }
9743 return resultobj;
9744 fail:
9745 return NULL;
9746 }
9747
9748
9749 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9750 PyObject *resultobj = 0;
9751 wxFSFile *arg1 = (wxFSFile *) 0 ;
9752 wxString *result = 0 ;
9753 void *argp1 = 0 ;
9754 int res1 = 0 ;
9755 PyObject *swig_obj[1] ;
9756
9757 if (!args) SWIG_fail;
9758 swig_obj[0] = args;
9759 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9760 if (!SWIG_IsOK(res1)) {
9761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
9762 }
9763 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9764 {
9765 PyThreadState* __tstate = wxPyBeginAllowThreads();
9766 {
9767 wxString const &_result_ref = (arg1)->GetMimeType();
9768 result = (wxString *) &_result_ref;
9769 }
9770 wxPyEndAllowThreads(__tstate);
9771 if (PyErr_Occurred()) SWIG_fail;
9772 }
9773 {
9774 #if wxUSE_UNICODE
9775 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9776 #else
9777 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9778 #endif
9779 }
9780 return resultobj;
9781 fail:
9782 return NULL;
9783 }
9784
9785
9786 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9787 PyObject *resultobj = 0;
9788 wxFSFile *arg1 = (wxFSFile *) 0 ;
9789 wxString *result = 0 ;
9790 void *argp1 = 0 ;
9791 int res1 = 0 ;
9792 PyObject *swig_obj[1] ;
9793
9794 if (!args) SWIG_fail;
9795 swig_obj[0] = args;
9796 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9797 if (!SWIG_IsOK(res1)) {
9798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
9799 }
9800 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9801 {
9802 PyThreadState* __tstate = wxPyBeginAllowThreads();
9803 {
9804 wxString const &_result_ref = (arg1)->GetLocation();
9805 result = (wxString *) &_result_ref;
9806 }
9807 wxPyEndAllowThreads(__tstate);
9808 if (PyErr_Occurred()) SWIG_fail;
9809 }
9810 {
9811 #if wxUSE_UNICODE
9812 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9813 #else
9814 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9815 #endif
9816 }
9817 return resultobj;
9818 fail:
9819 return NULL;
9820 }
9821
9822
9823 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9824 PyObject *resultobj = 0;
9825 wxFSFile *arg1 = (wxFSFile *) 0 ;
9826 wxString *result = 0 ;
9827 void *argp1 = 0 ;
9828 int res1 = 0 ;
9829 PyObject *swig_obj[1] ;
9830
9831 if (!args) SWIG_fail;
9832 swig_obj[0] = args;
9833 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9834 if (!SWIG_IsOK(res1)) {
9835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
9836 }
9837 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9838 {
9839 PyThreadState* __tstate = wxPyBeginAllowThreads();
9840 {
9841 wxString const &_result_ref = (arg1)->GetAnchor();
9842 result = (wxString *) &_result_ref;
9843 }
9844 wxPyEndAllowThreads(__tstate);
9845 if (PyErr_Occurred()) SWIG_fail;
9846 }
9847 {
9848 #if wxUSE_UNICODE
9849 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9850 #else
9851 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9852 #endif
9853 }
9854 return resultobj;
9855 fail:
9856 return NULL;
9857 }
9858
9859
9860 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9861 PyObject *resultobj = 0;
9862 wxFSFile *arg1 = (wxFSFile *) 0 ;
9863 wxDateTime result;
9864 void *argp1 = 0 ;
9865 int res1 = 0 ;
9866 PyObject *swig_obj[1] ;
9867
9868 if (!args) SWIG_fail;
9869 swig_obj[0] = args;
9870 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9871 if (!SWIG_IsOK(res1)) {
9872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
9873 }
9874 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9875 {
9876 PyThreadState* __tstate = wxPyBeginAllowThreads();
9877 result = (arg1)->GetModificationTime();
9878 wxPyEndAllowThreads(__tstate);
9879 if (PyErr_Occurred()) SWIG_fail;
9880 }
9881 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
9882 return resultobj;
9883 fail:
9884 return NULL;
9885 }
9886
9887
9888 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9889 PyObject *obj;
9890 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9891 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
9892 return SWIG_Py_Void();
9893 }
9894
9895 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9896 return SWIG_Python_InitShadowInstance(args);
9897 }
9898
9899 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9900 PyObject *resultobj = 0;
9901 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
9902 void *argp1 = 0 ;
9903 int res1 = 0 ;
9904 PyObject *swig_obj[1] ;
9905
9906 if (!args) SWIG_fail;
9907 swig_obj[0] = args;
9908 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
9909 if (!SWIG_IsOK(res1)) {
9910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
9911 }
9912 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
9913 {
9914 PyThreadState* __tstate = wxPyBeginAllowThreads();
9915 delete arg1;
9916
9917 wxPyEndAllowThreads(__tstate);
9918 if (PyErr_Occurred()) SWIG_fail;
9919 }
9920 resultobj = SWIG_Py_Void();
9921 return resultobj;
9922 fail:
9923 return NULL;
9924 }
9925
9926
9927 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9928 PyObject *obj;
9929 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9930 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
9931 return SWIG_Py_Void();
9932 }
9933
9934 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9935 PyObject *resultobj = 0;
9936 wxPyFileSystemHandler *result = 0 ;
9937
9938 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
9939 {
9940 PyThreadState* __tstate = wxPyBeginAllowThreads();
9941 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
9942 wxPyEndAllowThreads(__tstate);
9943 if (PyErr_Occurred()) SWIG_fail;
9944 }
9945 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
9946 return resultobj;
9947 fail:
9948 return NULL;
9949 }
9950
9951
9952 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9953 PyObject *resultobj = 0;
9954 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
9955 PyObject *arg2 = (PyObject *) 0 ;
9956 PyObject *arg3 = (PyObject *) 0 ;
9957 void *argp1 = 0 ;
9958 int res1 = 0 ;
9959 PyObject * obj0 = 0 ;
9960 PyObject * obj1 = 0 ;
9961 PyObject * obj2 = 0 ;
9962 char * kwnames[] = {
9963 (char *) "self",(char *) "self",(char *) "_class", NULL
9964 };
9965
9966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9967 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
9968 if (!SWIG_IsOK(res1)) {
9969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
9970 }
9971 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
9972 arg2 = obj1;
9973 arg3 = obj2;
9974 {
9975 PyThreadState* __tstate = wxPyBeginAllowThreads();
9976 (arg1)->_setCallbackInfo(arg2,arg3);
9977 wxPyEndAllowThreads(__tstate);
9978 if (PyErr_Occurred()) SWIG_fail;
9979 }
9980 resultobj = SWIG_Py_Void();
9981 return resultobj;
9982 fail:
9983 return NULL;
9984 }
9985
9986
9987 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9988 PyObject *resultobj = 0;
9989 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
9990 wxString *arg2 = 0 ;
9991 bool result;
9992 void *argp1 = 0 ;
9993 int res1 = 0 ;
9994 bool temp2 = false ;
9995 PyObject * obj0 = 0 ;
9996 PyObject * obj1 = 0 ;
9997 char * kwnames[] = {
9998 (char *) "self",(char *) "location", NULL
9999 };
10000
10001 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10002 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10003 if (!SWIG_IsOK(res1)) {
10004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10005 }
10006 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10007 {
10008 arg2 = wxString_in_helper(obj1);
10009 if (arg2 == NULL) SWIG_fail;
10010 temp2 = true;
10011 }
10012 {
10013 PyThreadState* __tstate = wxPyBeginAllowThreads();
10014 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10015 wxPyEndAllowThreads(__tstate);
10016 if (PyErr_Occurred()) SWIG_fail;
10017 }
10018 {
10019 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10020 }
10021 {
10022 if (temp2)
10023 delete arg2;
10024 }
10025 return resultobj;
10026 fail:
10027 {
10028 if (temp2)
10029 delete arg2;
10030 }
10031 return NULL;
10032 }
10033
10034
10035 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10036 PyObject *resultobj = 0;
10037 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10038 wxFileSystem *arg2 = 0 ;
10039 wxString *arg3 = 0 ;
10040 wxFSFile *result = 0 ;
10041 void *argp1 = 0 ;
10042 int res1 = 0 ;
10043 void *argp2 = 0 ;
10044 int res2 = 0 ;
10045 bool temp3 = false ;
10046 PyObject * obj0 = 0 ;
10047 PyObject * obj1 = 0 ;
10048 PyObject * obj2 = 0 ;
10049 char * kwnames[] = {
10050 (char *) "self",(char *) "fs",(char *) "location", NULL
10051 };
10052
10053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10055 if (!SWIG_IsOK(res1)) {
10056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10057 }
10058 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10059 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10060 if (!SWIG_IsOK(res2)) {
10061 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10062 }
10063 if (!argp2) {
10064 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10065 }
10066 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10067 {
10068 arg3 = wxString_in_helper(obj2);
10069 if (arg3 == NULL) SWIG_fail;
10070 temp3 = true;
10071 }
10072 {
10073 PyThreadState* __tstate = wxPyBeginAllowThreads();
10074 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10075 wxPyEndAllowThreads(__tstate);
10076 if (PyErr_Occurred()) SWIG_fail;
10077 }
10078 {
10079 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
10080 }
10081 {
10082 if (temp3)
10083 delete arg3;
10084 }
10085 return resultobj;
10086 fail:
10087 {
10088 if (temp3)
10089 delete arg3;
10090 }
10091 return NULL;
10092 }
10093
10094
10095 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10096 PyObject *resultobj = 0;
10097 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10098 wxString *arg2 = 0 ;
10099 int arg3 = (int) 0 ;
10100 wxString result;
10101 void *argp1 = 0 ;
10102 int res1 = 0 ;
10103 bool temp2 = false ;
10104 int val3 ;
10105 int ecode3 = 0 ;
10106 PyObject * obj0 = 0 ;
10107 PyObject * obj1 = 0 ;
10108 PyObject * obj2 = 0 ;
10109 char * kwnames[] = {
10110 (char *) "self",(char *) "spec",(char *) "flags", NULL
10111 };
10112
10113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10114 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10115 if (!SWIG_IsOK(res1)) {
10116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10117 }
10118 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10119 {
10120 arg2 = wxString_in_helper(obj1);
10121 if (arg2 == NULL) SWIG_fail;
10122 temp2 = true;
10123 }
10124 if (obj2) {
10125 ecode3 = SWIG_AsVal_int(obj2, &val3);
10126 if (!SWIG_IsOK(ecode3)) {
10127 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
10128 }
10129 arg3 = static_cast< int >(val3);
10130 }
10131 {
10132 PyThreadState* __tstate = wxPyBeginAllowThreads();
10133 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10134 wxPyEndAllowThreads(__tstate);
10135 if (PyErr_Occurred()) SWIG_fail;
10136 }
10137 {
10138 #if wxUSE_UNICODE
10139 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10140 #else
10141 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10142 #endif
10143 }
10144 {
10145 if (temp2)
10146 delete arg2;
10147 }
10148 return resultobj;
10149 fail:
10150 {
10151 if (temp2)
10152 delete arg2;
10153 }
10154 return NULL;
10155 }
10156
10157
10158 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10159 PyObject *resultobj = 0;
10160 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10161 wxString result;
10162 void *argp1 = 0 ;
10163 int res1 = 0 ;
10164 PyObject *swig_obj[1] ;
10165
10166 if (!args) SWIG_fail;
10167 swig_obj[0] = args;
10168 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10169 if (!SWIG_IsOK(res1)) {
10170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10171 }
10172 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10173 {
10174 PyThreadState* __tstate = wxPyBeginAllowThreads();
10175 result = (arg1)->FindNext();
10176 wxPyEndAllowThreads(__tstate);
10177 if (PyErr_Occurred()) SWIG_fail;
10178 }
10179 {
10180 #if wxUSE_UNICODE
10181 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10182 #else
10183 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10184 #endif
10185 }
10186 return resultobj;
10187 fail:
10188 return NULL;
10189 }
10190
10191
10192 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10193 PyObject *resultobj = 0;
10194 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10195 wxString *arg2 = 0 ;
10196 wxString result;
10197 void *argp1 = 0 ;
10198 int res1 = 0 ;
10199 bool temp2 = false ;
10200 PyObject * obj0 = 0 ;
10201 PyObject * obj1 = 0 ;
10202 char * kwnames[] = {
10203 (char *) "self",(char *) "location", NULL
10204 };
10205
10206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
10207 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10208 if (!SWIG_IsOK(res1)) {
10209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10210 }
10211 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10212 {
10213 arg2 = wxString_in_helper(obj1);
10214 if (arg2 == NULL) SWIG_fail;
10215 temp2 = true;
10216 }
10217 {
10218 PyThreadState* __tstate = wxPyBeginAllowThreads();
10219 result = (arg1)->GetProtocol((wxString const &)*arg2);
10220 wxPyEndAllowThreads(__tstate);
10221 if (PyErr_Occurred()) SWIG_fail;
10222 }
10223 {
10224 #if wxUSE_UNICODE
10225 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10226 #else
10227 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10228 #endif
10229 }
10230 {
10231 if (temp2)
10232 delete arg2;
10233 }
10234 return resultobj;
10235 fail:
10236 {
10237 if (temp2)
10238 delete arg2;
10239 }
10240 return NULL;
10241 }
10242
10243
10244 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10245 PyObject *resultobj = 0;
10246 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10247 wxString *arg2 = 0 ;
10248 wxString result;
10249 void *argp1 = 0 ;
10250 int res1 = 0 ;
10251 bool temp2 = false ;
10252 PyObject * obj0 = 0 ;
10253 PyObject * obj1 = 0 ;
10254 char * kwnames[] = {
10255 (char *) "self",(char *) "location", NULL
10256 };
10257
10258 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10259 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10260 if (!SWIG_IsOK(res1)) {
10261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10262 }
10263 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10264 {
10265 arg2 = wxString_in_helper(obj1);
10266 if (arg2 == NULL) SWIG_fail;
10267 temp2 = true;
10268 }
10269 {
10270 PyThreadState* __tstate = wxPyBeginAllowThreads();
10271 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
10272 wxPyEndAllowThreads(__tstate);
10273 if (PyErr_Occurred()) SWIG_fail;
10274 }
10275 {
10276 #if wxUSE_UNICODE
10277 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10278 #else
10279 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10280 #endif
10281 }
10282 {
10283 if (temp2)
10284 delete arg2;
10285 }
10286 return resultobj;
10287 fail:
10288 {
10289 if (temp2)
10290 delete arg2;
10291 }
10292 return NULL;
10293 }
10294
10295
10296 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10297 PyObject *resultobj = 0;
10298 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10299 wxString *arg2 = 0 ;
10300 wxString result;
10301 void *argp1 = 0 ;
10302 int res1 = 0 ;
10303 bool temp2 = false ;
10304 PyObject * obj0 = 0 ;
10305 PyObject * obj1 = 0 ;
10306 char * kwnames[] = {
10307 (char *) "self",(char *) "location", NULL
10308 };
10309
10310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
10311 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10312 if (!SWIG_IsOK(res1)) {
10313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10314 }
10315 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10316 {
10317 arg2 = wxString_in_helper(obj1);
10318 if (arg2 == NULL) SWIG_fail;
10319 temp2 = true;
10320 }
10321 {
10322 PyThreadState* __tstate = wxPyBeginAllowThreads();
10323 result = (arg1)->GetAnchor((wxString const &)*arg2);
10324 wxPyEndAllowThreads(__tstate);
10325 if (PyErr_Occurred()) SWIG_fail;
10326 }
10327 {
10328 #if wxUSE_UNICODE
10329 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10330 #else
10331 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10332 #endif
10333 }
10334 {
10335 if (temp2)
10336 delete arg2;
10337 }
10338 return resultobj;
10339 fail:
10340 {
10341 if (temp2)
10342 delete arg2;
10343 }
10344 return NULL;
10345 }
10346
10347
10348 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10349 PyObject *resultobj = 0;
10350 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10351 wxString *arg2 = 0 ;
10352 wxString result;
10353 void *argp1 = 0 ;
10354 int res1 = 0 ;
10355 bool temp2 = false ;
10356 PyObject * obj0 = 0 ;
10357 PyObject * obj1 = 0 ;
10358 char * kwnames[] = {
10359 (char *) "self",(char *) "location", NULL
10360 };
10361
10362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10363 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10364 if (!SWIG_IsOK(res1)) {
10365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10366 }
10367 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10368 {
10369 arg2 = wxString_in_helper(obj1);
10370 if (arg2 == NULL) SWIG_fail;
10371 temp2 = true;
10372 }
10373 {
10374 PyThreadState* __tstate = wxPyBeginAllowThreads();
10375 result = (arg1)->GetRightLocation((wxString const &)*arg2);
10376 wxPyEndAllowThreads(__tstate);
10377 if (PyErr_Occurred()) SWIG_fail;
10378 }
10379 {
10380 #if wxUSE_UNICODE
10381 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10382 #else
10383 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10384 #endif
10385 }
10386 {
10387 if (temp2)
10388 delete arg2;
10389 }
10390 return resultobj;
10391 fail:
10392 {
10393 if (temp2)
10394 delete arg2;
10395 }
10396 return NULL;
10397 }
10398
10399
10400 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10401 PyObject *resultobj = 0;
10402 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10403 wxString *arg2 = 0 ;
10404 wxString result;
10405 void *argp1 = 0 ;
10406 int res1 = 0 ;
10407 bool temp2 = false ;
10408 PyObject * obj0 = 0 ;
10409 PyObject * obj1 = 0 ;
10410 char * kwnames[] = {
10411 (char *) "self",(char *) "location", NULL
10412 };
10413
10414 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
10415 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10416 if (!SWIG_IsOK(res1)) {
10417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10418 }
10419 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10420 {
10421 arg2 = wxString_in_helper(obj1);
10422 if (arg2 == NULL) SWIG_fail;
10423 temp2 = true;
10424 }
10425 {
10426 PyThreadState* __tstate = wxPyBeginAllowThreads();
10427 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
10428 wxPyEndAllowThreads(__tstate);
10429 if (PyErr_Occurred()) SWIG_fail;
10430 }
10431 {
10432 #if wxUSE_UNICODE
10433 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10434 #else
10435 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10436 #endif
10437 }
10438 {
10439 if (temp2)
10440 delete arg2;
10441 }
10442 return resultobj;
10443 fail:
10444 {
10445 if (temp2)
10446 delete arg2;
10447 }
10448 return NULL;
10449 }
10450
10451
10452 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10453 PyObject *obj;
10454 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10455 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
10456 return SWIG_Py_Void();
10457 }
10458
10459 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10460 return SWIG_Python_InitShadowInstance(args);
10461 }
10462
10463 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10464 PyObject *resultobj = 0;
10465 wxFileSystem *result = 0 ;
10466
10467 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
10468 {
10469 PyThreadState* __tstate = wxPyBeginAllowThreads();
10470 result = (wxFileSystem *)new wxFileSystem();
10471 wxPyEndAllowThreads(__tstate);
10472 if (PyErr_Occurred()) SWIG_fail;
10473 }
10474 {
10475 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
10476 }
10477 return resultobj;
10478 fail:
10479 return NULL;
10480 }
10481
10482
10483 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10484 PyObject *resultobj = 0;
10485 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10486 void *argp1 = 0 ;
10487 int res1 = 0 ;
10488 PyObject *swig_obj[1] ;
10489
10490 if (!args) SWIG_fail;
10491 swig_obj[0] = args;
10492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
10493 if (!SWIG_IsOK(res1)) {
10494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10495 }
10496 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10497 {
10498 PyThreadState* __tstate = wxPyBeginAllowThreads();
10499 delete arg1;
10500
10501 wxPyEndAllowThreads(__tstate);
10502 if (PyErr_Occurred()) SWIG_fail;
10503 }
10504 resultobj = SWIG_Py_Void();
10505 return resultobj;
10506 fail:
10507 return NULL;
10508 }
10509
10510
10511 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10512 PyObject *resultobj = 0;
10513 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10514 wxString *arg2 = 0 ;
10515 bool arg3 = (bool) false ;
10516 void *argp1 = 0 ;
10517 int res1 = 0 ;
10518 bool temp2 = false ;
10519 bool val3 ;
10520 int ecode3 = 0 ;
10521 PyObject * obj0 = 0 ;
10522 PyObject * obj1 = 0 ;
10523 PyObject * obj2 = 0 ;
10524 char * kwnames[] = {
10525 (char *) "self",(char *) "location",(char *) "is_dir", NULL
10526 };
10527
10528 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10529 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10530 if (!SWIG_IsOK(res1)) {
10531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10532 }
10533 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10534 {
10535 arg2 = wxString_in_helper(obj1);
10536 if (arg2 == NULL) SWIG_fail;
10537 temp2 = true;
10538 }
10539 if (obj2) {
10540 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10541 if (!SWIG_IsOK(ecode3)) {
10542 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
10543 }
10544 arg3 = static_cast< bool >(val3);
10545 }
10546 {
10547 PyThreadState* __tstate = wxPyBeginAllowThreads();
10548 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
10549 wxPyEndAllowThreads(__tstate);
10550 if (PyErr_Occurred()) SWIG_fail;
10551 }
10552 resultobj = SWIG_Py_Void();
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_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10568 PyObject *resultobj = 0;
10569 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10570 wxString result;
10571 void *argp1 = 0 ;
10572 int res1 = 0 ;
10573 PyObject *swig_obj[1] ;
10574
10575 if (!args) SWIG_fail;
10576 swig_obj[0] = args;
10577 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10578 if (!SWIG_IsOK(res1)) {
10579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10580 }
10581 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10582 {
10583 PyThreadState* __tstate = wxPyBeginAllowThreads();
10584 result = (arg1)->GetPath();
10585 wxPyEndAllowThreads(__tstate);
10586 if (PyErr_Occurred()) SWIG_fail;
10587 }
10588 {
10589 #if wxUSE_UNICODE
10590 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10591 #else
10592 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10593 #endif
10594 }
10595 return resultobj;
10596 fail:
10597 return NULL;
10598 }
10599
10600
10601 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10602 PyObject *resultobj = 0;
10603 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10604 wxString *arg2 = 0 ;
10605 wxFSFile *result = 0 ;
10606 void *argp1 = 0 ;
10607 int res1 = 0 ;
10608 bool temp2 = false ;
10609 PyObject * obj0 = 0 ;
10610 PyObject * obj1 = 0 ;
10611 char * kwnames[] = {
10612 (char *) "self",(char *) "location", NULL
10613 };
10614
10615 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
10616 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10617 if (!SWIG_IsOK(res1)) {
10618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10619 }
10620 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10621 {
10622 arg2 = wxString_in_helper(obj1);
10623 if (arg2 == NULL) SWIG_fail;
10624 temp2 = true;
10625 }
10626 {
10627 PyThreadState* __tstate = wxPyBeginAllowThreads();
10628 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
10629 wxPyEndAllowThreads(__tstate);
10630 if (PyErr_Occurred()) SWIG_fail;
10631 }
10632 {
10633 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
10634 }
10635 {
10636 if (temp2)
10637 delete arg2;
10638 }
10639 return resultobj;
10640 fail:
10641 {
10642 if (temp2)
10643 delete arg2;
10644 }
10645 return NULL;
10646 }
10647
10648
10649 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10650 PyObject *resultobj = 0;
10651 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10652 wxString *arg2 = 0 ;
10653 int arg3 = (int) 0 ;
10654 wxString result;
10655 void *argp1 = 0 ;
10656 int res1 = 0 ;
10657 bool temp2 = false ;
10658 int val3 ;
10659 int ecode3 = 0 ;
10660 PyObject * obj0 = 0 ;
10661 PyObject * obj1 = 0 ;
10662 PyObject * obj2 = 0 ;
10663 char * kwnames[] = {
10664 (char *) "self",(char *) "spec",(char *) "flags", NULL
10665 };
10666
10667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10668 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10669 if (!SWIG_IsOK(res1)) {
10670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10671 }
10672 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10673 {
10674 arg2 = wxString_in_helper(obj1);
10675 if (arg2 == NULL) SWIG_fail;
10676 temp2 = true;
10677 }
10678 if (obj2) {
10679 ecode3 = SWIG_AsVal_int(obj2, &val3);
10680 if (!SWIG_IsOK(ecode3)) {
10681 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
10682 }
10683 arg3 = static_cast< int >(val3);
10684 }
10685 {
10686 PyThreadState* __tstate = wxPyBeginAllowThreads();
10687 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10688 wxPyEndAllowThreads(__tstate);
10689 if (PyErr_Occurred()) SWIG_fail;
10690 }
10691 {
10692 #if wxUSE_UNICODE
10693 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10694 #else
10695 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10696 #endif
10697 }
10698 {
10699 if (temp2)
10700 delete arg2;
10701 }
10702 return resultobj;
10703 fail:
10704 {
10705 if (temp2)
10706 delete arg2;
10707 }
10708 return NULL;
10709 }
10710
10711
10712 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10713 PyObject *resultobj = 0;
10714 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10715 wxString result;
10716 void *argp1 = 0 ;
10717 int res1 = 0 ;
10718 PyObject *swig_obj[1] ;
10719
10720 if (!args) SWIG_fail;
10721 swig_obj[0] = args;
10722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10723 if (!SWIG_IsOK(res1)) {
10724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10725 }
10726 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10727 {
10728 PyThreadState* __tstate = wxPyBeginAllowThreads();
10729 result = (arg1)->FindNext();
10730 wxPyEndAllowThreads(__tstate);
10731 if (PyErr_Occurred()) SWIG_fail;
10732 }
10733 {
10734 #if wxUSE_UNICODE
10735 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10736 #else
10737 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10738 #endif
10739 }
10740 return resultobj;
10741 fail:
10742 return NULL;
10743 }
10744
10745
10746 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10747 PyObject *resultobj = 0;
10748 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10749 int res1 = 0 ;
10750 PyObject * obj0 = 0 ;
10751 char * kwnames[] = {
10752 (char *) "handler", NULL
10753 };
10754
10755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
10756 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
10757 if (!SWIG_IsOK(res1)) {
10758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10759 }
10760 {
10761 PyThreadState* __tstate = wxPyBeginAllowThreads();
10762 wxFileSystem::AddHandler(arg1);
10763 wxPyEndAllowThreads(__tstate);
10764 if (PyErr_Occurred()) SWIG_fail;
10765 }
10766 resultobj = SWIG_Py_Void();
10767 return resultobj;
10768 fail:
10769 return NULL;
10770 }
10771
10772
10773 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10774 PyObject *resultobj = 0;
10775
10776 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
10777 {
10778 PyThreadState* __tstate = wxPyBeginAllowThreads();
10779 wxFileSystem::CleanUpHandlers();
10780 wxPyEndAllowThreads(__tstate);
10781 if (PyErr_Occurred()) SWIG_fail;
10782 }
10783 resultobj = SWIG_Py_Void();
10784 return resultobj;
10785 fail:
10786 return NULL;
10787 }
10788
10789
10790 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10791 PyObject *resultobj = 0;
10792 wxString *arg1 = 0 ;
10793 wxString result;
10794 bool temp1 = false ;
10795 PyObject * obj0 = 0 ;
10796 char * kwnames[] = {
10797 (char *) "filename", NULL
10798 };
10799
10800 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
10801 {
10802 arg1 = wxString_in_helper(obj0);
10803 if (arg1 == NULL) SWIG_fail;
10804 temp1 = true;
10805 }
10806 {
10807 PyThreadState* __tstate = wxPyBeginAllowThreads();
10808 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
10809 wxPyEndAllowThreads(__tstate);
10810 if (PyErr_Occurred()) SWIG_fail;
10811 }
10812 {
10813 #if wxUSE_UNICODE
10814 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10815 #else
10816 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10817 #endif
10818 }
10819 {
10820 if (temp1)
10821 delete arg1;
10822 }
10823 return resultobj;
10824 fail:
10825 {
10826 if (temp1)
10827 delete arg1;
10828 }
10829 return NULL;
10830 }
10831
10832
10833 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10834 PyObject *resultobj = 0;
10835 wxString *arg1 = 0 ;
10836 wxString result;
10837 bool temp1 = false ;
10838 PyObject * obj0 = 0 ;
10839 char * kwnames[] = {
10840 (char *) "url", NULL
10841 };
10842
10843 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
10844 {
10845 arg1 = wxString_in_helper(obj0);
10846 if (arg1 == NULL) SWIG_fail;
10847 temp1 = true;
10848 }
10849 {
10850 PyThreadState* __tstate = wxPyBeginAllowThreads();
10851 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
10852 wxPyEndAllowThreads(__tstate);
10853 if (PyErr_Occurred()) SWIG_fail;
10854 }
10855 {
10856 #if wxUSE_UNICODE
10857 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10858 #else
10859 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10860 #endif
10861 }
10862 {
10863 if (temp1)
10864 delete arg1;
10865 }
10866 return resultobj;
10867 fail:
10868 {
10869 if (temp1)
10870 delete arg1;
10871 }
10872 return NULL;
10873 }
10874
10875
10876 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10877 PyObject *obj;
10878 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10879 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
10880 return SWIG_Py_Void();
10881 }
10882
10883 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10884 return SWIG_Python_InitShadowInstance(args);
10885 }
10886
10887 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10888 PyObject *resultobj = 0;
10889 wxInternetFSHandler *result = 0 ;
10890
10891 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
10892 {
10893 PyThreadState* __tstate = wxPyBeginAllowThreads();
10894 result = (wxInternetFSHandler *)new wxInternetFSHandler();
10895 wxPyEndAllowThreads(__tstate);
10896 if (PyErr_Occurred()) SWIG_fail;
10897 }
10898 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
10899 return resultobj;
10900 fail:
10901 return NULL;
10902 }
10903
10904
10905 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10906 PyObject *resultobj = 0;
10907 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
10908 wxString *arg2 = 0 ;
10909 bool result;
10910 void *argp1 = 0 ;
10911 int res1 = 0 ;
10912 bool temp2 = false ;
10913 PyObject * obj0 = 0 ;
10914 PyObject * obj1 = 0 ;
10915 char * kwnames[] = {
10916 (char *) "self",(char *) "location", NULL
10917 };
10918
10919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10920 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
10921 if (!SWIG_IsOK(res1)) {
10922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
10923 }
10924 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
10925 {
10926 arg2 = wxString_in_helper(obj1);
10927 if (arg2 == NULL) SWIG_fail;
10928 temp2 = true;
10929 }
10930 {
10931 PyThreadState* __tstate = wxPyBeginAllowThreads();
10932 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10933 wxPyEndAllowThreads(__tstate);
10934 if (PyErr_Occurred()) SWIG_fail;
10935 }
10936 {
10937 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10938 }
10939 {
10940 if (temp2)
10941 delete arg2;
10942 }
10943 return resultobj;
10944 fail:
10945 {
10946 if (temp2)
10947 delete arg2;
10948 }
10949 return NULL;
10950 }
10951
10952
10953 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10954 PyObject *resultobj = 0;
10955 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
10956 wxFileSystem *arg2 = 0 ;
10957 wxString *arg3 = 0 ;
10958 wxFSFile *result = 0 ;
10959 void *argp1 = 0 ;
10960 int res1 = 0 ;
10961 void *argp2 = 0 ;
10962 int res2 = 0 ;
10963 bool temp3 = false ;
10964 PyObject * obj0 = 0 ;
10965 PyObject * obj1 = 0 ;
10966 PyObject * obj2 = 0 ;
10967 char * kwnames[] = {
10968 (char *) "self",(char *) "fs",(char *) "location", NULL
10969 };
10970
10971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10972 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
10973 if (!SWIG_IsOK(res1)) {
10974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
10975 }
10976 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
10977 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10978 if (!SWIG_IsOK(res2)) {
10979 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10980 }
10981 if (!argp2) {
10982 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10983 }
10984 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10985 {
10986 arg3 = wxString_in_helper(obj2);
10987 if (arg3 == NULL) SWIG_fail;
10988 temp3 = true;
10989 }
10990 {
10991 PyThreadState* __tstate = wxPyBeginAllowThreads();
10992 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10993 wxPyEndAllowThreads(__tstate);
10994 if (PyErr_Occurred()) SWIG_fail;
10995 }
10996 {
10997 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
10998 }
10999 {
11000 if (temp3)
11001 delete arg3;
11002 }
11003 return resultobj;
11004 fail:
11005 {
11006 if (temp3)
11007 delete arg3;
11008 }
11009 return NULL;
11010 }
11011
11012
11013 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11014 PyObject *obj;
11015 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11016 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
11017 return SWIG_Py_Void();
11018 }
11019
11020 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11021 return SWIG_Python_InitShadowInstance(args);
11022 }
11023
11024 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11025 PyObject *resultobj = 0;
11026 wxZipFSHandler *result = 0 ;
11027
11028 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
11029 {
11030 PyThreadState* __tstate = wxPyBeginAllowThreads();
11031 result = (wxZipFSHandler *)new wxZipFSHandler();
11032 wxPyEndAllowThreads(__tstate);
11033 if (PyErr_Occurred()) SWIG_fail;
11034 }
11035 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
11036 return resultobj;
11037 fail:
11038 return NULL;
11039 }
11040
11041
11042 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11043 PyObject *resultobj = 0;
11044 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11045 wxString *arg2 = 0 ;
11046 bool result;
11047 void *argp1 = 0 ;
11048 int res1 = 0 ;
11049 bool temp2 = false ;
11050 PyObject * obj0 = 0 ;
11051 PyObject * obj1 = 0 ;
11052 char * kwnames[] = {
11053 (char *) "self",(char *) "location", NULL
11054 };
11055
11056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11057 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11058 if (!SWIG_IsOK(res1)) {
11059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11060 }
11061 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11062 {
11063 arg2 = wxString_in_helper(obj1);
11064 if (arg2 == NULL) SWIG_fail;
11065 temp2 = true;
11066 }
11067 {
11068 PyThreadState* __tstate = wxPyBeginAllowThreads();
11069 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11070 wxPyEndAllowThreads(__tstate);
11071 if (PyErr_Occurred()) SWIG_fail;
11072 }
11073 {
11074 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11075 }
11076 {
11077 if (temp2)
11078 delete arg2;
11079 }
11080 return resultobj;
11081 fail:
11082 {
11083 if (temp2)
11084 delete arg2;
11085 }
11086 return NULL;
11087 }
11088
11089
11090 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11091 PyObject *resultobj = 0;
11092 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11093 wxFileSystem *arg2 = 0 ;
11094 wxString *arg3 = 0 ;
11095 wxFSFile *result = 0 ;
11096 void *argp1 = 0 ;
11097 int res1 = 0 ;
11098 void *argp2 = 0 ;
11099 int res2 = 0 ;
11100 bool temp3 = false ;
11101 PyObject * obj0 = 0 ;
11102 PyObject * obj1 = 0 ;
11103 PyObject * obj2 = 0 ;
11104 char * kwnames[] = {
11105 (char *) "self",(char *) "fs",(char *) "location", NULL
11106 };
11107
11108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11110 if (!SWIG_IsOK(res1)) {
11111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11112 }
11113 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11114 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11115 if (!SWIG_IsOK(res2)) {
11116 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11117 }
11118 if (!argp2) {
11119 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11120 }
11121 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11122 {
11123 arg3 = wxString_in_helper(obj2);
11124 if (arg3 == NULL) SWIG_fail;
11125 temp3 = true;
11126 }
11127 {
11128 PyThreadState* __tstate = wxPyBeginAllowThreads();
11129 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11130 wxPyEndAllowThreads(__tstate);
11131 if (PyErr_Occurred()) SWIG_fail;
11132 }
11133 {
11134 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
11135 }
11136 {
11137 if (temp3)
11138 delete arg3;
11139 }
11140 return resultobj;
11141 fail:
11142 {
11143 if (temp3)
11144 delete arg3;
11145 }
11146 return NULL;
11147 }
11148
11149
11150 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11151 PyObject *resultobj = 0;
11152 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11153 wxString *arg2 = 0 ;
11154 int arg3 = (int) 0 ;
11155 wxString result;
11156 void *argp1 = 0 ;
11157 int res1 = 0 ;
11158 bool temp2 = false ;
11159 int val3 ;
11160 int ecode3 = 0 ;
11161 PyObject * obj0 = 0 ;
11162 PyObject * obj1 = 0 ;
11163 PyObject * obj2 = 0 ;
11164 char * kwnames[] = {
11165 (char *) "self",(char *) "spec",(char *) "flags", NULL
11166 };
11167
11168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11170 if (!SWIG_IsOK(res1)) {
11171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11172 }
11173 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11174 {
11175 arg2 = wxString_in_helper(obj1);
11176 if (arg2 == NULL) SWIG_fail;
11177 temp2 = true;
11178 }
11179 if (obj2) {
11180 ecode3 = SWIG_AsVal_int(obj2, &val3);
11181 if (!SWIG_IsOK(ecode3)) {
11182 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11183 }
11184 arg3 = static_cast< int >(val3);
11185 }
11186 {
11187 PyThreadState* __tstate = wxPyBeginAllowThreads();
11188 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11189 wxPyEndAllowThreads(__tstate);
11190 if (PyErr_Occurred()) SWIG_fail;
11191 }
11192 {
11193 #if wxUSE_UNICODE
11194 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11195 #else
11196 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11197 #endif
11198 }
11199 {
11200 if (temp2)
11201 delete arg2;
11202 }
11203 return resultobj;
11204 fail:
11205 {
11206 if (temp2)
11207 delete arg2;
11208 }
11209 return NULL;
11210 }
11211
11212
11213 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11214 PyObject *resultobj = 0;
11215 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11216 wxString result;
11217 void *argp1 = 0 ;
11218 int res1 = 0 ;
11219 PyObject *swig_obj[1] ;
11220
11221 if (!args) SWIG_fail;
11222 swig_obj[0] = args;
11223 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11224 if (!SWIG_IsOK(res1)) {
11225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11226 }
11227 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11228 {
11229 PyThreadState* __tstate = wxPyBeginAllowThreads();
11230 result = (arg1)->FindNext();
11231 wxPyEndAllowThreads(__tstate);
11232 if (PyErr_Occurred()) SWIG_fail;
11233 }
11234 {
11235 #if wxUSE_UNICODE
11236 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11237 #else
11238 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11239 #endif
11240 }
11241 return resultobj;
11242 fail:
11243 return NULL;
11244 }
11245
11246
11247 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11248 PyObject *obj;
11249 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11250 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
11251 return SWIG_Py_Void();
11252 }
11253
11254 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11255 return SWIG_Python_InitShadowInstance(args);
11256 }
11257
11258 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11259 PyObject *resultobj = 0;
11260 wxString *arg1 = 0 ;
11261 wxImage *arg2 = 0 ;
11262 long arg3 ;
11263 bool temp1 = false ;
11264 void *argp2 = 0 ;
11265 int res2 = 0 ;
11266 long val3 ;
11267 int ecode3 = 0 ;
11268 PyObject * obj0 = 0 ;
11269 PyObject * obj1 = 0 ;
11270 PyObject * obj2 = 0 ;
11271 char * kwnames[] = {
11272 (char *) "filename",(char *) "image",(char *) "type", NULL
11273 };
11274
11275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11276 {
11277 arg1 = wxString_in_helper(obj0);
11278 if (arg1 == NULL) SWIG_fail;
11279 temp1 = true;
11280 }
11281 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
11282 if (!SWIG_IsOK(res2)) {
11283 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11284 }
11285 if (!argp2) {
11286 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11287 }
11288 arg2 = reinterpret_cast< wxImage * >(argp2);
11289 ecode3 = SWIG_AsVal_long(obj2, &val3);
11290 if (!SWIG_IsOK(ecode3)) {
11291 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
11292 }
11293 arg3 = static_cast< long >(val3);
11294 {
11295 PyThreadState* __tstate = wxPyBeginAllowThreads();
11296 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
11297 wxPyEndAllowThreads(__tstate);
11298 if (PyErr_Occurred()) SWIG_fail;
11299 }
11300 resultobj = SWIG_Py_Void();
11301 {
11302 if (temp1)
11303 delete arg1;
11304 }
11305 return resultobj;
11306 fail:
11307 {
11308 if (temp1)
11309 delete arg1;
11310 }
11311 return NULL;
11312 }
11313
11314
11315 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11316 PyObject *resultobj = 0;
11317 wxString *arg1 = 0 ;
11318 wxBitmap *arg2 = 0 ;
11319 long arg3 ;
11320 bool temp1 = false ;
11321 void *argp2 = 0 ;
11322 int res2 = 0 ;
11323 long val3 ;
11324 int ecode3 = 0 ;
11325 PyObject * obj0 = 0 ;
11326 PyObject * obj1 = 0 ;
11327 PyObject * obj2 = 0 ;
11328 char * kwnames[] = {
11329 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
11330 };
11331
11332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11333 {
11334 arg1 = wxString_in_helper(obj0);
11335 if (arg1 == NULL) SWIG_fail;
11336 temp1 = true;
11337 }
11338 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
11339 if (!SWIG_IsOK(res2)) {
11340 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11341 }
11342 if (!argp2) {
11343 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11344 }
11345 arg2 = reinterpret_cast< wxBitmap * >(argp2);
11346 ecode3 = SWIG_AsVal_long(obj2, &val3);
11347 if (!SWIG_IsOK(ecode3)) {
11348 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
11349 }
11350 arg3 = static_cast< long >(val3);
11351 {
11352 PyThreadState* __tstate = wxPyBeginAllowThreads();
11353 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
11354 wxPyEndAllowThreads(__tstate);
11355 if (PyErr_Occurred()) SWIG_fail;
11356 }
11357 resultobj = SWIG_Py_Void();
11358 {
11359 if (temp1)
11360 delete arg1;
11361 }
11362 return resultobj;
11363 fail:
11364 {
11365 if (temp1)
11366 delete arg1;
11367 }
11368 return NULL;
11369 }
11370
11371
11372 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11373 PyObject *resultobj = 0;
11374 wxString *arg1 = 0 ;
11375 PyObject *arg2 = (PyObject *) 0 ;
11376 bool temp1 = false ;
11377 PyObject * obj0 = 0 ;
11378 PyObject * obj1 = 0 ;
11379 char * kwnames[] = {
11380 (char *) "filename",(char *) "data", NULL
11381 };
11382
11383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
11384 {
11385 arg1 = wxString_in_helper(obj0);
11386 if (arg1 == NULL) SWIG_fail;
11387 temp1 = true;
11388 }
11389 arg2 = obj1;
11390 {
11391 PyThreadState* __tstate = wxPyBeginAllowThreads();
11392 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
11393 wxPyEndAllowThreads(__tstate);
11394 if (PyErr_Occurred()) SWIG_fail;
11395 }
11396 resultobj = SWIG_Py_Void();
11397 {
11398 if (temp1)
11399 delete arg1;
11400 }
11401 return resultobj;
11402 fail:
11403 {
11404 if (temp1)
11405 delete arg1;
11406 }
11407 return NULL;
11408 }
11409
11410
11411 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11412 PyObject *resultobj = 0;
11413 wxMemoryFSHandler *result = 0 ;
11414
11415 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
11416 {
11417 PyThreadState* __tstate = wxPyBeginAllowThreads();
11418 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
11419 wxPyEndAllowThreads(__tstate);
11420 if (PyErr_Occurred()) SWIG_fail;
11421 }
11422 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
11423 return resultobj;
11424 fail:
11425 return NULL;
11426 }
11427
11428
11429 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11430 PyObject *resultobj = 0;
11431 wxString *arg1 = 0 ;
11432 bool temp1 = false ;
11433 PyObject * obj0 = 0 ;
11434 char * kwnames[] = {
11435 (char *) "filename", NULL
11436 };
11437
11438 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
11439 {
11440 arg1 = wxString_in_helper(obj0);
11441 if (arg1 == NULL) SWIG_fail;
11442 temp1 = true;
11443 }
11444 {
11445 PyThreadState* __tstate = wxPyBeginAllowThreads();
11446 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
11447 wxPyEndAllowThreads(__tstate);
11448 if (PyErr_Occurred()) SWIG_fail;
11449 }
11450 resultobj = SWIG_Py_Void();
11451 {
11452 if (temp1)
11453 delete arg1;
11454 }
11455 return resultobj;
11456 fail:
11457 {
11458 if (temp1)
11459 delete arg1;
11460 }
11461 return NULL;
11462 }
11463
11464
11465 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11466 PyObject *resultobj = 0;
11467 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11468 wxString *arg2 = 0 ;
11469 bool result;
11470 void *argp1 = 0 ;
11471 int res1 = 0 ;
11472 bool temp2 = false ;
11473 PyObject * obj0 = 0 ;
11474 PyObject * obj1 = 0 ;
11475 char * kwnames[] = {
11476 (char *) "self",(char *) "location", NULL
11477 };
11478
11479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11480 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11481 if (!SWIG_IsOK(res1)) {
11482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11483 }
11484 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11485 {
11486 arg2 = wxString_in_helper(obj1);
11487 if (arg2 == NULL) SWIG_fail;
11488 temp2 = true;
11489 }
11490 {
11491 PyThreadState* __tstate = wxPyBeginAllowThreads();
11492 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11493 wxPyEndAllowThreads(__tstate);
11494 if (PyErr_Occurred()) SWIG_fail;
11495 }
11496 {
11497 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11498 }
11499 {
11500 if (temp2)
11501 delete arg2;
11502 }
11503 return resultobj;
11504 fail:
11505 {
11506 if (temp2)
11507 delete arg2;
11508 }
11509 return NULL;
11510 }
11511
11512
11513 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11514 PyObject *resultobj = 0;
11515 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11516 wxFileSystem *arg2 = 0 ;
11517 wxString *arg3 = 0 ;
11518 wxFSFile *result = 0 ;
11519 void *argp1 = 0 ;
11520 int res1 = 0 ;
11521 void *argp2 = 0 ;
11522 int res2 = 0 ;
11523 bool temp3 = false ;
11524 PyObject * obj0 = 0 ;
11525 PyObject * obj1 = 0 ;
11526 PyObject * obj2 = 0 ;
11527 char * kwnames[] = {
11528 (char *) "self",(char *) "fs",(char *) "location", NULL
11529 };
11530
11531 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11532 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11533 if (!SWIG_IsOK(res1)) {
11534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11535 }
11536 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11537 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11538 if (!SWIG_IsOK(res2)) {
11539 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11540 }
11541 if (!argp2) {
11542 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11543 }
11544 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11545 {
11546 arg3 = wxString_in_helper(obj2);
11547 if (arg3 == NULL) SWIG_fail;
11548 temp3 = true;
11549 }
11550 {
11551 PyThreadState* __tstate = wxPyBeginAllowThreads();
11552 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11553 wxPyEndAllowThreads(__tstate);
11554 if (PyErr_Occurred()) SWIG_fail;
11555 }
11556 {
11557 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
11558 }
11559 {
11560 if (temp3)
11561 delete arg3;
11562 }
11563 return resultobj;
11564 fail:
11565 {
11566 if (temp3)
11567 delete arg3;
11568 }
11569 return NULL;
11570 }
11571
11572
11573 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11574 PyObject *resultobj = 0;
11575 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11576 wxString *arg2 = 0 ;
11577 int arg3 = (int) 0 ;
11578 wxString result;
11579 void *argp1 = 0 ;
11580 int res1 = 0 ;
11581 bool temp2 = false ;
11582 int val3 ;
11583 int ecode3 = 0 ;
11584 PyObject * obj0 = 0 ;
11585 PyObject * obj1 = 0 ;
11586 PyObject * obj2 = 0 ;
11587 char * kwnames[] = {
11588 (char *) "self",(char *) "spec",(char *) "flags", NULL
11589 };
11590
11591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11593 if (!SWIG_IsOK(res1)) {
11594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11595 }
11596 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11597 {
11598 arg2 = wxString_in_helper(obj1);
11599 if (arg2 == NULL) SWIG_fail;
11600 temp2 = true;
11601 }
11602 if (obj2) {
11603 ecode3 = SWIG_AsVal_int(obj2, &val3);
11604 if (!SWIG_IsOK(ecode3)) {
11605 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11606 }
11607 arg3 = static_cast< int >(val3);
11608 }
11609 {
11610 PyThreadState* __tstate = wxPyBeginAllowThreads();
11611 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11612 wxPyEndAllowThreads(__tstate);
11613 if (PyErr_Occurred()) SWIG_fail;
11614 }
11615 {
11616 #if wxUSE_UNICODE
11617 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11618 #else
11619 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11620 #endif
11621 }
11622 {
11623 if (temp2)
11624 delete arg2;
11625 }
11626 return resultobj;
11627 fail:
11628 {
11629 if (temp2)
11630 delete arg2;
11631 }
11632 return NULL;
11633 }
11634
11635
11636 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11637 PyObject *resultobj = 0;
11638 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11639 wxString result;
11640 void *argp1 = 0 ;
11641 int res1 = 0 ;
11642 PyObject *swig_obj[1] ;
11643
11644 if (!args) SWIG_fail;
11645 swig_obj[0] = args;
11646 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11647 if (!SWIG_IsOK(res1)) {
11648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11649 }
11650 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11651 {
11652 PyThreadState* __tstate = wxPyBeginAllowThreads();
11653 result = (arg1)->FindNext();
11654 wxPyEndAllowThreads(__tstate);
11655 if (PyErr_Occurred()) SWIG_fail;
11656 }
11657 {
11658 #if wxUSE_UNICODE
11659 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11660 #else
11661 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11662 #endif
11663 }
11664 return resultobj;
11665 fail:
11666 return NULL;
11667 }
11668
11669
11670 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11671 PyObject *obj;
11672 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11673 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
11674 return SWIG_Py_Void();
11675 }
11676
11677 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11678 return SWIG_Python_InitShadowInstance(args);
11679 }
11680
11681 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11682 PyObject *resultobj = 0;
11683 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11684 wxString result;
11685 void *argp1 = 0 ;
11686 int res1 = 0 ;
11687 PyObject *swig_obj[1] ;
11688
11689 if (!args) SWIG_fail;
11690 swig_obj[0] = args;
11691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11692 if (!SWIG_IsOK(res1)) {
11693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11694 }
11695 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11696 {
11697 PyThreadState* __tstate = wxPyBeginAllowThreads();
11698 result = (arg1)->GetName();
11699 wxPyEndAllowThreads(__tstate);
11700 if (PyErr_Occurred()) SWIG_fail;
11701 }
11702 {
11703 #if wxUSE_UNICODE
11704 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11705 #else
11706 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11707 #endif
11708 }
11709 return resultobj;
11710 fail:
11711 return NULL;
11712 }
11713
11714
11715 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11716 PyObject *resultobj = 0;
11717 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11718 wxString result;
11719 void *argp1 = 0 ;
11720 int res1 = 0 ;
11721 PyObject *swig_obj[1] ;
11722
11723 if (!args) SWIG_fail;
11724 swig_obj[0] = args;
11725 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11726 if (!SWIG_IsOK(res1)) {
11727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11728 }
11729 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11730 {
11731 PyThreadState* __tstate = wxPyBeginAllowThreads();
11732 result = (arg1)->GetExtension();
11733 wxPyEndAllowThreads(__tstate);
11734 if (PyErr_Occurred()) SWIG_fail;
11735 }
11736 {
11737 #if wxUSE_UNICODE
11738 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11739 #else
11740 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11741 #endif
11742 }
11743 return resultobj;
11744 fail:
11745 return NULL;
11746 }
11747
11748
11749 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11750 PyObject *resultobj = 0;
11751 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11752 long result;
11753 void *argp1 = 0 ;
11754 int res1 = 0 ;
11755 PyObject *swig_obj[1] ;
11756
11757 if (!args) SWIG_fail;
11758 swig_obj[0] = args;
11759 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11760 if (!SWIG_IsOK(res1)) {
11761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11762 }
11763 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11764 {
11765 PyThreadState* __tstate = wxPyBeginAllowThreads();
11766 result = (long)(arg1)->GetType();
11767 wxPyEndAllowThreads(__tstate);
11768 if (PyErr_Occurred()) SWIG_fail;
11769 }
11770 resultobj = SWIG_From_long(static_cast< long >(result));
11771 return resultobj;
11772 fail:
11773 return NULL;
11774 }
11775
11776
11777 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11778 PyObject *resultobj = 0;
11779 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11780 wxString result;
11781 void *argp1 = 0 ;
11782 int res1 = 0 ;
11783 PyObject *swig_obj[1] ;
11784
11785 if (!args) SWIG_fail;
11786 swig_obj[0] = args;
11787 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11788 if (!SWIG_IsOK(res1)) {
11789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11790 }
11791 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11792 {
11793 PyThreadState* __tstate = wxPyBeginAllowThreads();
11794 result = (arg1)->GetMimeType();
11795 wxPyEndAllowThreads(__tstate);
11796 if (PyErr_Occurred()) SWIG_fail;
11797 }
11798 {
11799 #if wxUSE_UNICODE
11800 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11801 #else
11802 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11803 #endif
11804 }
11805 return resultobj;
11806 fail:
11807 return NULL;
11808 }
11809
11810
11811 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11812 PyObject *resultobj = 0;
11813 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11814 wxString *arg2 = 0 ;
11815 bool result;
11816 void *argp1 = 0 ;
11817 int res1 = 0 ;
11818 bool temp2 = false ;
11819 PyObject * obj0 = 0 ;
11820 PyObject * obj1 = 0 ;
11821 char * kwnames[] = {
11822 (char *) "self",(char *) "name", NULL
11823 };
11824
11825 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
11826 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11827 if (!SWIG_IsOK(res1)) {
11828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11829 }
11830 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11831 {
11832 arg2 = wxString_in_helper(obj1);
11833 if (arg2 == NULL) SWIG_fail;
11834 temp2 = true;
11835 }
11836 {
11837 PyThreadState* __tstate = wxPyBeginAllowThreads();
11838 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
11839 wxPyEndAllowThreads(__tstate);
11840 if (PyErr_Occurred()) SWIG_fail;
11841 }
11842 {
11843 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11844 }
11845 {
11846 if (temp2)
11847 delete arg2;
11848 }
11849 return resultobj;
11850 fail:
11851 {
11852 if (temp2)
11853 delete arg2;
11854 }
11855 return NULL;
11856 }
11857
11858
11859 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11860 PyObject *resultobj = 0;
11861 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11862 wxString *arg2 = 0 ;
11863 void *argp1 = 0 ;
11864 int res1 = 0 ;
11865 bool temp2 = false ;
11866 PyObject * obj0 = 0 ;
11867 PyObject * obj1 = 0 ;
11868 char * kwnames[] = {
11869 (char *) "self",(char *) "name", NULL
11870 };
11871
11872 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
11873 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11874 if (!SWIG_IsOK(res1)) {
11875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11876 }
11877 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11878 {
11879 arg2 = wxString_in_helper(obj1);
11880 if (arg2 == NULL) SWIG_fail;
11881 temp2 = true;
11882 }
11883 {
11884 PyThreadState* __tstate = wxPyBeginAllowThreads();
11885 (arg1)->SetName((wxString const &)*arg2);
11886 wxPyEndAllowThreads(__tstate);
11887 if (PyErr_Occurred()) SWIG_fail;
11888 }
11889 resultobj = SWIG_Py_Void();
11890 {
11891 if (temp2)
11892 delete arg2;
11893 }
11894 return resultobj;
11895 fail:
11896 {
11897 if (temp2)
11898 delete arg2;
11899 }
11900 return NULL;
11901 }
11902
11903
11904 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11905 PyObject *resultobj = 0;
11906 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11907 wxString *arg2 = 0 ;
11908 void *argp1 = 0 ;
11909 int res1 = 0 ;
11910 bool temp2 = false ;
11911 PyObject * obj0 = 0 ;
11912 PyObject * obj1 = 0 ;
11913 char * kwnames[] = {
11914 (char *) "self",(char *) "extension", NULL
11915 };
11916
11917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
11918 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11919 if (!SWIG_IsOK(res1)) {
11920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11921 }
11922 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11923 {
11924 arg2 = wxString_in_helper(obj1);
11925 if (arg2 == NULL) SWIG_fail;
11926 temp2 = true;
11927 }
11928 {
11929 PyThreadState* __tstate = wxPyBeginAllowThreads();
11930 (arg1)->SetExtension((wxString const &)*arg2);
11931 wxPyEndAllowThreads(__tstate);
11932 if (PyErr_Occurred()) SWIG_fail;
11933 }
11934 resultobj = SWIG_Py_Void();
11935 {
11936 if (temp2)
11937 delete arg2;
11938 }
11939 return resultobj;
11940 fail:
11941 {
11942 if (temp2)
11943 delete arg2;
11944 }
11945 return NULL;
11946 }
11947
11948
11949 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11950 PyObject *resultobj = 0;
11951 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11952 long arg2 ;
11953 void *argp1 = 0 ;
11954 int res1 = 0 ;
11955 long val2 ;
11956 int ecode2 = 0 ;
11957 PyObject * obj0 = 0 ;
11958 PyObject * obj1 = 0 ;
11959 char * kwnames[] = {
11960 (char *) "self",(char *) "type", NULL
11961 };
11962
11963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
11964 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11965 if (!SWIG_IsOK(res1)) {
11966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11967 }
11968 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11969 ecode2 = SWIG_AsVal_long(obj1, &val2);
11970 if (!SWIG_IsOK(ecode2)) {
11971 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
11972 }
11973 arg2 = static_cast< long >(val2);
11974 {
11975 PyThreadState* __tstate = wxPyBeginAllowThreads();
11976 (arg1)->SetType(arg2);
11977 wxPyEndAllowThreads(__tstate);
11978 if (PyErr_Occurred()) SWIG_fail;
11979 }
11980 resultobj = SWIG_Py_Void();
11981 return resultobj;
11982 fail:
11983 return NULL;
11984 }
11985
11986
11987 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11988 PyObject *resultobj = 0;
11989 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11990 wxString *arg2 = 0 ;
11991 void *argp1 = 0 ;
11992 int res1 = 0 ;
11993 bool temp2 = false ;
11994 PyObject * obj0 = 0 ;
11995 PyObject * obj1 = 0 ;
11996 char * kwnames[] = {
11997 (char *) "self",(char *) "mimetype", NULL
11998 };
11999
12000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
12001 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12002 if (!SWIG_IsOK(res1)) {
12003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12004 }
12005 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12006 {
12007 arg2 = wxString_in_helper(obj1);
12008 if (arg2 == NULL) SWIG_fail;
12009 temp2 = true;
12010 }
12011 {
12012 PyThreadState* __tstate = wxPyBeginAllowThreads();
12013 (arg1)->SetMimeType((wxString const &)*arg2);
12014 wxPyEndAllowThreads(__tstate);
12015 if (PyErr_Occurred()) SWIG_fail;
12016 }
12017 resultobj = SWIG_Py_Void();
12018 {
12019 if (temp2)
12020 delete arg2;
12021 }
12022 return resultobj;
12023 fail:
12024 {
12025 if (temp2)
12026 delete arg2;
12027 }
12028 return NULL;
12029 }
12030
12031
12032 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12033 PyObject *obj;
12034 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12035 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
12036 return SWIG_Py_Void();
12037 }
12038
12039 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12040 PyObject *resultobj = 0;
12041 wxPyImageHandler *result = 0 ;
12042
12043 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
12044 {
12045 PyThreadState* __tstate = wxPyBeginAllowThreads();
12046 result = (wxPyImageHandler *)new wxPyImageHandler();
12047 wxPyEndAllowThreads(__tstate);
12048 if (PyErr_Occurred()) SWIG_fail;
12049 }
12050 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
12051 return resultobj;
12052 fail:
12053 return NULL;
12054 }
12055
12056
12057 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12058 PyObject *resultobj = 0;
12059 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
12060 PyObject *arg2 = (PyObject *) 0 ;
12061 void *argp1 = 0 ;
12062 int res1 = 0 ;
12063 PyObject * obj0 = 0 ;
12064 PyObject * obj1 = 0 ;
12065 char * kwnames[] = {
12066 (char *) "self",(char *) "self", NULL
12067 };
12068
12069 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
12070 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
12071 if (!SWIG_IsOK(res1)) {
12072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
12073 }
12074 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
12075 arg2 = obj1;
12076 {
12077 PyThreadState* __tstate = wxPyBeginAllowThreads();
12078 (arg1)->_SetSelf(arg2);
12079 wxPyEndAllowThreads(__tstate);
12080 if (PyErr_Occurred()) SWIG_fail;
12081 }
12082 resultobj = SWIG_Py_Void();
12083 return resultobj;
12084 fail:
12085 return NULL;
12086 }
12087
12088
12089 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12090 PyObject *obj;
12091 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12092 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
12093 return SWIG_Py_Void();
12094 }
12095
12096 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12097 return SWIG_Python_InitShadowInstance(args);
12098 }
12099
12100 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12101 PyObject *resultobj = 0;
12102 wxImageHistogram *result = 0 ;
12103
12104 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
12105 {
12106 PyThreadState* __tstate = wxPyBeginAllowThreads();
12107 result = (wxImageHistogram *)new wxImageHistogram();
12108 wxPyEndAllowThreads(__tstate);
12109 if (PyErr_Occurred()) SWIG_fail;
12110 }
12111 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
12112 return resultobj;
12113 fail:
12114 return NULL;
12115 }
12116
12117
12118 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12119 PyObject *resultobj = 0;
12120 byte arg1 ;
12121 byte arg2 ;
12122 byte arg3 ;
12123 unsigned long result;
12124 unsigned char val1 ;
12125 int ecode1 = 0 ;
12126 unsigned char val2 ;
12127 int ecode2 = 0 ;
12128 unsigned char val3 ;
12129 int ecode3 = 0 ;
12130 PyObject * obj0 = 0 ;
12131 PyObject * obj1 = 0 ;
12132 PyObject * obj2 = 0 ;
12133 char * kwnames[] = {
12134 (char *) "r",(char *) "g",(char *) "b", NULL
12135 };
12136
12137 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12138 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12139 if (!SWIG_IsOK(ecode1)) {
12140 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
12141 }
12142 arg1 = static_cast< byte >(val1);
12143 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12144 if (!SWIG_IsOK(ecode2)) {
12145 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
12146 }
12147 arg2 = static_cast< byte >(val2);
12148 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12149 if (!SWIG_IsOK(ecode3)) {
12150 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
12151 }
12152 arg3 = static_cast< byte >(val3);
12153 {
12154 PyThreadState* __tstate = wxPyBeginAllowThreads();
12155 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
12156 wxPyEndAllowThreads(__tstate);
12157 if (PyErr_Occurred()) SWIG_fail;
12158 }
12159 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12160 return resultobj;
12161 fail:
12162 return NULL;
12163 }
12164
12165
12166 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12167 PyObject *resultobj = 0;
12168 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12169 byte *arg2 = (byte *) 0 ;
12170 byte *arg3 = (byte *) 0 ;
12171 byte *arg4 = (byte *) 0 ;
12172 byte arg5 = (byte) 1 ;
12173 byte arg6 = (byte) 0 ;
12174 byte arg7 = (byte) 0 ;
12175 bool result;
12176 void *argp1 = 0 ;
12177 int res1 = 0 ;
12178 byte temp2 ;
12179 int res2 = SWIG_TMPOBJ ;
12180 byte temp3 ;
12181 int res3 = SWIG_TMPOBJ ;
12182 byte temp4 ;
12183 int res4 = SWIG_TMPOBJ ;
12184 unsigned char val5 ;
12185 int ecode5 = 0 ;
12186 unsigned char val6 ;
12187 int ecode6 = 0 ;
12188 unsigned char val7 ;
12189 int ecode7 = 0 ;
12190 PyObject * obj0 = 0 ;
12191 PyObject * obj1 = 0 ;
12192 PyObject * obj2 = 0 ;
12193 PyObject * obj3 = 0 ;
12194 char * kwnames[] = {
12195 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
12196 };
12197
12198 arg2 = &temp2;
12199 arg3 = &temp3;
12200 arg4 = &temp4;
12201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12203 if (!SWIG_IsOK(res1)) {
12204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
12205 }
12206 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12207 if (obj1) {
12208 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
12209 if (!SWIG_IsOK(ecode5)) {
12210 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
12211 }
12212 arg5 = static_cast< byte >(val5);
12213 }
12214 if (obj2) {
12215 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
12216 if (!SWIG_IsOK(ecode6)) {
12217 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
12218 }
12219 arg6 = static_cast< byte >(val6);
12220 }
12221 if (obj3) {
12222 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
12223 if (!SWIG_IsOK(ecode7)) {
12224 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
12225 }
12226 arg7 = static_cast< byte >(val7);
12227 }
12228 {
12229 PyThreadState* __tstate = wxPyBeginAllowThreads();
12230 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
12231 wxPyEndAllowThreads(__tstate);
12232 if (PyErr_Occurred()) SWIG_fail;
12233 }
12234 {
12235 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12236 }
12237 if (SWIG_IsTmpObj(res2)) {
12238 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
12239 } else {
12240 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12241 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
12242 }
12243 if (SWIG_IsTmpObj(res3)) {
12244 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
12245 } else {
12246 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12247 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
12248 }
12249 if (SWIG_IsTmpObj(res4)) {
12250 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
12251 } else {
12252 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12253 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
12254 }
12255 return resultobj;
12256 fail:
12257 return NULL;
12258 }
12259
12260
12261 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12262 PyObject *resultobj = 0;
12263 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12264 unsigned long arg2 ;
12265 unsigned long result;
12266 void *argp1 = 0 ;
12267 int res1 = 0 ;
12268 unsigned long val2 ;
12269 int ecode2 = 0 ;
12270 PyObject * obj0 = 0 ;
12271 PyObject * obj1 = 0 ;
12272 char * kwnames[] = {
12273 (char *) "self",(char *) "key", NULL
12274 };
12275
12276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
12277 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12278 if (!SWIG_IsOK(res1)) {
12279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12280 }
12281 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12282 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
12283 if (!SWIG_IsOK(ecode2)) {
12284 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
12285 }
12286 arg2 = static_cast< unsigned long >(val2);
12287 {
12288 PyThreadState* __tstate = wxPyBeginAllowThreads();
12289 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
12290 wxPyEndAllowThreads(__tstate);
12291 if (PyErr_Occurred()) SWIG_fail;
12292 }
12293 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12294 return resultobj;
12295 fail:
12296 return NULL;
12297 }
12298
12299
12300 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12301 PyObject *resultobj = 0;
12302 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12303 byte arg2 ;
12304 byte arg3 ;
12305 byte arg4 ;
12306 unsigned long result;
12307 void *argp1 = 0 ;
12308 int res1 = 0 ;
12309 unsigned char val2 ;
12310 int ecode2 = 0 ;
12311 unsigned char val3 ;
12312 int ecode3 = 0 ;
12313 unsigned char val4 ;
12314 int ecode4 = 0 ;
12315 PyObject * obj0 = 0 ;
12316 PyObject * obj1 = 0 ;
12317 PyObject * obj2 = 0 ;
12318 PyObject * obj3 = 0 ;
12319 char * kwnames[] = {
12320 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12321 };
12322
12323 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12324 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12325 if (!SWIG_IsOK(res1)) {
12326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12327 }
12328 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12329 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12330 if (!SWIG_IsOK(ecode2)) {
12331 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
12332 }
12333 arg2 = static_cast< byte >(val2);
12334 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12335 if (!SWIG_IsOK(ecode3)) {
12336 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
12337 }
12338 arg3 = static_cast< byte >(val3);
12339 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
12340 if (!SWIG_IsOK(ecode4)) {
12341 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
12342 }
12343 arg4 = static_cast< byte >(val4);
12344 {
12345 PyThreadState* __tstate = wxPyBeginAllowThreads();
12346 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
12347 wxPyEndAllowThreads(__tstate);
12348 if (PyErr_Occurred()) SWIG_fail;
12349 }
12350 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12351 return resultobj;
12352 fail:
12353 return NULL;
12354 }
12355
12356
12357 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12358 PyObject *resultobj = 0;
12359 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12360 wxColour *arg2 = 0 ;
12361 unsigned long result;
12362 void *argp1 = 0 ;
12363 int res1 = 0 ;
12364 wxColour temp2 ;
12365 PyObject * obj0 = 0 ;
12366 PyObject * obj1 = 0 ;
12367 char * kwnames[] = {
12368 (char *) "self",(char *) "colour", NULL
12369 };
12370
12371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
12372 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12373 if (!SWIG_IsOK(res1)) {
12374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12375 }
12376 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12377 {
12378 arg2 = &temp2;
12379 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12380 }
12381 {
12382 PyThreadState* __tstate = wxPyBeginAllowThreads();
12383 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
12384 wxPyEndAllowThreads(__tstate);
12385 if (PyErr_Occurred()) SWIG_fail;
12386 }
12387 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12388 return resultobj;
12389 fail:
12390 return NULL;
12391 }
12392
12393
12394 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12395 PyObject *obj;
12396 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12397 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
12398 return SWIG_Py_Void();
12399 }
12400
12401 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12402 return SWIG_Python_InitShadowInstance(args);
12403 }
12404
12405 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12406 PyObject *resultobj = 0;
12407 byte arg1 = (byte) 0 ;
12408 byte arg2 = (byte) 0 ;
12409 byte arg3 = (byte) 0 ;
12410 wxImage_RGBValue *result = 0 ;
12411 unsigned char val1 ;
12412 int ecode1 = 0 ;
12413 unsigned char val2 ;
12414 int ecode2 = 0 ;
12415 unsigned char val3 ;
12416 int ecode3 = 0 ;
12417 PyObject * obj0 = 0 ;
12418 PyObject * obj1 = 0 ;
12419 PyObject * obj2 = 0 ;
12420 char * kwnames[] = {
12421 (char *) "r",(char *) "g",(char *) "b", NULL
12422 };
12423
12424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12425 if (obj0) {
12426 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12427 if (!SWIG_IsOK(ecode1)) {
12428 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
12429 }
12430 arg1 = static_cast< byte >(val1);
12431 }
12432 if (obj1) {
12433 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12434 if (!SWIG_IsOK(ecode2)) {
12435 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
12436 }
12437 arg2 = static_cast< byte >(val2);
12438 }
12439 if (obj2) {
12440 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12441 if (!SWIG_IsOK(ecode3)) {
12442 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
12443 }
12444 arg3 = static_cast< byte >(val3);
12445 }
12446 {
12447 PyThreadState* __tstate = wxPyBeginAllowThreads();
12448 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
12449 wxPyEndAllowThreads(__tstate);
12450 if (PyErr_Occurred()) SWIG_fail;
12451 }
12452 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
12453 return resultobj;
12454 fail:
12455 return NULL;
12456 }
12457
12458
12459 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12460 PyObject *resultobj = 0;
12461 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12462 byte arg2 ;
12463 void *argp1 = 0 ;
12464 int res1 = 0 ;
12465 unsigned char val2 ;
12466 int ecode2 = 0 ;
12467 PyObject *swig_obj[2] ;
12468
12469 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
12470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12471 if (!SWIG_IsOK(res1)) {
12472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12473 }
12474 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12475 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12476 if (!SWIG_IsOK(ecode2)) {
12477 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
12478 }
12479 arg2 = static_cast< byte >(val2);
12480 if (arg1) (arg1)->red = arg2;
12481
12482 resultobj = SWIG_Py_Void();
12483 return resultobj;
12484 fail:
12485 return NULL;
12486 }
12487
12488
12489 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12490 PyObject *resultobj = 0;
12491 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12492 byte result;
12493 void *argp1 = 0 ;
12494 int res1 = 0 ;
12495 PyObject *swig_obj[1] ;
12496
12497 if (!args) SWIG_fail;
12498 swig_obj[0] = args;
12499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12500 if (!SWIG_IsOK(res1)) {
12501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12502 }
12503 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12504 result = (byte) ((arg1)->red);
12505 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12506 return resultobj;
12507 fail:
12508 return NULL;
12509 }
12510
12511
12512 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12513 PyObject *resultobj = 0;
12514 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12515 byte arg2 ;
12516 void *argp1 = 0 ;
12517 int res1 = 0 ;
12518 unsigned char val2 ;
12519 int ecode2 = 0 ;
12520 PyObject *swig_obj[2] ;
12521
12522 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
12523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12524 if (!SWIG_IsOK(res1)) {
12525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12526 }
12527 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12528 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12529 if (!SWIG_IsOK(ecode2)) {
12530 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
12531 }
12532 arg2 = static_cast< byte >(val2);
12533 if (arg1) (arg1)->green = arg2;
12534
12535 resultobj = SWIG_Py_Void();
12536 return resultobj;
12537 fail:
12538 return NULL;
12539 }
12540
12541
12542 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12543 PyObject *resultobj = 0;
12544 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12545 byte result;
12546 void *argp1 = 0 ;
12547 int res1 = 0 ;
12548 PyObject *swig_obj[1] ;
12549
12550 if (!args) SWIG_fail;
12551 swig_obj[0] = args;
12552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12553 if (!SWIG_IsOK(res1)) {
12554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12555 }
12556 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12557 result = (byte) ((arg1)->green);
12558 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12559 return resultobj;
12560 fail:
12561 return NULL;
12562 }
12563
12564
12565 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12566 PyObject *resultobj = 0;
12567 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12568 byte arg2 ;
12569 void *argp1 = 0 ;
12570 int res1 = 0 ;
12571 unsigned char val2 ;
12572 int ecode2 = 0 ;
12573 PyObject *swig_obj[2] ;
12574
12575 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
12576 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12577 if (!SWIG_IsOK(res1)) {
12578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12579 }
12580 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12581 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12582 if (!SWIG_IsOK(ecode2)) {
12583 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
12584 }
12585 arg2 = static_cast< byte >(val2);
12586 if (arg1) (arg1)->blue = arg2;
12587
12588 resultobj = SWIG_Py_Void();
12589 return resultobj;
12590 fail:
12591 return NULL;
12592 }
12593
12594
12595 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12596 PyObject *resultobj = 0;
12597 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12598 byte result;
12599 void *argp1 = 0 ;
12600 int res1 = 0 ;
12601 PyObject *swig_obj[1] ;
12602
12603 if (!args) SWIG_fail;
12604 swig_obj[0] = args;
12605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12606 if (!SWIG_IsOK(res1)) {
12607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12608 }
12609 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12610 result = (byte) ((arg1)->blue);
12611 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12612 return resultobj;
12613 fail:
12614 return NULL;
12615 }
12616
12617
12618 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12619 PyObject *obj;
12620 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12621 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
12622 return SWIG_Py_Void();
12623 }
12624
12625 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12626 return SWIG_Python_InitShadowInstance(args);
12627 }
12628
12629 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12630 PyObject *resultobj = 0;
12631 double arg1 = (double) 0.0 ;
12632 double arg2 = (double) 0.0 ;
12633 double arg3 = (double) 0.0 ;
12634 wxImage_HSVValue *result = 0 ;
12635 double val1 ;
12636 int ecode1 = 0 ;
12637 double val2 ;
12638 int ecode2 = 0 ;
12639 double val3 ;
12640 int ecode3 = 0 ;
12641 PyObject * obj0 = 0 ;
12642 PyObject * obj1 = 0 ;
12643 PyObject * obj2 = 0 ;
12644 char * kwnames[] = {
12645 (char *) "h",(char *) "s",(char *) "v", NULL
12646 };
12647
12648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12649 if (obj0) {
12650 ecode1 = SWIG_AsVal_double(obj0, &val1);
12651 if (!SWIG_IsOK(ecode1)) {
12652 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
12653 }
12654 arg1 = static_cast< double >(val1);
12655 }
12656 if (obj1) {
12657 ecode2 = SWIG_AsVal_double(obj1, &val2);
12658 if (!SWIG_IsOK(ecode2)) {
12659 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
12660 }
12661 arg2 = static_cast< double >(val2);
12662 }
12663 if (obj2) {
12664 ecode3 = SWIG_AsVal_double(obj2, &val3);
12665 if (!SWIG_IsOK(ecode3)) {
12666 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
12667 }
12668 arg3 = static_cast< double >(val3);
12669 }
12670 {
12671 PyThreadState* __tstate = wxPyBeginAllowThreads();
12672 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
12673 wxPyEndAllowThreads(__tstate);
12674 if (PyErr_Occurred()) SWIG_fail;
12675 }
12676 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
12677 return resultobj;
12678 fail:
12679 return NULL;
12680 }
12681
12682
12683 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12684 PyObject *resultobj = 0;
12685 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12686 double arg2 ;
12687 void *argp1 = 0 ;
12688 int res1 = 0 ;
12689 double val2 ;
12690 int ecode2 = 0 ;
12691 PyObject *swig_obj[2] ;
12692
12693 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
12694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12695 if (!SWIG_IsOK(res1)) {
12696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12697 }
12698 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12699 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12700 if (!SWIG_IsOK(ecode2)) {
12701 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
12702 }
12703 arg2 = static_cast< double >(val2);
12704 if (arg1) (arg1)->hue = arg2;
12705
12706 resultobj = SWIG_Py_Void();
12707 return resultobj;
12708 fail:
12709 return NULL;
12710 }
12711
12712
12713 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12714 PyObject *resultobj = 0;
12715 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12716 double result;
12717 void *argp1 = 0 ;
12718 int res1 = 0 ;
12719 PyObject *swig_obj[1] ;
12720
12721 if (!args) SWIG_fail;
12722 swig_obj[0] = args;
12723 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12724 if (!SWIG_IsOK(res1)) {
12725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12726 }
12727 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12728 result = (double) ((arg1)->hue);
12729 resultobj = SWIG_From_double(static_cast< double >(result));
12730 return resultobj;
12731 fail:
12732 return NULL;
12733 }
12734
12735
12736 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12737 PyObject *resultobj = 0;
12738 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12739 double arg2 ;
12740 void *argp1 = 0 ;
12741 int res1 = 0 ;
12742 double val2 ;
12743 int ecode2 = 0 ;
12744 PyObject *swig_obj[2] ;
12745
12746 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
12747 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12748 if (!SWIG_IsOK(res1)) {
12749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12750 }
12751 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12752 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12753 if (!SWIG_IsOK(ecode2)) {
12754 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
12755 }
12756 arg2 = static_cast< double >(val2);
12757 if (arg1) (arg1)->saturation = arg2;
12758
12759 resultobj = SWIG_Py_Void();
12760 return resultobj;
12761 fail:
12762 return NULL;
12763 }
12764
12765
12766 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12767 PyObject *resultobj = 0;
12768 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12769 double result;
12770 void *argp1 = 0 ;
12771 int res1 = 0 ;
12772 PyObject *swig_obj[1] ;
12773
12774 if (!args) SWIG_fail;
12775 swig_obj[0] = args;
12776 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12777 if (!SWIG_IsOK(res1)) {
12778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12779 }
12780 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12781 result = (double) ((arg1)->saturation);
12782 resultobj = SWIG_From_double(static_cast< double >(result));
12783 return resultobj;
12784 fail:
12785 return NULL;
12786 }
12787
12788
12789 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12790 PyObject *resultobj = 0;
12791 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12792 double arg2 ;
12793 void *argp1 = 0 ;
12794 int res1 = 0 ;
12795 double val2 ;
12796 int ecode2 = 0 ;
12797 PyObject *swig_obj[2] ;
12798
12799 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
12800 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12801 if (!SWIG_IsOK(res1)) {
12802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12803 }
12804 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12805 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12806 if (!SWIG_IsOK(ecode2)) {
12807 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
12808 }
12809 arg2 = static_cast< double >(val2);
12810 if (arg1) (arg1)->value = arg2;
12811
12812 resultobj = SWIG_Py_Void();
12813 return resultobj;
12814 fail:
12815 return NULL;
12816 }
12817
12818
12819 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12820 PyObject *resultobj = 0;
12821 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12822 double result;
12823 void *argp1 = 0 ;
12824 int res1 = 0 ;
12825 PyObject *swig_obj[1] ;
12826
12827 if (!args) SWIG_fail;
12828 swig_obj[0] = args;
12829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12830 if (!SWIG_IsOK(res1)) {
12831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12832 }
12833 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12834 result = (double) ((arg1)->value);
12835 resultobj = SWIG_From_double(static_cast< double >(result));
12836 return resultobj;
12837 fail:
12838 return NULL;
12839 }
12840
12841
12842 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12843 PyObject *obj;
12844 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12845 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
12846 return SWIG_Py_Void();
12847 }
12848
12849 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12850 return SWIG_Python_InitShadowInstance(args);
12851 }
12852
12853 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12854 PyObject *resultobj = 0;
12855 wxString *arg1 = 0 ;
12856 long arg2 = (long) wxBITMAP_TYPE_ANY ;
12857 int arg3 = (int) -1 ;
12858 wxImage *result = 0 ;
12859 bool temp1 = false ;
12860 long val2 ;
12861 int ecode2 = 0 ;
12862 int val3 ;
12863 int ecode3 = 0 ;
12864 PyObject * obj0 = 0 ;
12865 PyObject * obj1 = 0 ;
12866 PyObject * obj2 = 0 ;
12867 char * kwnames[] = {
12868 (char *) "name",(char *) "type",(char *) "index", NULL
12869 };
12870
12871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12872 {
12873 arg1 = wxString_in_helper(obj0);
12874 if (arg1 == NULL) SWIG_fail;
12875 temp1 = true;
12876 }
12877 if (obj1) {
12878 ecode2 = SWIG_AsVal_long(obj1, &val2);
12879 if (!SWIG_IsOK(ecode2)) {
12880 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
12881 }
12882 arg2 = static_cast< long >(val2);
12883 }
12884 if (obj2) {
12885 ecode3 = SWIG_AsVal_int(obj2, &val3);
12886 if (!SWIG_IsOK(ecode3)) {
12887 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
12888 }
12889 arg3 = static_cast< int >(val3);
12890 }
12891 {
12892 PyThreadState* __tstate = wxPyBeginAllowThreads();
12893 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
12894 wxPyEndAllowThreads(__tstate);
12895 if (PyErr_Occurred()) SWIG_fail;
12896 }
12897 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
12898 {
12899 if (temp1)
12900 delete arg1;
12901 }
12902 return resultobj;
12903 fail:
12904 {
12905 if (temp1)
12906 delete arg1;
12907 }
12908 return NULL;
12909 }
12910
12911
12912 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12913 PyObject *resultobj = 0;
12914 wxImage *arg1 = (wxImage *) 0 ;
12915 void *argp1 = 0 ;
12916 int res1 = 0 ;
12917 PyObject *swig_obj[1] ;
12918
12919 if (!args) SWIG_fail;
12920 swig_obj[0] = args;
12921 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
12922 if (!SWIG_IsOK(res1)) {
12923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
12924 }
12925 arg1 = reinterpret_cast< wxImage * >(argp1);
12926 {
12927 PyThreadState* __tstate = wxPyBeginAllowThreads();
12928 delete arg1;
12929
12930 wxPyEndAllowThreads(__tstate);
12931 if (PyErr_Occurred()) SWIG_fail;
12932 }
12933 resultobj = SWIG_Py_Void();
12934 return resultobj;
12935 fail:
12936 return NULL;
12937 }
12938
12939
12940 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12941 PyObject *resultobj = 0;
12942 wxString *arg1 = 0 ;
12943 wxString *arg2 = 0 ;
12944 int arg3 = (int) -1 ;
12945 wxImage *result = 0 ;
12946 bool temp1 = false ;
12947 bool temp2 = false ;
12948 int val3 ;
12949 int ecode3 = 0 ;
12950 PyObject * obj0 = 0 ;
12951 PyObject * obj1 = 0 ;
12952 PyObject * obj2 = 0 ;
12953 char * kwnames[] = {
12954 (char *) "name",(char *) "mimetype",(char *) "index", NULL
12955 };
12956
12957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12958 {
12959 arg1 = wxString_in_helper(obj0);
12960 if (arg1 == NULL) SWIG_fail;
12961 temp1 = true;
12962 }
12963 {
12964 arg2 = wxString_in_helper(obj1);
12965 if (arg2 == NULL) SWIG_fail;
12966 temp2 = true;
12967 }
12968 if (obj2) {
12969 ecode3 = SWIG_AsVal_int(obj2, &val3);
12970 if (!SWIG_IsOK(ecode3)) {
12971 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
12972 }
12973 arg3 = static_cast< int >(val3);
12974 }
12975 {
12976 PyThreadState* __tstate = wxPyBeginAllowThreads();
12977 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
12978 wxPyEndAllowThreads(__tstate);
12979 if (PyErr_Occurred()) SWIG_fail;
12980 }
12981 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
12982 {
12983 if (temp1)
12984 delete arg1;
12985 }
12986 {
12987 if (temp2)
12988 delete arg2;
12989 }
12990 return resultobj;
12991 fail:
12992 {
12993 if (temp1)
12994 delete arg1;
12995 }
12996 {
12997 if (temp2)
12998 delete arg2;
12999 }
13000 return NULL;
13001 }
13002
13003
13004 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13005 PyObject *resultobj = 0;
13006 wxInputStream *arg1 = 0 ;
13007 long arg2 = (long) wxBITMAP_TYPE_ANY ;
13008 int arg3 = (int) -1 ;
13009 wxImage *result = 0 ;
13010 wxPyInputStream *temp1 ;
13011 bool created1 ;
13012 long val2 ;
13013 int ecode2 = 0 ;
13014 int val3 ;
13015 int ecode3 = 0 ;
13016 PyObject * obj0 = 0 ;
13017 PyObject * obj1 = 0 ;
13018 PyObject * obj2 = 0 ;
13019 char * kwnames[] = {
13020 (char *) "stream",(char *) "type",(char *) "index", NULL
13021 };
13022
13023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13024 {
13025 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13026 arg1 = temp1->m_wxis;
13027 created1 = false;
13028 } else {
13029 PyErr_Clear(); // clear the failure of the wxPyConvert above
13030 arg1 = wxPyCBInputStream_create(obj0, false);
13031 if (arg1 == NULL) {
13032 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13033 SWIG_fail;
13034 }
13035 created1 = true;
13036 }
13037 }
13038 if (obj1) {
13039 ecode2 = SWIG_AsVal_long(obj1, &val2);
13040 if (!SWIG_IsOK(ecode2)) {
13041 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
13042 }
13043 arg2 = static_cast< long >(val2);
13044 }
13045 if (obj2) {
13046 ecode3 = SWIG_AsVal_int(obj2, &val3);
13047 if (!SWIG_IsOK(ecode3)) {
13048 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
13049 }
13050 arg3 = static_cast< int >(val3);
13051 }
13052 {
13053 PyThreadState* __tstate = wxPyBeginAllowThreads();
13054 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
13055 wxPyEndAllowThreads(__tstate);
13056 if (PyErr_Occurred()) SWIG_fail;
13057 }
13058 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13059 {
13060 if (created1) delete arg1;
13061 }
13062 return resultobj;
13063 fail:
13064 {
13065 if (created1) delete arg1;
13066 }
13067 return NULL;
13068 }
13069
13070
13071 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13072 PyObject *resultobj = 0;
13073 wxInputStream *arg1 = 0 ;
13074 wxString *arg2 = 0 ;
13075 int arg3 = (int) -1 ;
13076 wxImage *result = 0 ;
13077 wxPyInputStream *temp1 ;
13078 bool created1 ;
13079 bool temp2 = false ;
13080 int val3 ;
13081 int ecode3 = 0 ;
13082 PyObject * obj0 = 0 ;
13083 PyObject * obj1 = 0 ;
13084 PyObject * obj2 = 0 ;
13085 char * kwnames[] = {
13086 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
13087 };
13088
13089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13090 {
13091 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13092 arg1 = temp1->m_wxis;
13093 created1 = false;
13094 } else {
13095 PyErr_Clear(); // clear the failure of the wxPyConvert above
13096 arg1 = wxPyCBInputStream_create(obj0, false);
13097 if (arg1 == NULL) {
13098 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13099 SWIG_fail;
13100 }
13101 created1 = true;
13102 }
13103 }
13104 {
13105 arg2 = wxString_in_helper(obj1);
13106 if (arg2 == NULL) SWIG_fail;
13107 temp2 = true;
13108 }
13109 if (obj2) {
13110 ecode3 = SWIG_AsVal_int(obj2, &val3);
13111 if (!SWIG_IsOK(ecode3)) {
13112 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
13113 }
13114 arg3 = static_cast< int >(val3);
13115 }
13116 {
13117 PyThreadState* __tstate = wxPyBeginAllowThreads();
13118 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
13119 wxPyEndAllowThreads(__tstate);
13120 if (PyErr_Occurred()) SWIG_fail;
13121 }
13122 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13123 {
13124 if (created1) delete arg1;
13125 }
13126 {
13127 if (temp2)
13128 delete arg2;
13129 }
13130 return resultobj;
13131 fail:
13132 {
13133 if (created1) delete arg1;
13134 }
13135 {
13136 if (temp2)
13137 delete arg2;
13138 }
13139 return NULL;
13140 }
13141
13142
13143 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13144 PyObject *resultobj = 0;
13145 int arg1 = (int) 0 ;
13146 int arg2 = (int) 0 ;
13147 bool arg3 = (bool) true ;
13148 wxImage *result = 0 ;
13149 int val1 ;
13150 int ecode1 = 0 ;
13151 int val2 ;
13152 int ecode2 = 0 ;
13153 bool val3 ;
13154 int ecode3 = 0 ;
13155 PyObject * obj0 = 0 ;
13156 PyObject * obj1 = 0 ;
13157 PyObject * obj2 = 0 ;
13158 char * kwnames[] = {
13159 (char *) "width",(char *) "height",(char *) "clear", NULL
13160 };
13161
13162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13163 if (obj0) {
13164 ecode1 = SWIG_AsVal_int(obj0, &val1);
13165 if (!SWIG_IsOK(ecode1)) {
13166 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
13167 }
13168 arg1 = static_cast< int >(val1);
13169 }
13170 if (obj1) {
13171 ecode2 = SWIG_AsVal_int(obj1, &val2);
13172 if (!SWIG_IsOK(ecode2)) {
13173 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
13174 }
13175 arg2 = static_cast< int >(val2);
13176 }
13177 if (obj2) {
13178 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13179 if (!SWIG_IsOK(ecode3)) {
13180 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
13181 }
13182 arg3 = static_cast< bool >(val3);
13183 }
13184 {
13185 PyThreadState* __tstate = wxPyBeginAllowThreads();
13186 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
13187 wxPyEndAllowThreads(__tstate);
13188 if (PyErr_Occurred()) SWIG_fail;
13189 }
13190 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13191 return resultobj;
13192 fail:
13193 return NULL;
13194 }
13195
13196
13197 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13198 PyObject *resultobj = 0;
13199 wxBitmap *arg1 = 0 ;
13200 wxImage *result = 0 ;
13201 void *argp1 = 0 ;
13202 int res1 = 0 ;
13203 PyObject * obj0 = 0 ;
13204 char * kwnames[] = {
13205 (char *) "bitmap", NULL
13206 };
13207
13208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
13209 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
13210 if (!SWIG_IsOK(res1)) {
13211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13212 }
13213 if (!argp1) {
13214 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13215 }
13216 arg1 = reinterpret_cast< wxBitmap * >(argp1);
13217 {
13218 if (!wxPyCheckForApp()) SWIG_fail;
13219 PyThreadState* __tstate = wxPyBeginAllowThreads();
13220 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
13221 wxPyEndAllowThreads(__tstate);
13222 if (PyErr_Occurred()) SWIG_fail;
13223 }
13224 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13225 return resultobj;
13226 fail:
13227 return NULL;
13228 }
13229
13230
13231 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13232 PyObject *resultobj = 0;
13233 int arg1 ;
13234 int arg2 ;
13235 buffer arg3 ;
13236 int arg4 ;
13237 wxImage *result = 0 ;
13238 int val1 ;
13239 int ecode1 = 0 ;
13240 int val2 ;
13241 int ecode2 = 0 ;
13242 PyObject * obj0 = 0 ;
13243 PyObject * obj1 = 0 ;
13244 PyObject * obj2 = 0 ;
13245 char * kwnames[] = {
13246 (char *) "width",(char *) "height",(char *) "data", NULL
13247 };
13248
13249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13250 ecode1 = SWIG_AsVal_int(obj0, &val1);
13251 if (!SWIG_IsOK(ecode1)) {
13252 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
13253 }
13254 arg1 = static_cast< int >(val1);
13255 ecode2 = SWIG_AsVal_int(obj1, &val2);
13256 if (!SWIG_IsOK(ecode2)) {
13257 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
13258 }
13259 arg2 = static_cast< int >(val2);
13260 {
13261 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
13262 }
13263 {
13264 PyThreadState* __tstate = wxPyBeginAllowThreads();
13265 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
13266 wxPyEndAllowThreads(__tstate);
13267 if (PyErr_Occurred()) SWIG_fail;
13268 }
13269 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13270 return resultobj;
13271 fail:
13272 return NULL;
13273 }
13274
13275
13276 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13277 PyObject *resultobj = 0;
13278 int arg1 ;
13279 int arg2 ;
13280 buffer arg3 ;
13281 int arg4 ;
13282 buffer arg5 ;
13283 int arg6 ;
13284 wxImage *result = 0 ;
13285 int val1 ;
13286 int ecode1 = 0 ;
13287 int val2 ;
13288 int ecode2 = 0 ;
13289 PyObject * obj0 = 0 ;
13290 PyObject * obj1 = 0 ;
13291 PyObject * obj2 = 0 ;
13292 PyObject * obj3 = 0 ;
13293 char * kwnames[] = {
13294 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
13295 };
13296
13297 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13298 ecode1 = SWIG_AsVal_int(obj0, &val1);
13299 if (!SWIG_IsOK(ecode1)) {
13300 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
13301 }
13302 arg1 = static_cast< int >(val1);
13303 ecode2 = SWIG_AsVal_int(obj1, &val2);
13304 if (!SWIG_IsOK(ecode2)) {
13305 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
13306 }
13307 arg2 = static_cast< int >(val2);
13308 {
13309 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
13310 }
13311 {
13312 if (!PyArg_Parse(obj3, "t#", &arg5, &arg6)) SWIG_fail;
13313 }
13314 {
13315 PyThreadState* __tstate = wxPyBeginAllowThreads();
13316 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
13317 wxPyEndAllowThreads(__tstate);
13318 if (PyErr_Occurred()) SWIG_fail;
13319 }
13320 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13321 return resultobj;
13322 fail:
13323 return NULL;
13324 }
13325
13326
13327 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13328 PyObject *resultobj = 0;
13329 wxImage *arg1 = (wxImage *) 0 ;
13330 int arg2 ;
13331 int arg3 ;
13332 bool arg4 = (bool) true ;
13333 void *argp1 = 0 ;
13334 int res1 = 0 ;
13335 int val2 ;
13336 int ecode2 = 0 ;
13337 int val3 ;
13338 int ecode3 = 0 ;
13339 bool val4 ;
13340 int ecode4 = 0 ;
13341 PyObject * obj0 = 0 ;
13342 PyObject * obj1 = 0 ;
13343 PyObject * obj2 = 0 ;
13344 PyObject * obj3 = 0 ;
13345 char * kwnames[] = {
13346 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
13347 };
13348
13349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13350 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13351 if (!SWIG_IsOK(res1)) {
13352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
13353 }
13354 arg1 = reinterpret_cast< wxImage * >(argp1);
13355 ecode2 = SWIG_AsVal_int(obj1, &val2);
13356 if (!SWIG_IsOK(ecode2)) {
13357 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
13358 }
13359 arg2 = static_cast< int >(val2);
13360 ecode3 = SWIG_AsVal_int(obj2, &val3);
13361 if (!SWIG_IsOK(ecode3)) {
13362 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
13363 }
13364 arg3 = static_cast< int >(val3);
13365 if (obj3) {
13366 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13367 if (!SWIG_IsOK(ecode4)) {
13368 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
13369 }
13370 arg4 = static_cast< bool >(val4);
13371 }
13372 {
13373 PyThreadState* __tstate = wxPyBeginAllowThreads();
13374 (arg1)->Create(arg2,arg3,arg4);
13375 wxPyEndAllowThreads(__tstate);
13376 if (PyErr_Occurred()) SWIG_fail;
13377 }
13378 resultobj = SWIG_Py_Void();
13379 return resultobj;
13380 fail:
13381 return NULL;
13382 }
13383
13384
13385 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13386 PyObject *resultobj = 0;
13387 wxImage *arg1 = (wxImage *) 0 ;
13388 void *argp1 = 0 ;
13389 int res1 = 0 ;
13390 PyObject *swig_obj[1] ;
13391
13392 if (!args) SWIG_fail;
13393 swig_obj[0] = args;
13394 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13395 if (!SWIG_IsOK(res1)) {
13396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
13397 }
13398 arg1 = reinterpret_cast< wxImage * >(argp1);
13399 {
13400 PyThreadState* __tstate = wxPyBeginAllowThreads();
13401 (arg1)->Destroy();
13402 wxPyEndAllowThreads(__tstate);
13403 if (PyErr_Occurred()) SWIG_fail;
13404 }
13405 resultobj = SWIG_Py_Void();
13406 return resultobj;
13407 fail:
13408 return NULL;
13409 }
13410
13411
13412 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13413 PyObject *resultobj = 0;
13414 wxImage *arg1 = (wxImage *) 0 ;
13415 int arg2 ;
13416 int arg3 ;
13417 SwigValueWrapper<wxImage > result;
13418 void *argp1 = 0 ;
13419 int res1 = 0 ;
13420 int val2 ;
13421 int ecode2 = 0 ;
13422 int val3 ;
13423 int ecode3 = 0 ;
13424 PyObject * obj0 = 0 ;
13425 PyObject * obj1 = 0 ;
13426 PyObject * obj2 = 0 ;
13427 char * kwnames[] = {
13428 (char *) "self",(char *) "width",(char *) "height", NULL
13429 };
13430
13431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13432 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13433 if (!SWIG_IsOK(res1)) {
13434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
13435 }
13436 arg1 = reinterpret_cast< wxImage * >(argp1);
13437 ecode2 = SWIG_AsVal_int(obj1, &val2);
13438 if (!SWIG_IsOK(ecode2)) {
13439 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
13440 }
13441 arg2 = static_cast< int >(val2);
13442 ecode3 = SWIG_AsVal_int(obj2, &val3);
13443 if (!SWIG_IsOK(ecode3)) {
13444 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
13445 }
13446 arg3 = static_cast< int >(val3);
13447 {
13448 PyThreadState* __tstate = wxPyBeginAllowThreads();
13449 result = (arg1)->Scale(arg2,arg3);
13450 wxPyEndAllowThreads(__tstate);
13451 if (PyErr_Occurred()) SWIG_fail;
13452 }
13453 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13454 return resultobj;
13455 fail:
13456 return NULL;
13457 }
13458
13459
13460 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13461 PyObject *resultobj = 0;
13462 wxImage *arg1 = (wxImage *) 0 ;
13463 int arg2 ;
13464 int arg3 ;
13465 SwigValueWrapper<wxImage > result;
13466 void *argp1 = 0 ;
13467 int res1 = 0 ;
13468 int val2 ;
13469 int ecode2 = 0 ;
13470 int val3 ;
13471 int ecode3 = 0 ;
13472 PyObject * obj0 = 0 ;
13473 PyObject * obj1 = 0 ;
13474 PyObject * obj2 = 0 ;
13475 char * kwnames[] = {
13476 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
13477 };
13478
13479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13480 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13481 if (!SWIG_IsOK(res1)) {
13482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
13483 }
13484 arg1 = reinterpret_cast< wxImage * >(argp1);
13485 ecode2 = SWIG_AsVal_int(obj1, &val2);
13486 if (!SWIG_IsOK(ecode2)) {
13487 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
13488 }
13489 arg2 = static_cast< int >(val2);
13490 ecode3 = SWIG_AsVal_int(obj2, &val3);
13491 if (!SWIG_IsOK(ecode3)) {
13492 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
13493 }
13494 arg3 = static_cast< int >(val3);
13495 {
13496 PyThreadState* __tstate = wxPyBeginAllowThreads();
13497 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
13498 wxPyEndAllowThreads(__tstate);
13499 if (PyErr_Occurred()) SWIG_fail;
13500 }
13501 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13502 return resultobj;
13503 fail:
13504 return NULL;
13505 }
13506
13507
13508 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13509 PyObject *resultobj = 0;
13510 wxImage *arg1 = (wxImage *) 0 ;
13511 int arg2 ;
13512 int arg3 ;
13513 wxImage *result = 0 ;
13514 void *argp1 = 0 ;
13515 int res1 = 0 ;
13516 int val2 ;
13517 int ecode2 = 0 ;
13518 int val3 ;
13519 int ecode3 = 0 ;
13520 PyObject * obj0 = 0 ;
13521 PyObject * obj1 = 0 ;
13522 PyObject * obj2 = 0 ;
13523 char * kwnames[] = {
13524 (char *) "self",(char *) "width",(char *) "height", NULL
13525 };
13526
13527 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13528 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13529 if (!SWIG_IsOK(res1)) {
13530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
13531 }
13532 arg1 = reinterpret_cast< wxImage * >(argp1);
13533 ecode2 = SWIG_AsVal_int(obj1, &val2);
13534 if (!SWIG_IsOK(ecode2)) {
13535 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
13536 }
13537 arg2 = static_cast< int >(val2);
13538 ecode3 = SWIG_AsVal_int(obj2, &val3);
13539 if (!SWIG_IsOK(ecode3)) {
13540 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
13541 }
13542 arg3 = static_cast< int >(val3);
13543 {
13544 PyThreadState* __tstate = wxPyBeginAllowThreads();
13545 {
13546 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
13547 result = (wxImage *) &_result_ref;
13548 }
13549 wxPyEndAllowThreads(__tstate);
13550 if (PyErr_Occurred()) SWIG_fail;
13551 }
13552 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13553 return resultobj;
13554 fail:
13555 return NULL;
13556 }
13557
13558
13559 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13560 PyObject *resultobj = 0;
13561 wxImage *arg1 = (wxImage *) 0 ;
13562 wxSize *arg2 = 0 ;
13563 wxPoint *arg3 = 0 ;
13564 int arg4 = (int) -1 ;
13565 int arg5 = (int) -1 ;
13566 int arg6 = (int) -1 ;
13567 wxImage *result = 0 ;
13568 void *argp1 = 0 ;
13569 int res1 = 0 ;
13570 wxSize temp2 ;
13571 wxPoint temp3 ;
13572 int val4 ;
13573 int ecode4 = 0 ;
13574 int val5 ;
13575 int ecode5 = 0 ;
13576 int val6 ;
13577 int ecode6 = 0 ;
13578 PyObject * obj0 = 0 ;
13579 PyObject * obj1 = 0 ;
13580 PyObject * obj2 = 0 ;
13581 PyObject * obj3 = 0 ;
13582 PyObject * obj4 = 0 ;
13583 PyObject * obj5 = 0 ;
13584 char * kwnames[] = {
13585 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
13586 };
13587
13588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13590 if (!SWIG_IsOK(res1)) {
13591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
13592 }
13593 arg1 = reinterpret_cast< wxImage * >(argp1);
13594 {
13595 arg2 = &temp2;
13596 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
13597 }
13598 {
13599 arg3 = &temp3;
13600 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13601 }
13602 if (obj3) {
13603 ecode4 = SWIG_AsVal_int(obj3, &val4);
13604 if (!SWIG_IsOK(ecode4)) {
13605 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
13606 }
13607 arg4 = static_cast< int >(val4);
13608 }
13609 if (obj4) {
13610 ecode5 = SWIG_AsVal_int(obj4, &val5);
13611 if (!SWIG_IsOK(ecode5)) {
13612 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
13613 }
13614 arg5 = static_cast< int >(val5);
13615 }
13616 if (obj5) {
13617 ecode6 = SWIG_AsVal_int(obj5, &val6);
13618 if (!SWIG_IsOK(ecode6)) {
13619 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
13620 }
13621 arg6 = static_cast< int >(val6);
13622 }
13623 {
13624 PyThreadState* __tstate = wxPyBeginAllowThreads();
13625 {
13626 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
13627 result = (wxImage *) &_result_ref;
13628 }
13629 wxPyEndAllowThreads(__tstate);
13630 if (PyErr_Occurred()) SWIG_fail;
13631 }
13632 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13633 return resultobj;
13634 fail:
13635 return NULL;
13636 }
13637
13638
13639 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13640 PyObject *resultobj = 0;
13641 wxImage *arg1 = (wxImage *) 0 ;
13642 int arg2 ;
13643 int arg3 ;
13644 byte arg4 ;
13645 byte arg5 ;
13646 byte arg6 ;
13647 void *argp1 = 0 ;
13648 int res1 = 0 ;
13649 int val2 ;
13650 int ecode2 = 0 ;
13651 int val3 ;
13652 int ecode3 = 0 ;
13653 unsigned char val4 ;
13654 int ecode4 = 0 ;
13655 unsigned char val5 ;
13656 int ecode5 = 0 ;
13657 unsigned char val6 ;
13658 int ecode6 = 0 ;
13659 PyObject * obj0 = 0 ;
13660 PyObject * obj1 = 0 ;
13661 PyObject * obj2 = 0 ;
13662 PyObject * obj3 = 0 ;
13663 PyObject * obj4 = 0 ;
13664 PyObject * obj5 = 0 ;
13665 char * kwnames[] = {
13666 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
13667 };
13668
13669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13670 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13671 if (!SWIG_IsOK(res1)) {
13672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
13673 }
13674 arg1 = reinterpret_cast< wxImage * >(argp1);
13675 ecode2 = SWIG_AsVal_int(obj1, &val2);
13676 if (!SWIG_IsOK(ecode2)) {
13677 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
13678 }
13679 arg2 = static_cast< int >(val2);
13680 ecode3 = SWIG_AsVal_int(obj2, &val3);
13681 if (!SWIG_IsOK(ecode3)) {
13682 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
13683 }
13684 arg3 = static_cast< int >(val3);
13685 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13686 if (!SWIG_IsOK(ecode4)) {
13687 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
13688 }
13689 arg4 = static_cast< byte >(val4);
13690 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13691 if (!SWIG_IsOK(ecode5)) {
13692 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
13693 }
13694 arg5 = static_cast< byte >(val5);
13695 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
13696 if (!SWIG_IsOK(ecode6)) {
13697 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
13698 }
13699 arg6 = static_cast< byte >(val6);
13700 {
13701 PyThreadState* __tstate = wxPyBeginAllowThreads();
13702 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
13703 wxPyEndAllowThreads(__tstate);
13704 if (PyErr_Occurred()) SWIG_fail;
13705 }
13706 resultobj = SWIG_Py_Void();
13707 return resultobj;
13708 fail:
13709 return NULL;
13710 }
13711
13712
13713 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13714 PyObject *resultobj = 0;
13715 wxImage *arg1 = (wxImage *) 0 ;
13716 wxRect *arg2 = 0 ;
13717 byte arg3 ;
13718 byte arg4 ;
13719 byte arg5 ;
13720 void *argp1 = 0 ;
13721 int res1 = 0 ;
13722 wxRect temp2 ;
13723 unsigned char val3 ;
13724 int ecode3 = 0 ;
13725 unsigned char val4 ;
13726 int ecode4 = 0 ;
13727 unsigned char val5 ;
13728 int ecode5 = 0 ;
13729 PyObject * obj0 = 0 ;
13730 PyObject * obj1 = 0 ;
13731 PyObject * obj2 = 0 ;
13732 PyObject * obj3 = 0 ;
13733 PyObject * obj4 = 0 ;
13734 char * kwnames[] = {
13735 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
13736 };
13737
13738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
13739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13740 if (!SWIG_IsOK(res1)) {
13741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
13742 }
13743 arg1 = reinterpret_cast< wxImage * >(argp1);
13744 {
13745 arg2 = &temp2;
13746 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13747 }
13748 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
13749 if (!SWIG_IsOK(ecode3)) {
13750 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
13751 }
13752 arg3 = static_cast< byte >(val3);
13753 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13754 if (!SWIG_IsOK(ecode4)) {
13755 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
13756 }
13757 arg4 = static_cast< byte >(val4);
13758 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13759 if (!SWIG_IsOK(ecode5)) {
13760 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
13761 }
13762 arg5 = static_cast< byte >(val5);
13763 {
13764 PyThreadState* __tstate = wxPyBeginAllowThreads();
13765 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
13766 wxPyEndAllowThreads(__tstate);
13767 if (PyErr_Occurred()) SWIG_fail;
13768 }
13769 resultobj = SWIG_Py_Void();
13770 return resultobj;
13771 fail:
13772 return NULL;
13773 }
13774
13775
13776 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13777 PyObject *resultobj = 0;
13778 wxImage *arg1 = (wxImage *) 0 ;
13779 int arg2 ;
13780 int arg3 ;
13781 byte result;
13782 void *argp1 = 0 ;
13783 int res1 = 0 ;
13784 int val2 ;
13785 int ecode2 = 0 ;
13786 int val3 ;
13787 int ecode3 = 0 ;
13788 PyObject * obj0 = 0 ;
13789 PyObject * obj1 = 0 ;
13790 PyObject * obj2 = 0 ;
13791 char * kwnames[] = {
13792 (char *) "self",(char *) "x",(char *) "y", NULL
13793 };
13794
13795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13796 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13797 if (!SWIG_IsOK(res1)) {
13798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
13799 }
13800 arg1 = reinterpret_cast< wxImage * >(argp1);
13801 ecode2 = SWIG_AsVal_int(obj1, &val2);
13802 if (!SWIG_IsOK(ecode2)) {
13803 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
13804 }
13805 arg2 = static_cast< int >(val2);
13806 ecode3 = SWIG_AsVal_int(obj2, &val3);
13807 if (!SWIG_IsOK(ecode3)) {
13808 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
13809 }
13810 arg3 = static_cast< int >(val3);
13811 {
13812 PyThreadState* __tstate = wxPyBeginAllowThreads();
13813 result = (byte)(arg1)->GetRed(arg2,arg3);
13814 wxPyEndAllowThreads(__tstate);
13815 if (PyErr_Occurred()) SWIG_fail;
13816 }
13817 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13818 return resultobj;
13819 fail:
13820 return NULL;
13821 }
13822
13823
13824 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13825 PyObject *resultobj = 0;
13826 wxImage *arg1 = (wxImage *) 0 ;
13827 int arg2 ;
13828 int arg3 ;
13829 byte result;
13830 void *argp1 = 0 ;
13831 int res1 = 0 ;
13832 int val2 ;
13833 int ecode2 = 0 ;
13834 int val3 ;
13835 int ecode3 = 0 ;
13836 PyObject * obj0 = 0 ;
13837 PyObject * obj1 = 0 ;
13838 PyObject * obj2 = 0 ;
13839 char * kwnames[] = {
13840 (char *) "self",(char *) "x",(char *) "y", NULL
13841 };
13842
13843 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13844 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13845 if (!SWIG_IsOK(res1)) {
13846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
13847 }
13848 arg1 = reinterpret_cast< wxImage * >(argp1);
13849 ecode2 = SWIG_AsVal_int(obj1, &val2);
13850 if (!SWIG_IsOK(ecode2)) {
13851 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
13852 }
13853 arg2 = static_cast< int >(val2);
13854 ecode3 = SWIG_AsVal_int(obj2, &val3);
13855 if (!SWIG_IsOK(ecode3)) {
13856 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
13857 }
13858 arg3 = static_cast< int >(val3);
13859 {
13860 PyThreadState* __tstate = wxPyBeginAllowThreads();
13861 result = (byte)(arg1)->GetGreen(arg2,arg3);
13862 wxPyEndAllowThreads(__tstate);
13863 if (PyErr_Occurred()) SWIG_fail;
13864 }
13865 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13866 return resultobj;
13867 fail:
13868 return NULL;
13869 }
13870
13871
13872 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13873 PyObject *resultobj = 0;
13874 wxImage *arg1 = (wxImage *) 0 ;
13875 int arg2 ;
13876 int arg3 ;
13877 byte result;
13878 void *argp1 = 0 ;
13879 int res1 = 0 ;
13880 int val2 ;
13881 int ecode2 = 0 ;
13882 int val3 ;
13883 int ecode3 = 0 ;
13884 PyObject * obj0 = 0 ;
13885 PyObject * obj1 = 0 ;
13886 PyObject * obj2 = 0 ;
13887 char * kwnames[] = {
13888 (char *) "self",(char *) "x",(char *) "y", NULL
13889 };
13890
13891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13892 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13893 if (!SWIG_IsOK(res1)) {
13894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
13895 }
13896 arg1 = reinterpret_cast< wxImage * >(argp1);
13897 ecode2 = SWIG_AsVal_int(obj1, &val2);
13898 if (!SWIG_IsOK(ecode2)) {
13899 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
13900 }
13901 arg2 = static_cast< int >(val2);
13902 ecode3 = SWIG_AsVal_int(obj2, &val3);
13903 if (!SWIG_IsOK(ecode3)) {
13904 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
13905 }
13906 arg3 = static_cast< int >(val3);
13907 {
13908 PyThreadState* __tstate = wxPyBeginAllowThreads();
13909 result = (byte)(arg1)->GetBlue(arg2,arg3);
13910 wxPyEndAllowThreads(__tstate);
13911 if (PyErr_Occurred()) SWIG_fail;
13912 }
13913 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13914 return resultobj;
13915 fail:
13916 return NULL;
13917 }
13918
13919
13920 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13921 PyObject *resultobj = 0;
13922 wxImage *arg1 = (wxImage *) 0 ;
13923 int arg2 ;
13924 int arg3 ;
13925 byte arg4 ;
13926 void *argp1 = 0 ;
13927 int res1 = 0 ;
13928 int val2 ;
13929 int ecode2 = 0 ;
13930 int val3 ;
13931 int ecode3 = 0 ;
13932 unsigned char val4 ;
13933 int ecode4 = 0 ;
13934 PyObject * obj0 = 0 ;
13935 PyObject * obj1 = 0 ;
13936 PyObject * obj2 = 0 ;
13937 PyObject * obj3 = 0 ;
13938 char * kwnames[] = {
13939 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
13940 };
13941
13942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13944 if (!SWIG_IsOK(res1)) {
13945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
13946 }
13947 arg1 = reinterpret_cast< wxImage * >(argp1);
13948 ecode2 = SWIG_AsVal_int(obj1, &val2);
13949 if (!SWIG_IsOK(ecode2)) {
13950 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
13951 }
13952 arg2 = static_cast< int >(val2);
13953 ecode3 = SWIG_AsVal_int(obj2, &val3);
13954 if (!SWIG_IsOK(ecode3)) {
13955 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
13956 }
13957 arg3 = static_cast< int >(val3);
13958 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13959 if (!SWIG_IsOK(ecode4)) {
13960 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
13961 }
13962 arg4 = static_cast< byte >(val4);
13963 {
13964 PyThreadState* __tstate = wxPyBeginAllowThreads();
13965 (arg1)->SetAlpha(arg2,arg3,arg4);
13966 wxPyEndAllowThreads(__tstate);
13967 if (PyErr_Occurred()) SWIG_fail;
13968 }
13969 resultobj = SWIG_Py_Void();
13970 return resultobj;
13971 fail:
13972 return NULL;
13973 }
13974
13975
13976 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13977 PyObject *resultobj = 0;
13978 wxImage *arg1 = (wxImage *) 0 ;
13979 int arg2 ;
13980 int arg3 ;
13981 byte result;
13982 void *argp1 = 0 ;
13983 int res1 = 0 ;
13984 int val2 ;
13985 int ecode2 = 0 ;
13986 int val3 ;
13987 int ecode3 = 0 ;
13988 PyObject * obj0 = 0 ;
13989 PyObject * obj1 = 0 ;
13990 PyObject * obj2 = 0 ;
13991 char * kwnames[] = {
13992 (char *) "self",(char *) "x",(char *) "y", NULL
13993 };
13994
13995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13996 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13997 if (!SWIG_IsOK(res1)) {
13998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
13999 }
14000 arg1 = reinterpret_cast< wxImage * >(argp1);
14001 ecode2 = SWIG_AsVal_int(obj1, &val2);
14002 if (!SWIG_IsOK(ecode2)) {
14003 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
14004 }
14005 arg2 = static_cast< int >(val2);
14006 ecode3 = SWIG_AsVal_int(obj2, &val3);
14007 if (!SWIG_IsOK(ecode3)) {
14008 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
14009 }
14010 arg3 = static_cast< int >(val3);
14011 {
14012 PyThreadState* __tstate = wxPyBeginAllowThreads();
14013 result = (byte)(arg1)->GetAlpha(arg2,arg3);
14014 wxPyEndAllowThreads(__tstate);
14015 if (PyErr_Occurred()) SWIG_fail;
14016 }
14017 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14018 return resultobj;
14019 fail:
14020 return NULL;
14021 }
14022
14023
14024 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14025 PyObject *resultobj = 0;
14026 wxImage *arg1 = (wxImage *) 0 ;
14027 bool result;
14028 void *argp1 = 0 ;
14029 int res1 = 0 ;
14030 PyObject *swig_obj[1] ;
14031
14032 if (!args) SWIG_fail;
14033 swig_obj[0] = args;
14034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14035 if (!SWIG_IsOK(res1)) {
14036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14037 }
14038 arg1 = reinterpret_cast< wxImage * >(argp1);
14039 {
14040 PyThreadState* __tstate = wxPyBeginAllowThreads();
14041 result = (bool)(arg1)->HasAlpha();
14042 wxPyEndAllowThreads(__tstate);
14043 if (PyErr_Occurred()) SWIG_fail;
14044 }
14045 {
14046 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14047 }
14048 return resultobj;
14049 fail:
14050 return NULL;
14051 }
14052
14053
14054 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14055 PyObject *resultobj = 0;
14056 wxImage *arg1 = (wxImage *) 0 ;
14057 void *argp1 = 0 ;
14058 int res1 = 0 ;
14059 PyObject *swig_obj[1] ;
14060
14061 if (!args) SWIG_fail;
14062 swig_obj[0] = args;
14063 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14064 if (!SWIG_IsOK(res1)) {
14065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14066 }
14067 arg1 = reinterpret_cast< wxImage * >(argp1);
14068 {
14069 PyThreadState* __tstate = wxPyBeginAllowThreads();
14070 (arg1)->InitAlpha();
14071 wxPyEndAllowThreads(__tstate);
14072 if (PyErr_Occurred()) SWIG_fail;
14073 }
14074 resultobj = SWIG_Py_Void();
14075 return resultobj;
14076 fail:
14077 return NULL;
14078 }
14079
14080
14081 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14082 PyObject *resultobj = 0;
14083 wxImage *arg1 = (wxImage *) 0 ;
14084 int arg2 ;
14085 int arg3 ;
14086 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14087 bool result;
14088 void *argp1 = 0 ;
14089 int res1 = 0 ;
14090 int val2 ;
14091 int ecode2 = 0 ;
14092 int val3 ;
14093 int ecode3 = 0 ;
14094 unsigned char val4 ;
14095 int ecode4 = 0 ;
14096 PyObject * obj0 = 0 ;
14097 PyObject * obj1 = 0 ;
14098 PyObject * obj2 = 0 ;
14099 PyObject * obj3 = 0 ;
14100 char * kwnames[] = {
14101 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
14102 };
14103
14104 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14105 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14106 if (!SWIG_IsOK(res1)) {
14107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
14108 }
14109 arg1 = reinterpret_cast< wxImage * >(argp1);
14110 ecode2 = SWIG_AsVal_int(obj1, &val2);
14111 if (!SWIG_IsOK(ecode2)) {
14112 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
14113 }
14114 arg2 = static_cast< int >(val2);
14115 ecode3 = SWIG_AsVal_int(obj2, &val3);
14116 if (!SWIG_IsOK(ecode3)) {
14117 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
14118 }
14119 arg3 = static_cast< int >(val3);
14120 if (obj3) {
14121 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14122 if (!SWIG_IsOK(ecode4)) {
14123 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
14124 }
14125 arg4 = static_cast< byte >(val4);
14126 }
14127 {
14128 PyThreadState* __tstate = wxPyBeginAllowThreads();
14129 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
14130 wxPyEndAllowThreads(__tstate);
14131 if (PyErr_Occurred()) SWIG_fail;
14132 }
14133 {
14134 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14135 }
14136 return resultobj;
14137 fail:
14138 return NULL;
14139 }
14140
14141
14142 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14143 PyObject *resultobj = 0;
14144 wxImage *arg1 = (wxImage *) 0 ;
14145 byte *arg2 = (byte *) 0 ;
14146 byte *arg3 = (byte *) 0 ;
14147 byte *arg4 = (byte *) 0 ;
14148 byte arg5 = (byte) 0 ;
14149 byte arg6 = (byte) 0 ;
14150 byte arg7 = (byte) 0 ;
14151 bool result;
14152 void *argp1 = 0 ;
14153 int res1 = 0 ;
14154 byte temp2 ;
14155 int res2 = SWIG_TMPOBJ ;
14156 byte temp3 ;
14157 int res3 = SWIG_TMPOBJ ;
14158 byte temp4 ;
14159 int res4 = SWIG_TMPOBJ ;
14160 unsigned char val5 ;
14161 int ecode5 = 0 ;
14162 unsigned char val6 ;
14163 int ecode6 = 0 ;
14164 unsigned char val7 ;
14165 int ecode7 = 0 ;
14166 PyObject * obj0 = 0 ;
14167 PyObject * obj1 = 0 ;
14168 PyObject * obj2 = 0 ;
14169 PyObject * obj3 = 0 ;
14170 char * kwnames[] = {
14171 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14172 };
14173
14174 arg2 = &temp2;
14175 arg3 = &temp3;
14176 arg4 = &temp4;
14177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14178 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14179 if (!SWIG_IsOK(res1)) {
14180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
14181 }
14182 arg1 = reinterpret_cast< wxImage * >(argp1);
14183 if (obj1) {
14184 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14185 if (!SWIG_IsOK(ecode5)) {
14186 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14187 }
14188 arg5 = static_cast< byte >(val5);
14189 }
14190 if (obj2) {
14191 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14192 if (!SWIG_IsOK(ecode6)) {
14193 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14194 }
14195 arg6 = static_cast< byte >(val6);
14196 }
14197 if (obj3) {
14198 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14199 if (!SWIG_IsOK(ecode7)) {
14200 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14201 }
14202 arg7 = static_cast< byte >(val7);
14203 }
14204 {
14205 PyThreadState* __tstate = wxPyBeginAllowThreads();
14206 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14207 wxPyEndAllowThreads(__tstate);
14208 if (PyErr_Occurred()) SWIG_fail;
14209 }
14210 {
14211 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14212 }
14213 if (SWIG_IsTmpObj(res2)) {
14214 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14215 } else {
14216 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14217 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14218 }
14219 if (SWIG_IsTmpObj(res3)) {
14220 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14221 } else {
14222 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14223 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14224 }
14225 if (SWIG_IsTmpObj(res4)) {
14226 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14227 } else {
14228 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14229 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14230 }
14231 return resultobj;
14232 fail:
14233 return NULL;
14234 }
14235
14236
14237 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14238 PyObject *resultobj = 0;
14239 wxImage *arg1 = (wxImage *) 0 ;
14240 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14241 bool result;
14242 void *argp1 = 0 ;
14243 int res1 = 0 ;
14244 unsigned char val2 ;
14245 int ecode2 = 0 ;
14246 PyObject * obj0 = 0 ;
14247 PyObject * obj1 = 0 ;
14248 char * kwnames[] = {
14249 (char *) "self",(char *) "threshold", NULL
14250 };
14251
14252 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
14253 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14254 if (!SWIG_IsOK(res1)) {
14255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
14256 }
14257 arg1 = reinterpret_cast< wxImage * >(argp1);
14258 if (obj1) {
14259 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14260 if (!SWIG_IsOK(ecode2)) {
14261 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
14262 }
14263 arg2 = static_cast< byte >(val2);
14264 }
14265 {
14266 PyThreadState* __tstate = wxPyBeginAllowThreads();
14267 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
14268 wxPyEndAllowThreads(__tstate);
14269 if (PyErr_Occurred()) SWIG_fail;
14270 }
14271 {
14272 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14273 }
14274 return resultobj;
14275 fail:
14276 return NULL;
14277 }
14278
14279
14280 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14281 PyObject *resultobj = 0;
14282 wxImage *arg1 = (wxImage *) 0 ;
14283 byte arg2 ;
14284 byte arg3 ;
14285 byte arg4 ;
14286 bool result;
14287 void *argp1 = 0 ;
14288 int res1 = 0 ;
14289 unsigned char val2 ;
14290 int ecode2 = 0 ;
14291 unsigned char val3 ;
14292 int ecode3 = 0 ;
14293 unsigned char val4 ;
14294 int ecode4 = 0 ;
14295 PyObject * obj0 = 0 ;
14296 PyObject * obj1 = 0 ;
14297 PyObject * obj2 = 0 ;
14298 PyObject * obj3 = 0 ;
14299 char * kwnames[] = {
14300 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
14301 };
14302
14303 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14304 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14305 if (!SWIG_IsOK(res1)) {
14306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14307 }
14308 arg1 = reinterpret_cast< wxImage * >(argp1);
14309 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14310 if (!SWIG_IsOK(ecode2)) {
14311 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
14312 }
14313 arg2 = static_cast< byte >(val2);
14314 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14315 if (!SWIG_IsOK(ecode3)) {
14316 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
14317 }
14318 arg3 = static_cast< byte >(val3);
14319 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14320 if (!SWIG_IsOK(ecode4)) {
14321 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
14322 }
14323 arg4 = static_cast< byte >(val4);
14324 {
14325 PyThreadState* __tstate = wxPyBeginAllowThreads();
14326 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
14327 wxPyEndAllowThreads(__tstate);
14328 if (PyErr_Occurred()) SWIG_fail;
14329 }
14330 {
14331 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14332 }
14333 return resultobj;
14334 fail:
14335 return NULL;
14336 }
14337
14338
14339 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14340 PyObject *resultobj = 0;
14341 wxImage *arg1 = (wxImage *) 0 ;
14342 wxImage *arg2 = 0 ;
14343 byte arg3 ;
14344 byte arg4 ;
14345 byte arg5 ;
14346 bool result;
14347 void *argp1 = 0 ;
14348 int res1 = 0 ;
14349 void *argp2 = 0 ;
14350 int res2 = 0 ;
14351 unsigned char val3 ;
14352 int ecode3 = 0 ;
14353 unsigned char val4 ;
14354 int ecode4 = 0 ;
14355 unsigned char val5 ;
14356 int ecode5 = 0 ;
14357 PyObject * obj0 = 0 ;
14358 PyObject * obj1 = 0 ;
14359 PyObject * obj2 = 0 ;
14360 PyObject * obj3 = 0 ;
14361 PyObject * obj4 = 0 ;
14362 char * kwnames[] = {
14363 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
14364 };
14365
14366 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
14367 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14368 if (!SWIG_IsOK(res1)) {
14369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
14370 }
14371 arg1 = reinterpret_cast< wxImage * >(argp1);
14372 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
14373 if (!SWIG_IsOK(res2)) {
14374 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14375 }
14376 if (!argp2) {
14377 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14378 }
14379 arg2 = reinterpret_cast< wxImage * >(argp2);
14380 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14381 if (!SWIG_IsOK(ecode3)) {
14382 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
14383 }
14384 arg3 = static_cast< byte >(val3);
14385 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14386 if (!SWIG_IsOK(ecode4)) {
14387 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
14388 }
14389 arg4 = static_cast< byte >(val4);
14390 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
14391 if (!SWIG_IsOK(ecode5)) {
14392 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
14393 }
14394 arg5 = static_cast< byte >(val5);
14395 {
14396 PyThreadState* __tstate = wxPyBeginAllowThreads();
14397 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
14398 wxPyEndAllowThreads(__tstate);
14399 if (PyErr_Occurred()) SWIG_fail;
14400 }
14401 {
14402 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14403 }
14404 return resultobj;
14405 fail:
14406 return NULL;
14407 }
14408
14409
14410 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14411 PyObject *resultobj = 0;
14412 wxString *arg1 = 0 ;
14413 bool result;
14414 bool temp1 = false ;
14415 PyObject * obj0 = 0 ;
14416 char * kwnames[] = {
14417 (char *) "filename", NULL
14418 };
14419
14420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
14421 {
14422 arg1 = wxString_in_helper(obj0);
14423 if (arg1 == NULL) SWIG_fail;
14424 temp1 = true;
14425 }
14426 {
14427 PyThreadState* __tstate = wxPyBeginAllowThreads();
14428 result = (bool)wxImage::CanRead((wxString const &)*arg1);
14429 wxPyEndAllowThreads(__tstate);
14430 if (PyErr_Occurred()) SWIG_fail;
14431 }
14432 {
14433 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14434 }
14435 {
14436 if (temp1)
14437 delete arg1;
14438 }
14439 return resultobj;
14440 fail:
14441 {
14442 if (temp1)
14443 delete arg1;
14444 }
14445 return NULL;
14446 }
14447
14448
14449 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14450 PyObject *resultobj = 0;
14451 wxString *arg1 = 0 ;
14452 long arg2 = (long) wxBITMAP_TYPE_ANY ;
14453 int result;
14454 bool temp1 = false ;
14455 long val2 ;
14456 int ecode2 = 0 ;
14457 PyObject * obj0 = 0 ;
14458 PyObject * obj1 = 0 ;
14459 char * kwnames[] = {
14460 (char *) "filename",(char *) "type", NULL
14461 };
14462
14463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
14464 {
14465 arg1 = wxString_in_helper(obj0);
14466 if (arg1 == NULL) SWIG_fail;
14467 temp1 = true;
14468 }
14469 if (obj1) {
14470 ecode2 = SWIG_AsVal_long(obj1, &val2);
14471 if (!SWIG_IsOK(ecode2)) {
14472 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
14473 }
14474 arg2 = static_cast< long >(val2);
14475 }
14476 {
14477 PyThreadState* __tstate = wxPyBeginAllowThreads();
14478 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
14479 wxPyEndAllowThreads(__tstate);
14480 if (PyErr_Occurred()) SWIG_fail;
14481 }
14482 resultobj = SWIG_From_int(static_cast< int >(result));
14483 {
14484 if (temp1)
14485 delete arg1;
14486 }
14487 return resultobj;
14488 fail:
14489 {
14490 if (temp1)
14491 delete arg1;
14492 }
14493 return NULL;
14494 }
14495
14496
14497 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14498 PyObject *resultobj = 0;
14499 wxImage *arg1 = (wxImage *) 0 ;
14500 wxString *arg2 = 0 ;
14501 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14502 int arg4 = (int) -1 ;
14503 bool result;
14504 void *argp1 = 0 ;
14505 int res1 = 0 ;
14506 bool temp2 = false ;
14507 long val3 ;
14508 int ecode3 = 0 ;
14509 int val4 ;
14510 int ecode4 = 0 ;
14511 PyObject * obj0 = 0 ;
14512 PyObject * obj1 = 0 ;
14513 PyObject * obj2 = 0 ;
14514 PyObject * obj3 = 0 ;
14515 char * kwnames[] = {
14516 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
14517 };
14518
14519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14520 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14521 if (!SWIG_IsOK(res1)) {
14522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
14523 }
14524 arg1 = reinterpret_cast< wxImage * >(argp1);
14525 {
14526 arg2 = wxString_in_helper(obj1);
14527 if (arg2 == NULL) SWIG_fail;
14528 temp2 = true;
14529 }
14530 if (obj2) {
14531 ecode3 = SWIG_AsVal_long(obj2, &val3);
14532 if (!SWIG_IsOK(ecode3)) {
14533 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
14534 }
14535 arg3 = static_cast< long >(val3);
14536 }
14537 if (obj3) {
14538 ecode4 = SWIG_AsVal_int(obj3, &val4);
14539 if (!SWIG_IsOK(ecode4)) {
14540 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
14541 }
14542 arg4 = static_cast< int >(val4);
14543 }
14544 {
14545 PyThreadState* __tstate = wxPyBeginAllowThreads();
14546 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
14547 wxPyEndAllowThreads(__tstate);
14548 if (PyErr_Occurred()) SWIG_fail;
14549 }
14550 {
14551 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14552 }
14553 {
14554 if (temp2)
14555 delete arg2;
14556 }
14557 return resultobj;
14558 fail:
14559 {
14560 if (temp2)
14561 delete arg2;
14562 }
14563 return NULL;
14564 }
14565
14566
14567 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14568 PyObject *resultobj = 0;
14569 wxImage *arg1 = (wxImage *) 0 ;
14570 wxString *arg2 = 0 ;
14571 wxString *arg3 = 0 ;
14572 int arg4 = (int) -1 ;
14573 bool result;
14574 void *argp1 = 0 ;
14575 int res1 = 0 ;
14576 bool temp2 = false ;
14577 bool temp3 = false ;
14578 int val4 ;
14579 int ecode4 = 0 ;
14580 PyObject * obj0 = 0 ;
14581 PyObject * obj1 = 0 ;
14582 PyObject * obj2 = 0 ;
14583 PyObject * obj3 = 0 ;
14584 char * kwnames[] = {
14585 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
14586 };
14587
14588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14590 if (!SWIG_IsOK(res1)) {
14591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14592 }
14593 arg1 = reinterpret_cast< wxImage * >(argp1);
14594 {
14595 arg2 = wxString_in_helper(obj1);
14596 if (arg2 == NULL) SWIG_fail;
14597 temp2 = true;
14598 }
14599 {
14600 arg3 = wxString_in_helper(obj2);
14601 if (arg3 == NULL) SWIG_fail;
14602 temp3 = true;
14603 }
14604 if (obj3) {
14605 ecode4 = SWIG_AsVal_int(obj3, &val4);
14606 if (!SWIG_IsOK(ecode4)) {
14607 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
14608 }
14609 arg4 = static_cast< int >(val4);
14610 }
14611 {
14612 PyThreadState* __tstate = wxPyBeginAllowThreads();
14613 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14614 wxPyEndAllowThreads(__tstate);
14615 if (PyErr_Occurred()) SWIG_fail;
14616 }
14617 {
14618 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14619 }
14620 {
14621 if (temp2)
14622 delete arg2;
14623 }
14624 {
14625 if (temp3)
14626 delete arg3;
14627 }
14628 return resultobj;
14629 fail:
14630 {
14631 if (temp2)
14632 delete arg2;
14633 }
14634 {
14635 if (temp3)
14636 delete arg3;
14637 }
14638 return NULL;
14639 }
14640
14641
14642 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14643 PyObject *resultobj = 0;
14644 wxImage *arg1 = (wxImage *) 0 ;
14645 wxString *arg2 = 0 ;
14646 int arg3 ;
14647 bool result;
14648 void *argp1 = 0 ;
14649 int res1 = 0 ;
14650 bool temp2 = false ;
14651 int val3 ;
14652 int ecode3 = 0 ;
14653 PyObject * obj0 = 0 ;
14654 PyObject * obj1 = 0 ;
14655 PyObject * obj2 = 0 ;
14656 char * kwnames[] = {
14657 (char *) "self",(char *) "name",(char *) "type", NULL
14658 };
14659
14660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14662 if (!SWIG_IsOK(res1)) {
14663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
14664 }
14665 arg1 = reinterpret_cast< wxImage * >(argp1);
14666 {
14667 arg2 = wxString_in_helper(obj1);
14668 if (arg2 == NULL) SWIG_fail;
14669 temp2 = true;
14670 }
14671 ecode3 = SWIG_AsVal_int(obj2, &val3);
14672 if (!SWIG_IsOK(ecode3)) {
14673 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
14674 }
14675 arg3 = static_cast< int >(val3);
14676 {
14677 PyThreadState* __tstate = wxPyBeginAllowThreads();
14678 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
14679 wxPyEndAllowThreads(__tstate);
14680 if (PyErr_Occurred()) SWIG_fail;
14681 }
14682 {
14683 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14684 }
14685 {
14686 if (temp2)
14687 delete arg2;
14688 }
14689 return resultobj;
14690 fail:
14691 {
14692 if (temp2)
14693 delete arg2;
14694 }
14695 return NULL;
14696 }
14697
14698
14699 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14700 PyObject *resultobj = 0;
14701 wxImage *arg1 = (wxImage *) 0 ;
14702 wxString *arg2 = 0 ;
14703 wxString *arg3 = 0 ;
14704 bool result;
14705 void *argp1 = 0 ;
14706 int res1 = 0 ;
14707 bool temp2 = false ;
14708 bool temp3 = false ;
14709 PyObject * obj0 = 0 ;
14710 PyObject * obj1 = 0 ;
14711 PyObject * obj2 = 0 ;
14712 char * kwnames[] = {
14713 (char *) "self",(char *) "name",(char *) "mimetype", NULL
14714 };
14715
14716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14717 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14718 if (!SWIG_IsOK(res1)) {
14719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14720 }
14721 arg1 = reinterpret_cast< wxImage * >(argp1);
14722 {
14723 arg2 = wxString_in_helper(obj1);
14724 if (arg2 == NULL) SWIG_fail;
14725 temp2 = true;
14726 }
14727 {
14728 arg3 = wxString_in_helper(obj2);
14729 if (arg3 == NULL) SWIG_fail;
14730 temp3 = true;
14731 }
14732 {
14733 PyThreadState* __tstate = wxPyBeginAllowThreads();
14734 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
14735 wxPyEndAllowThreads(__tstate);
14736 if (PyErr_Occurred()) SWIG_fail;
14737 }
14738 {
14739 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14740 }
14741 {
14742 if (temp2)
14743 delete arg2;
14744 }
14745 {
14746 if (temp3)
14747 delete arg3;
14748 }
14749 return resultobj;
14750 fail:
14751 {
14752 if (temp2)
14753 delete arg2;
14754 }
14755 {
14756 if (temp3)
14757 delete arg3;
14758 }
14759 return NULL;
14760 }
14761
14762
14763 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14764 PyObject *resultobj = 0;
14765 wxInputStream *arg1 = 0 ;
14766 bool result;
14767 wxPyInputStream *temp1 ;
14768 bool created1 ;
14769 PyObject * obj0 = 0 ;
14770 char * kwnames[] = {
14771 (char *) "stream", NULL
14772 };
14773
14774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
14775 {
14776 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
14777 arg1 = temp1->m_wxis;
14778 created1 = false;
14779 } else {
14780 PyErr_Clear(); // clear the failure of the wxPyConvert above
14781 arg1 = wxPyCBInputStream_create(obj0, false);
14782 if (arg1 == NULL) {
14783 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14784 SWIG_fail;
14785 }
14786 created1 = true;
14787 }
14788 }
14789 {
14790 PyThreadState* __tstate = wxPyBeginAllowThreads();
14791 result = (bool)wxImage::CanRead(*arg1);
14792 wxPyEndAllowThreads(__tstate);
14793 if (PyErr_Occurred()) SWIG_fail;
14794 }
14795 {
14796 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14797 }
14798 {
14799 if (created1) delete arg1;
14800 }
14801 return resultobj;
14802 fail:
14803 {
14804 if (created1) delete arg1;
14805 }
14806 return NULL;
14807 }
14808
14809
14810 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14811 PyObject *resultobj = 0;
14812 wxImage *arg1 = (wxImage *) 0 ;
14813 wxInputStream *arg2 = 0 ;
14814 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14815 int arg4 = (int) -1 ;
14816 bool result;
14817 void *argp1 = 0 ;
14818 int res1 = 0 ;
14819 wxPyInputStream *temp2 ;
14820 bool created2 ;
14821 long val3 ;
14822 int ecode3 = 0 ;
14823 int val4 ;
14824 int ecode4 = 0 ;
14825 PyObject * obj0 = 0 ;
14826 PyObject * obj1 = 0 ;
14827 PyObject * obj2 = 0 ;
14828 PyObject * obj3 = 0 ;
14829 char * kwnames[] = {
14830 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
14831 };
14832
14833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14835 if (!SWIG_IsOK(res1)) {
14836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
14837 }
14838 arg1 = reinterpret_cast< wxImage * >(argp1);
14839 {
14840 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14841 arg2 = temp2->m_wxis;
14842 created2 = false;
14843 } else {
14844 PyErr_Clear(); // clear the failure of the wxPyConvert above
14845 arg2 = wxPyCBInputStream_create(obj1, false);
14846 if (arg2 == NULL) {
14847 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14848 SWIG_fail;
14849 }
14850 created2 = true;
14851 }
14852 }
14853 if (obj2) {
14854 ecode3 = SWIG_AsVal_long(obj2, &val3);
14855 if (!SWIG_IsOK(ecode3)) {
14856 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
14857 }
14858 arg3 = static_cast< long >(val3);
14859 }
14860 if (obj3) {
14861 ecode4 = SWIG_AsVal_int(obj3, &val4);
14862 if (!SWIG_IsOK(ecode4)) {
14863 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
14864 }
14865 arg4 = static_cast< int >(val4);
14866 }
14867 {
14868 PyThreadState* __tstate = wxPyBeginAllowThreads();
14869 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
14870 wxPyEndAllowThreads(__tstate);
14871 if (PyErr_Occurred()) SWIG_fail;
14872 }
14873 {
14874 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14875 }
14876 {
14877 if (created2) delete arg2;
14878 }
14879 return resultobj;
14880 fail:
14881 {
14882 if (created2) delete arg2;
14883 }
14884 return NULL;
14885 }
14886
14887
14888 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14889 PyObject *resultobj = 0;
14890 wxImage *arg1 = (wxImage *) 0 ;
14891 wxInputStream *arg2 = 0 ;
14892 wxString *arg3 = 0 ;
14893 int arg4 = (int) -1 ;
14894 bool result;
14895 void *argp1 = 0 ;
14896 int res1 = 0 ;
14897 wxPyInputStream *temp2 ;
14898 bool created2 ;
14899 bool temp3 = false ;
14900 int val4 ;
14901 int ecode4 = 0 ;
14902 PyObject * obj0 = 0 ;
14903 PyObject * obj1 = 0 ;
14904 PyObject * obj2 = 0 ;
14905 PyObject * obj3 = 0 ;
14906 char * kwnames[] = {
14907 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
14908 };
14909
14910 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14911 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14912 if (!SWIG_IsOK(res1)) {
14913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
14914 }
14915 arg1 = reinterpret_cast< wxImage * >(argp1);
14916 {
14917 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14918 arg2 = temp2->m_wxis;
14919 created2 = false;
14920 } else {
14921 PyErr_Clear(); // clear the failure of the wxPyConvert above
14922 arg2 = wxPyCBInputStream_create(obj1, false);
14923 if (arg2 == NULL) {
14924 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14925 SWIG_fail;
14926 }
14927 created2 = true;
14928 }
14929 }
14930 {
14931 arg3 = wxString_in_helper(obj2);
14932 if (arg3 == NULL) SWIG_fail;
14933 temp3 = true;
14934 }
14935 if (obj3) {
14936 ecode4 = SWIG_AsVal_int(obj3, &val4);
14937 if (!SWIG_IsOK(ecode4)) {
14938 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
14939 }
14940 arg4 = static_cast< int >(val4);
14941 }
14942 {
14943 PyThreadState* __tstate = wxPyBeginAllowThreads();
14944 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
14945 wxPyEndAllowThreads(__tstate);
14946 if (PyErr_Occurred()) SWIG_fail;
14947 }
14948 {
14949 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14950 }
14951 {
14952 if (created2) delete arg2;
14953 }
14954 {
14955 if (temp3)
14956 delete arg3;
14957 }
14958 return resultobj;
14959 fail:
14960 {
14961 if (created2) delete arg2;
14962 }
14963 {
14964 if (temp3)
14965 delete arg3;
14966 }
14967 return NULL;
14968 }
14969
14970
14971 SWIGINTERN PyObject *_wrap_Image_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14972 PyObject *resultobj = 0;
14973 wxImage *arg1 = (wxImage *) 0 ;
14974 bool result;
14975 void *argp1 = 0 ;
14976 int res1 = 0 ;
14977 PyObject *swig_obj[1] ;
14978
14979 if (!args) SWIG_fail;
14980 swig_obj[0] = args;
14981 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14982 if (!SWIG_IsOK(res1)) {
14983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Ok" "', expected argument " "1"" of type '" "wxImage *""'");
14984 }
14985 arg1 = reinterpret_cast< wxImage * >(argp1);
14986 {
14987 PyThreadState* __tstate = wxPyBeginAllowThreads();
14988 result = (bool)(arg1)->Ok();
14989 wxPyEndAllowThreads(__tstate);
14990 if (PyErr_Occurred()) SWIG_fail;
14991 }
14992 {
14993 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14994 }
14995 return resultobj;
14996 fail:
14997 return NULL;
14998 }
14999
15000
15001 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15002 PyObject *resultobj = 0;
15003 wxImage *arg1 = (wxImage *) 0 ;
15004 int result;
15005 void *argp1 = 0 ;
15006 int res1 = 0 ;
15007 PyObject *swig_obj[1] ;
15008
15009 if (!args) SWIG_fail;
15010 swig_obj[0] = args;
15011 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15012 if (!SWIG_IsOK(res1)) {
15013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
15014 }
15015 arg1 = reinterpret_cast< wxImage * >(argp1);
15016 {
15017 PyThreadState* __tstate = wxPyBeginAllowThreads();
15018 result = (int)(arg1)->GetWidth();
15019 wxPyEndAllowThreads(__tstate);
15020 if (PyErr_Occurred()) SWIG_fail;
15021 }
15022 resultobj = SWIG_From_int(static_cast< int >(result));
15023 return resultobj;
15024 fail:
15025 return NULL;
15026 }
15027
15028
15029 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15030 PyObject *resultobj = 0;
15031 wxImage *arg1 = (wxImage *) 0 ;
15032 int result;
15033 void *argp1 = 0 ;
15034 int res1 = 0 ;
15035 PyObject *swig_obj[1] ;
15036
15037 if (!args) SWIG_fail;
15038 swig_obj[0] = args;
15039 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15040 if (!SWIG_IsOK(res1)) {
15041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
15042 }
15043 arg1 = reinterpret_cast< wxImage * >(argp1);
15044 {
15045 PyThreadState* __tstate = wxPyBeginAllowThreads();
15046 result = (int)(arg1)->GetHeight();
15047 wxPyEndAllowThreads(__tstate);
15048 if (PyErr_Occurred()) SWIG_fail;
15049 }
15050 resultobj = SWIG_From_int(static_cast< int >(result));
15051 return resultobj;
15052 fail:
15053 return NULL;
15054 }
15055
15056
15057 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15058 PyObject *resultobj = 0;
15059 wxImage *arg1 = (wxImage *) 0 ;
15060 wxSize result;
15061 void *argp1 = 0 ;
15062 int res1 = 0 ;
15063 PyObject *swig_obj[1] ;
15064
15065 if (!args) SWIG_fail;
15066 swig_obj[0] = args;
15067 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15068 if (!SWIG_IsOK(res1)) {
15069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
15070 }
15071 arg1 = reinterpret_cast< wxImage * >(argp1);
15072 {
15073 PyThreadState* __tstate = wxPyBeginAllowThreads();
15074 result = wxImage_GetSize(arg1);
15075 wxPyEndAllowThreads(__tstate);
15076 if (PyErr_Occurred()) SWIG_fail;
15077 }
15078 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
15079 return resultobj;
15080 fail:
15081 return NULL;
15082 }
15083
15084
15085 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15086 PyObject *resultobj = 0;
15087 wxImage *arg1 = (wxImage *) 0 ;
15088 wxRect *arg2 = 0 ;
15089 SwigValueWrapper<wxImage > result;
15090 void *argp1 = 0 ;
15091 int res1 = 0 ;
15092 wxRect temp2 ;
15093 PyObject * obj0 = 0 ;
15094 PyObject * obj1 = 0 ;
15095 char * kwnames[] = {
15096 (char *) "self",(char *) "rect", NULL
15097 };
15098
15099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
15100 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15101 if (!SWIG_IsOK(res1)) {
15102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
15103 }
15104 arg1 = reinterpret_cast< wxImage * >(argp1);
15105 {
15106 arg2 = &temp2;
15107 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
15108 }
15109 {
15110 PyThreadState* __tstate = wxPyBeginAllowThreads();
15111 result = (arg1)->GetSubImage((wxRect const &)*arg2);
15112 wxPyEndAllowThreads(__tstate);
15113 if (PyErr_Occurred()) SWIG_fail;
15114 }
15115 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15116 return resultobj;
15117 fail:
15118 return NULL;
15119 }
15120
15121
15122 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15123 PyObject *resultobj = 0;
15124 wxImage *arg1 = (wxImage *) 0 ;
15125 wxSize *arg2 = 0 ;
15126 wxPoint *arg3 = 0 ;
15127 int arg4 = (int) -1 ;
15128 int arg5 = (int) -1 ;
15129 int arg6 = (int) -1 ;
15130 SwigValueWrapper<wxImage > result;
15131 void *argp1 = 0 ;
15132 int res1 = 0 ;
15133 wxSize temp2 ;
15134 wxPoint temp3 ;
15135 int val4 ;
15136 int ecode4 = 0 ;
15137 int val5 ;
15138 int ecode5 = 0 ;
15139 int val6 ;
15140 int ecode6 = 0 ;
15141 PyObject * obj0 = 0 ;
15142 PyObject * obj1 = 0 ;
15143 PyObject * obj2 = 0 ;
15144 PyObject * obj3 = 0 ;
15145 PyObject * obj4 = 0 ;
15146 PyObject * obj5 = 0 ;
15147 char * kwnames[] = {
15148 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
15149 };
15150
15151 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
15152 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15153 if (!SWIG_IsOK(res1)) {
15154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
15155 }
15156 arg1 = reinterpret_cast< wxImage * >(argp1);
15157 {
15158 arg2 = &temp2;
15159 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
15160 }
15161 {
15162 arg3 = &temp3;
15163 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15164 }
15165 if (obj3) {
15166 ecode4 = SWIG_AsVal_int(obj3, &val4);
15167 if (!SWIG_IsOK(ecode4)) {
15168 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
15169 }
15170 arg4 = static_cast< int >(val4);
15171 }
15172 if (obj4) {
15173 ecode5 = SWIG_AsVal_int(obj4, &val5);
15174 if (!SWIG_IsOK(ecode5)) {
15175 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
15176 }
15177 arg5 = static_cast< int >(val5);
15178 }
15179 if (obj5) {
15180 ecode6 = SWIG_AsVal_int(obj5, &val6);
15181 if (!SWIG_IsOK(ecode6)) {
15182 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
15183 }
15184 arg6 = static_cast< int >(val6);
15185 }
15186 {
15187 PyThreadState* __tstate = wxPyBeginAllowThreads();
15188 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
15189 wxPyEndAllowThreads(__tstate);
15190 if (PyErr_Occurred()) SWIG_fail;
15191 }
15192 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15193 return resultobj;
15194 fail:
15195 return NULL;
15196 }
15197
15198
15199 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15200 PyObject *resultobj = 0;
15201 wxImage *arg1 = (wxImage *) 0 ;
15202 SwigValueWrapper<wxImage > result;
15203 void *argp1 = 0 ;
15204 int res1 = 0 ;
15205 PyObject *swig_obj[1] ;
15206
15207 if (!args) SWIG_fail;
15208 swig_obj[0] = args;
15209 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15210 if (!SWIG_IsOK(res1)) {
15211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
15212 }
15213 arg1 = reinterpret_cast< wxImage * >(argp1);
15214 {
15215 PyThreadState* __tstate = wxPyBeginAllowThreads();
15216 result = (arg1)->Copy();
15217 wxPyEndAllowThreads(__tstate);
15218 if (PyErr_Occurred()) SWIG_fail;
15219 }
15220 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15221 return resultobj;
15222 fail:
15223 return NULL;
15224 }
15225
15226
15227 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15228 PyObject *resultobj = 0;
15229 wxImage *arg1 = (wxImage *) 0 ;
15230 wxImage *arg2 = 0 ;
15231 int arg3 ;
15232 int arg4 ;
15233 void *argp1 = 0 ;
15234 int res1 = 0 ;
15235 void *argp2 = 0 ;
15236 int res2 = 0 ;
15237 int val3 ;
15238 int ecode3 = 0 ;
15239 int val4 ;
15240 int ecode4 = 0 ;
15241 PyObject * obj0 = 0 ;
15242 PyObject * obj1 = 0 ;
15243 PyObject * obj2 = 0 ;
15244 PyObject * obj3 = 0 ;
15245 char * kwnames[] = {
15246 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
15247 };
15248
15249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15250 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15251 if (!SWIG_IsOK(res1)) {
15252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
15253 }
15254 arg1 = reinterpret_cast< wxImage * >(argp1);
15255 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
15256 if (!SWIG_IsOK(res2)) {
15257 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15258 }
15259 if (!argp2) {
15260 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15261 }
15262 arg2 = reinterpret_cast< wxImage * >(argp2);
15263 ecode3 = SWIG_AsVal_int(obj2, &val3);
15264 if (!SWIG_IsOK(ecode3)) {
15265 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
15266 }
15267 arg3 = static_cast< int >(val3);
15268 ecode4 = SWIG_AsVal_int(obj3, &val4);
15269 if (!SWIG_IsOK(ecode4)) {
15270 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
15271 }
15272 arg4 = static_cast< int >(val4);
15273 {
15274 PyThreadState* __tstate = wxPyBeginAllowThreads();
15275 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
15276 wxPyEndAllowThreads(__tstate);
15277 if (PyErr_Occurred()) SWIG_fail;
15278 }
15279 resultobj = SWIG_Py_Void();
15280 return resultobj;
15281 fail:
15282 return NULL;
15283 }
15284
15285
15286 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15287 PyObject *resultobj = 0;
15288 wxImage *arg1 = (wxImage *) 0 ;
15289 PyObject *result = 0 ;
15290 void *argp1 = 0 ;
15291 int res1 = 0 ;
15292 PyObject *swig_obj[1] ;
15293
15294 if (!args) SWIG_fail;
15295 swig_obj[0] = args;
15296 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15297 if (!SWIG_IsOK(res1)) {
15298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
15299 }
15300 arg1 = reinterpret_cast< wxImage * >(argp1);
15301 {
15302 PyThreadState* __tstate = wxPyBeginAllowThreads();
15303 result = (PyObject *)wxImage_GetData(arg1);
15304 wxPyEndAllowThreads(__tstate);
15305 if (PyErr_Occurred()) SWIG_fail;
15306 }
15307 resultobj = result;
15308 return resultobj;
15309 fail:
15310 return NULL;
15311 }
15312
15313
15314 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15315 PyObject *resultobj = 0;
15316 wxImage *arg1 = (wxImage *) 0 ;
15317 buffer arg2 ;
15318 int arg3 ;
15319 void *argp1 = 0 ;
15320 int res1 = 0 ;
15321 PyObject * obj0 = 0 ;
15322 PyObject * obj1 = 0 ;
15323 char * kwnames[] = {
15324 (char *) "self",(char *) "data", NULL
15325 };
15326
15327 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
15328 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15329 if (!SWIG_IsOK(res1)) {
15330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
15331 }
15332 arg1 = reinterpret_cast< wxImage * >(argp1);
15333 {
15334 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15335 }
15336 {
15337 PyThreadState* __tstate = wxPyBeginAllowThreads();
15338 wxImage_SetData(arg1,arg2,arg3);
15339 wxPyEndAllowThreads(__tstate);
15340 if (PyErr_Occurred()) SWIG_fail;
15341 }
15342 resultobj = SWIG_Py_Void();
15343 return resultobj;
15344 fail:
15345 return NULL;
15346 }
15347
15348
15349 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15350 PyObject *resultobj = 0;
15351 wxImage *arg1 = (wxImage *) 0 ;
15352 PyObject *result = 0 ;
15353 void *argp1 = 0 ;
15354 int res1 = 0 ;
15355 PyObject *swig_obj[1] ;
15356
15357 if (!args) SWIG_fail;
15358 swig_obj[0] = args;
15359 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15360 if (!SWIG_IsOK(res1)) {
15361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15362 }
15363 arg1 = reinterpret_cast< wxImage * >(argp1);
15364 {
15365 PyThreadState* __tstate = wxPyBeginAllowThreads();
15366 result = (PyObject *)wxImage_GetDataBuffer(arg1);
15367 wxPyEndAllowThreads(__tstate);
15368 if (PyErr_Occurred()) SWIG_fail;
15369 }
15370 resultobj = result;
15371 return resultobj;
15372 fail:
15373 return NULL;
15374 }
15375
15376
15377 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15378 PyObject *resultobj = 0;
15379 wxImage *arg1 = (wxImage *) 0 ;
15380 buffer arg2 ;
15381 int arg3 ;
15382 void *argp1 = 0 ;
15383 int res1 = 0 ;
15384 PyObject * obj0 = 0 ;
15385 PyObject * obj1 = 0 ;
15386 char * kwnames[] = {
15387 (char *) "self",(char *) "data", NULL
15388 };
15389
15390 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15391 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15392 if (!SWIG_IsOK(res1)) {
15393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15394 }
15395 arg1 = reinterpret_cast< wxImage * >(argp1);
15396 {
15397 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15398 }
15399 {
15400 PyThreadState* __tstate = wxPyBeginAllowThreads();
15401 wxImage_SetDataBuffer(arg1,arg2,arg3);
15402 wxPyEndAllowThreads(__tstate);
15403 if (PyErr_Occurred()) SWIG_fail;
15404 }
15405 resultobj = SWIG_Py_Void();
15406 return resultobj;
15407 fail:
15408 return NULL;
15409 }
15410
15411
15412 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15413 PyObject *resultobj = 0;
15414 wxImage *arg1 = (wxImage *) 0 ;
15415 PyObject *result = 0 ;
15416 void *argp1 = 0 ;
15417 int res1 = 0 ;
15418 PyObject *swig_obj[1] ;
15419
15420 if (!args) SWIG_fail;
15421 swig_obj[0] = args;
15422 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15423 if (!SWIG_IsOK(res1)) {
15424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15425 }
15426 arg1 = reinterpret_cast< wxImage * >(argp1);
15427 {
15428 PyThreadState* __tstate = wxPyBeginAllowThreads();
15429 result = (PyObject *)wxImage_GetAlphaData(arg1);
15430 wxPyEndAllowThreads(__tstate);
15431 if (PyErr_Occurred()) SWIG_fail;
15432 }
15433 resultobj = result;
15434 return resultobj;
15435 fail:
15436 return NULL;
15437 }
15438
15439
15440 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15441 PyObject *resultobj = 0;
15442 wxImage *arg1 = (wxImage *) 0 ;
15443 buffer arg2 ;
15444 int arg3 ;
15445 void *argp1 = 0 ;
15446 int res1 = 0 ;
15447 PyObject * obj0 = 0 ;
15448 PyObject * obj1 = 0 ;
15449 char * kwnames[] = {
15450 (char *) "self",(char *) "alpha", NULL
15451 };
15452
15453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
15454 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15455 if (!SWIG_IsOK(res1)) {
15456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15457 }
15458 arg1 = reinterpret_cast< wxImage * >(argp1);
15459 {
15460 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15461 }
15462 {
15463 PyThreadState* __tstate = wxPyBeginAllowThreads();
15464 wxImage_SetAlphaData(arg1,arg2,arg3);
15465 wxPyEndAllowThreads(__tstate);
15466 if (PyErr_Occurred()) SWIG_fail;
15467 }
15468 resultobj = SWIG_Py_Void();
15469 return resultobj;
15470 fail:
15471 return NULL;
15472 }
15473
15474
15475 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15476 PyObject *resultobj = 0;
15477 wxImage *arg1 = (wxImage *) 0 ;
15478 PyObject *result = 0 ;
15479 void *argp1 = 0 ;
15480 int res1 = 0 ;
15481 PyObject *swig_obj[1] ;
15482
15483 if (!args) SWIG_fail;
15484 swig_obj[0] = args;
15485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15486 if (!SWIG_IsOK(res1)) {
15487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15488 }
15489 arg1 = reinterpret_cast< wxImage * >(argp1);
15490 {
15491 PyThreadState* __tstate = wxPyBeginAllowThreads();
15492 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
15493 wxPyEndAllowThreads(__tstate);
15494 if (PyErr_Occurred()) SWIG_fail;
15495 }
15496 resultobj = result;
15497 return resultobj;
15498 fail:
15499 return NULL;
15500 }
15501
15502
15503 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15504 PyObject *resultobj = 0;
15505 wxImage *arg1 = (wxImage *) 0 ;
15506 buffer arg2 ;
15507 int arg3 ;
15508 void *argp1 = 0 ;
15509 int res1 = 0 ;
15510 PyObject * obj0 = 0 ;
15511 PyObject * obj1 = 0 ;
15512 char * kwnames[] = {
15513 (char *) "self",(char *) "alpha", NULL
15514 };
15515
15516 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) 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_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15520 }
15521 arg1 = reinterpret_cast< wxImage * >(argp1);
15522 {
15523 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15524 }
15525 {
15526 PyThreadState* __tstate = wxPyBeginAllowThreads();
15527 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
15528 wxPyEndAllowThreads(__tstate);
15529 if (PyErr_Occurred()) SWIG_fail;
15530 }
15531 resultobj = SWIG_Py_Void();
15532 return resultobj;
15533 fail:
15534 return NULL;
15535 }
15536
15537
15538 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15539 PyObject *resultobj = 0;
15540 wxImage *arg1 = (wxImage *) 0 ;
15541 byte arg2 ;
15542 byte arg3 ;
15543 byte arg4 ;
15544 void *argp1 = 0 ;
15545 int res1 = 0 ;
15546 unsigned char val2 ;
15547 int ecode2 = 0 ;
15548 unsigned char val3 ;
15549 int ecode3 = 0 ;
15550 unsigned char val4 ;
15551 int ecode4 = 0 ;
15552 PyObject * obj0 = 0 ;
15553 PyObject * obj1 = 0 ;
15554 PyObject * obj2 = 0 ;
15555 PyObject * obj3 = 0 ;
15556 char * kwnames[] = {
15557 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
15558 };
15559
15560 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15561 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15562 if (!SWIG_IsOK(res1)) {
15563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
15564 }
15565 arg1 = reinterpret_cast< wxImage * >(argp1);
15566 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15567 if (!SWIG_IsOK(ecode2)) {
15568 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
15569 }
15570 arg2 = static_cast< byte >(val2);
15571 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15572 if (!SWIG_IsOK(ecode3)) {
15573 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
15574 }
15575 arg3 = static_cast< byte >(val3);
15576 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15577 if (!SWIG_IsOK(ecode4)) {
15578 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
15579 }
15580 arg4 = static_cast< byte >(val4);
15581 {
15582 PyThreadState* __tstate = wxPyBeginAllowThreads();
15583 (arg1)->SetMaskColour(arg2,arg3,arg4);
15584 wxPyEndAllowThreads(__tstate);
15585 if (PyErr_Occurred()) SWIG_fail;
15586 }
15587 resultobj = SWIG_Py_Void();
15588 return resultobj;
15589 fail:
15590 return NULL;
15591 }
15592
15593
15594 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15595 PyObject *resultobj = 0;
15596 wxImage *arg1 = (wxImage *) 0 ;
15597 byte *arg2 = (byte *) 0 ;
15598 byte *arg3 = (byte *) 0 ;
15599 byte *arg4 = (byte *) 0 ;
15600 void *argp1 = 0 ;
15601 int res1 = 0 ;
15602 byte temp2 ;
15603 int res2 = SWIG_TMPOBJ ;
15604 byte temp3 ;
15605 int res3 = SWIG_TMPOBJ ;
15606 byte temp4 ;
15607 int res4 = SWIG_TMPOBJ ;
15608 PyObject *swig_obj[1] ;
15609
15610 arg2 = &temp2;
15611 arg3 = &temp3;
15612 arg4 = &temp4;
15613 if (!args) SWIG_fail;
15614 swig_obj[0] = args;
15615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15616 if (!SWIG_IsOK(res1)) {
15617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
15618 }
15619 arg1 = reinterpret_cast< wxImage * >(argp1);
15620 {
15621 PyThreadState* __tstate = wxPyBeginAllowThreads();
15622 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
15623 wxPyEndAllowThreads(__tstate);
15624 if (PyErr_Occurred()) SWIG_fail;
15625 }
15626 resultobj = SWIG_Py_Void();
15627 if (SWIG_IsTmpObj(res2)) {
15628 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
15629 } else {
15630 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15631 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
15632 }
15633 if (SWIG_IsTmpObj(res3)) {
15634 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
15635 } else {
15636 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15637 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
15638 }
15639 if (SWIG_IsTmpObj(res4)) {
15640 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
15641 } else {
15642 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15643 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
15644 }
15645 return resultobj;
15646 fail:
15647 return NULL;
15648 }
15649
15650
15651 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15652 PyObject *resultobj = 0;
15653 wxImage *arg1 = (wxImage *) 0 ;
15654 byte result;
15655 void *argp1 = 0 ;
15656 int res1 = 0 ;
15657 PyObject *swig_obj[1] ;
15658
15659 if (!args) SWIG_fail;
15660 swig_obj[0] = args;
15661 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15662 if (!SWIG_IsOK(res1)) {
15663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
15664 }
15665 arg1 = reinterpret_cast< wxImage * >(argp1);
15666 {
15667 PyThreadState* __tstate = wxPyBeginAllowThreads();
15668 result = (byte)(arg1)->GetMaskRed();
15669 wxPyEndAllowThreads(__tstate);
15670 if (PyErr_Occurred()) SWIG_fail;
15671 }
15672 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15673 return resultobj;
15674 fail:
15675 return NULL;
15676 }
15677
15678
15679 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15680 PyObject *resultobj = 0;
15681 wxImage *arg1 = (wxImage *) 0 ;
15682 byte result;
15683 void *argp1 = 0 ;
15684 int res1 = 0 ;
15685 PyObject *swig_obj[1] ;
15686
15687 if (!args) SWIG_fail;
15688 swig_obj[0] = args;
15689 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15690 if (!SWIG_IsOK(res1)) {
15691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
15692 }
15693 arg1 = reinterpret_cast< wxImage * >(argp1);
15694 {
15695 PyThreadState* __tstate = wxPyBeginAllowThreads();
15696 result = (byte)(arg1)->GetMaskGreen();
15697 wxPyEndAllowThreads(__tstate);
15698 if (PyErr_Occurred()) SWIG_fail;
15699 }
15700 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15701 return resultobj;
15702 fail:
15703 return NULL;
15704 }
15705
15706
15707 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15708 PyObject *resultobj = 0;
15709 wxImage *arg1 = (wxImage *) 0 ;
15710 byte result;
15711 void *argp1 = 0 ;
15712 int res1 = 0 ;
15713 PyObject *swig_obj[1] ;
15714
15715 if (!args) SWIG_fail;
15716 swig_obj[0] = args;
15717 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15718 if (!SWIG_IsOK(res1)) {
15719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
15720 }
15721 arg1 = reinterpret_cast< wxImage * >(argp1);
15722 {
15723 PyThreadState* __tstate = wxPyBeginAllowThreads();
15724 result = (byte)(arg1)->GetMaskBlue();
15725 wxPyEndAllowThreads(__tstate);
15726 if (PyErr_Occurred()) SWIG_fail;
15727 }
15728 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15729 return resultobj;
15730 fail:
15731 return NULL;
15732 }
15733
15734
15735 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15736 PyObject *resultobj = 0;
15737 wxImage *arg1 = (wxImage *) 0 ;
15738 bool arg2 = (bool) true ;
15739 void *argp1 = 0 ;
15740 int res1 = 0 ;
15741 bool val2 ;
15742 int ecode2 = 0 ;
15743 PyObject * obj0 = 0 ;
15744 PyObject * obj1 = 0 ;
15745 char * kwnames[] = {
15746 (char *) "self",(char *) "mask", NULL
15747 };
15748
15749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
15750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15751 if (!SWIG_IsOK(res1)) {
15752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
15753 }
15754 arg1 = reinterpret_cast< wxImage * >(argp1);
15755 if (obj1) {
15756 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15757 if (!SWIG_IsOK(ecode2)) {
15758 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
15759 }
15760 arg2 = static_cast< bool >(val2);
15761 }
15762 {
15763 PyThreadState* __tstate = wxPyBeginAllowThreads();
15764 (arg1)->SetMask(arg2);
15765 wxPyEndAllowThreads(__tstate);
15766 if (PyErr_Occurred()) SWIG_fail;
15767 }
15768 resultobj = SWIG_Py_Void();
15769 return resultobj;
15770 fail:
15771 return NULL;
15772 }
15773
15774
15775 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15776 PyObject *resultobj = 0;
15777 wxImage *arg1 = (wxImage *) 0 ;
15778 bool result;
15779 void *argp1 = 0 ;
15780 int res1 = 0 ;
15781 PyObject *swig_obj[1] ;
15782
15783 if (!args) SWIG_fail;
15784 swig_obj[0] = args;
15785 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15786 if (!SWIG_IsOK(res1)) {
15787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
15788 }
15789 arg1 = reinterpret_cast< wxImage * >(argp1);
15790 {
15791 PyThreadState* __tstate = wxPyBeginAllowThreads();
15792 result = (bool)(arg1)->HasMask();
15793 wxPyEndAllowThreads(__tstate);
15794 if (PyErr_Occurred()) SWIG_fail;
15795 }
15796 {
15797 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15798 }
15799 return resultobj;
15800 fail:
15801 return NULL;
15802 }
15803
15804
15805 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15806 PyObject *resultobj = 0;
15807 wxImage *arg1 = (wxImage *) 0 ;
15808 double arg2 ;
15809 wxPoint *arg3 = 0 ;
15810 bool arg4 = (bool) true ;
15811 wxPoint *arg5 = (wxPoint *) NULL ;
15812 SwigValueWrapper<wxImage > result;
15813 void *argp1 = 0 ;
15814 int res1 = 0 ;
15815 double val2 ;
15816 int ecode2 = 0 ;
15817 wxPoint temp3 ;
15818 bool val4 ;
15819 int ecode4 = 0 ;
15820 void *argp5 = 0 ;
15821 int res5 = 0 ;
15822 PyObject * obj0 = 0 ;
15823 PyObject * obj1 = 0 ;
15824 PyObject * obj2 = 0 ;
15825 PyObject * obj3 = 0 ;
15826 PyObject * obj4 = 0 ;
15827 char * kwnames[] = {
15828 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
15829 };
15830
15831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
15832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15833 if (!SWIG_IsOK(res1)) {
15834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
15835 }
15836 arg1 = reinterpret_cast< wxImage * >(argp1);
15837 ecode2 = SWIG_AsVal_double(obj1, &val2);
15838 if (!SWIG_IsOK(ecode2)) {
15839 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
15840 }
15841 arg2 = static_cast< double >(val2);
15842 {
15843 arg3 = &temp3;
15844 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15845 }
15846 if (obj3) {
15847 ecode4 = SWIG_AsVal_bool(obj3, &val4);
15848 if (!SWIG_IsOK(ecode4)) {
15849 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
15850 }
15851 arg4 = static_cast< bool >(val4);
15852 }
15853 if (obj4) {
15854 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
15855 if (!SWIG_IsOK(res5)) {
15856 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
15857 }
15858 arg5 = reinterpret_cast< wxPoint * >(argp5);
15859 }
15860 {
15861 PyThreadState* __tstate = wxPyBeginAllowThreads();
15862 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
15863 wxPyEndAllowThreads(__tstate);
15864 if (PyErr_Occurred()) SWIG_fail;
15865 }
15866 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15867 return resultobj;
15868 fail:
15869 return NULL;
15870 }
15871
15872
15873 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15874 PyObject *resultobj = 0;
15875 wxImage *arg1 = (wxImage *) 0 ;
15876 bool arg2 = (bool) true ;
15877 SwigValueWrapper<wxImage > result;
15878 void *argp1 = 0 ;
15879 int res1 = 0 ;
15880 bool val2 ;
15881 int ecode2 = 0 ;
15882 PyObject * obj0 = 0 ;
15883 PyObject * obj1 = 0 ;
15884 char * kwnames[] = {
15885 (char *) "self",(char *) "clockwise", NULL
15886 };
15887
15888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
15889 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15890 if (!SWIG_IsOK(res1)) {
15891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
15892 }
15893 arg1 = reinterpret_cast< wxImage * >(argp1);
15894 if (obj1) {
15895 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15896 if (!SWIG_IsOK(ecode2)) {
15897 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
15898 }
15899 arg2 = static_cast< bool >(val2);
15900 }
15901 {
15902 PyThreadState* __tstate = wxPyBeginAllowThreads();
15903 result = (arg1)->Rotate90(arg2);
15904 wxPyEndAllowThreads(__tstate);
15905 if (PyErr_Occurred()) SWIG_fail;
15906 }
15907 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15908 return resultobj;
15909 fail:
15910 return NULL;
15911 }
15912
15913
15914 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15915 PyObject *resultobj = 0;
15916 wxImage *arg1 = (wxImage *) 0 ;
15917 bool arg2 = (bool) true ;
15918 SwigValueWrapper<wxImage > result;
15919 void *argp1 = 0 ;
15920 int res1 = 0 ;
15921 bool val2 ;
15922 int ecode2 = 0 ;
15923 PyObject * obj0 = 0 ;
15924 PyObject * obj1 = 0 ;
15925 char * kwnames[] = {
15926 (char *) "self",(char *) "horizontally", NULL
15927 };
15928
15929 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
15930 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15931 if (!SWIG_IsOK(res1)) {
15932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
15933 }
15934 arg1 = reinterpret_cast< wxImage * >(argp1);
15935 if (obj1) {
15936 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15937 if (!SWIG_IsOK(ecode2)) {
15938 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
15939 }
15940 arg2 = static_cast< bool >(val2);
15941 }
15942 {
15943 PyThreadState* __tstate = wxPyBeginAllowThreads();
15944 result = (arg1)->Mirror(arg2);
15945 wxPyEndAllowThreads(__tstate);
15946 if (PyErr_Occurred()) SWIG_fail;
15947 }
15948 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15949 return resultobj;
15950 fail:
15951 return NULL;
15952 }
15953
15954
15955 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15956 PyObject *resultobj = 0;
15957 wxImage *arg1 = (wxImage *) 0 ;
15958 byte arg2 ;
15959 byte arg3 ;
15960 byte arg4 ;
15961 byte arg5 ;
15962 byte arg6 ;
15963 byte arg7 ;
15964 void *argp1 = 0 ;
15965 int res1 = 0 ;
15966 unsigned char val2 ;
15967 int ecode2 = 0 ;
15968 unsigned char val3 ;
15969 int ecode3 = 0 ;
15970 unsigned char val4 ;
15971 int ecode4 = 0 ;
15972 unsigned char val5 ;
15973 int ecode5 = 0 ;
15974 unsigned char val6 ;
15975 int ecode6 = 0 ;
15976 unsigned char val7 ;
15977 int ecode7 = 0 ;
15978 PyObject * obj0 = 0 ;
15979 PyObject * obj1 = 0 ;
15980 PyObject * obj2 = 0 ;
15981 PyObject * obj3 = 0 ;
15982 PyObject * obj4 = 0 ;
15983 PyObject * obj5 = 0 ;
15984 PyObject * obj6 = 0 ;
15985 char * kwnames[] = {
15986 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
15987 };
15988
15989 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
15990 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15991 if (!SWIG_IsOK(res1)) {
15992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
15993 }
15994 arg1 = reinterpret_cast< wxImage * >(argp1);
15995 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15996 if (!SWIG_IsOK(ecode2)) {
15997 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
15998 }
15999 arg2 = static_cast< byte >(val2);
16000 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16001 if (!SWIG_IsOK(ecode3)) {
16002 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
16003 }
16004 arg3 = static_cast< byte >(val3);
16005 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16006 if (!SWIG_IsOK(ecode4)) {
16007 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
16008 }
16009 arg4 = static_cast< byte >(val4);
16010 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16011 if (!SWIG_IsOK(ecode5)) {
16012 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
16013 }
16014 arg5 = static_cast< byte >(val5);
16015 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
16016 if (!SWIG_IsOK(ecode6)) {
16017 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
16018 }
16019 arg6 = static_cast< byte >(val6);
16020 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
16021 if (!SWIG_IsOK(ecode7)) {
16022 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
16023 }
16024 arg7 = static_cast< byte >(val7);
16025 {
16026 PyThreadState* __tstate = wxPyBeginAllowThreads();
16027 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
16028 wxPyEndAllowThreads(__tstate);
16029 if (PyErr_Occurred()) SWIG_fail;
16030 }
16031 resultobj = SWIG_Py_Void();
16032 return resultobj;
16033 fail:
16034 return NULL;
16035 }
16036
16037
16038 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16039 PyObject *resultobj = 0;
16040 wxImage *arg1 = (wxImage *) 0 ;
16041 double arg2 = (double) 0.299 ;
16042 double arg3 = (double) 0.587 ;
16043 double arg4 = (double) 0.114 ;
16044 SwigValueWrapper<wxImage > result;
16045 void *argp1 = 0 ;
16046 int res1 = 0 ;
16047 double val2 ;
16048 int ecode2 = 0 ;
16049 double val3 ;
16050 int ecode3 = 0 ;
16051 double val4 ;
16052 int ecode4 = 0 ;
16053 PyObject * obj0 = 0 ;
16054 PyObject * obj1 = 0 ;
16055 PyObject * obj2 = 0 ;
16056 PyObject * obj3 = 0 ;
16057 char * kwnames[] = {
16058 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
16059 };
16060
16061 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16062 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16063 if (!SWIG_IsOK(res1)) {
16064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
16065 }
16066 arg1 = reinterpret_cast< wxImage * >(argp1);
16067 if (obj1) {
16068 ecode2 = SWIG_AsVal_double(obj1, &val2);
16069 if (!SWIG_IsOK(ecode2)) {
16070 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
16071 }
16072 arg2 = static_cast< double >(val2);
16073 }
16074 if (obj2) {
16075 ecode3 = SWIG_AsVal_double(obj2, &val3);
16076 if (!SWIG_IsOK(ecode3)) {
16077 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
16078 }
16079 arg3 = static_cast< double >(val3);
16080 }
16081 if (obj3) {
16082 ecode4 = SWIG_AsVal_double(obj3, &val4);
16083 if (!SWIG_IsOK(ecode4)) {
16084 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
16085 }
16086 arg4 = static_cast< double >(val4);
16087 }
16088 {
16089 PyThreadState* __tstate = wxPyBeginAllowThreads();
16090 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
16091 wxPyEndAllowThreads(__tstate);
16092 if (PyErr_Occurred()) SWIG_fail;
16093 }
16094 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16095 return resultobj;
16096 fail:
16097 return NULL;
16098 }
16099
16100
16101 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16102 PyObject *resultobj = 0;
16103 wxImage *arg1 = (wxImage *) 0 ;
16104 byte arg2 ;
16105 byte arg3 ;
16106 byte arg4 ;
16107 SwigValueWrapper<wxImage > result;
16108 void *argp1 = 0 ;
16109 int res1 = 0 ;
16110 unsigned char val2 ;
16111 int ecode2 = 0 ;
16112 unsigned char val3 ;
16113 int ecode3 = 0 ;
16114 unsigned char val4 ;
16115 int ecode4 = 0 ;
16116 PyObject * obj0 = 0 ;
16117 PyObject * obj1 = 0 ;
16118 PyObject * obj2 = 0 ;
16119 PyObject * obj3 = 0 ;
16120 char * kwnames[] = {
16121 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
16122 };
16123
16124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16125 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16126 if (!SWIG_IsOK(res1)) {
16127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
16128 }
16129 arg1 = reinterpret_cast< wxImage * >(argp1);
16130 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16131 if (!SWIG_IsOK(ecode2)) {
16132 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
16133 }
16134 arg2 = static_cast< byte >(val2);
16135 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16136 if (!SWIG_IsOK(ecode3)) {
16137 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
16138 }
16139 arg3 = static_cast< byte >(val3);
16140 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16141 if (!SWIG_IsOK(ecode4)) {
16142 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
16143 }
16144 arg4 = static_cast< byte >(val4);
16145 {
16146 PyThreadState* __tstate = wxPyBeginAllowThreads();
16147 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
16148 wxPyEndAllowThreads(__tstate);
16149 if (PyErr_Occurred()) SWIG_fail;
16150 }
16151 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16152 return resultobj;
16153 fail:
16154 return NULL;
16155 }
16156
16157
16158 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16159 PyObject *resultobj = 0;
16160 wxImage *arg1 = (wxImage *) 0 ;
16161 wxString *arg2 = 0 ;
16162 wxString *arg3 = 0 ;
16163 void *argp1 = 0 ;
16164 int res1 = 0 ;
16165 bool temp2 = false ;
16166 bool temp3 = false ;
16167 PyObject * obj0 = 0 ;
16168 PyObject * obj1 = 0 ;
16169 PyObject * obj2 = 0 ;
16170 char * kwnames[] = {
16171 (char *) "self",(char *) "name",(char *) "value", NULL
16172 };
16173
16174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16175 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16176 if (!SWIG_IsOK(res1)) {
16177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
16178 }
16179 arg1 = reinterpret_cast< wxImage * >(argp1);
16180 {
16181 arg2 = wxString_in_helper(obj1);
16182 if (arg2 == NULL) SWIG_fail;
16183 temp2 = true;
16184 }
16185 {
16186 arg3 = wxString_in_helper(obj2);
16187 if (arg3 == NULL) SWIG_fail;
16188 temp3 = true;
16189 }
16190 {
16191 PyThreadState* __tstate = wxPyBeginAllowThreads();
16192 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
16193 wxPyEndAllowThreads(__tstate);
16194 if (PyErr_Occurred()) SWIG_fail;
16195 }
16196 resultobj = SWIG_Py_Void();
16197 {
16198 if (temp2)
16199 delete arg2;
16200 }
16201 {
16202 if (temp3)
16203 delete arg3;
16204 }
16205 return resultobj;
16206 fail:
16207 {
16208 if (temp2)
16209 delete arg2;
16210 }
16211 {
16212 if (temp3)
16213 delete arg3;
16214 }
16215 return NULL;
16216 }
16217
16218
16219 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16220 PyObject *resultobj = 0;
16221 wxImage *arg1 = (wxImage *) 0 ;
16222 wxString *arg2 = 0 ;
16223 int arg3 ;
16224 void *argp1 = 0 ;
16225 int res1 = 0 ;
16226 bool temp2 = false ;
16227 int val3 ;
16228 int ecode3 = 0 ;
16229 PyObject * obj0 = 0 ;
16230 PyObject * obj1 = 0 ;
16231 PyObject * obj2 = 0 ;
16232 char * kwnames[] = {
16233 (char *) "self",(char *) "name",(char *) "value", NULL
16234 };
16235
16236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16237 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16238 if (!SWIG_IsOK(res1)) {
16239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
16240 }
16241 arg1 = reinterpret_cast< wxImage * >(argp1);
16242 {
16243 arg2 = wxString_in_helper(obj1);
16244 if (arg2 == NULL) SWIG_fail;
16245 temp2 = true;
16246 }
16247 ecode3 = SWIG_AsVal_int(obj2, &val3);
16248 if (!SWIG_IsOK(ecode3)) {
16249 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
16250 }
16251 arg3 = static_cast< int >(val3);
16252 {
16253 PyThreadState* __tstate = wxPyBeginAllowThreads();
16254 (arg1)->SetOption((wxString const &)*arg2,arg3);
16255 wxPyEndAllowThreads(__tstate);
16256 if (PyErr_Occurred()) SWIG_fail;
16257 }
16258 resultobj = SWIG_Py_Void();
16259 {
16260 if (temp2)
16261 delete arg2;
16262 }
16263 return resultobj;
16264 fail:
16265 {
16266 if (temp2)
16267 delete arg2;
16268 }
16269 return NULL;
16270 }
16271
16272
16273 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16274 PyObject *resultobj = 0;
16275 wxImage *arg1 = (wxImage *) 0 ;
16276 wxString *arg2 = 0 ;
16277 wxString result;
16278 void *argp1 = 0 ;
16279 int res1 = 0 ;
16280 bool temp2 = false ;
16281 PyObject * obj0 = 0 ;
16282 PyObject * obj1 = 0 ;
16283 char * kwnames[] = {
16284 (char *) "self",(char *) "name", NULL
16285 };
16286
16287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
16288 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16289 if (!SWIG_IsOK(res1)) {
16290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16291 }
16292 arg1 = reinterpret_cast< wxImage * >(argp1);
16293 {
16294 arg2 = wxString_in_helper(obj1);
16295 if (arg2 == NULL) SWIG_fail;
16296 temp2 = true;
16297 }
16298 {
16299 PyThreadState* __tstate = wxPyBeginAllowThreads();
16300 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
16301 wxPyEndAllowThreads(__tstate);
16302 if (PyErr_Occurred()) SWIG_fail;
16303 }
16304 {
16305 #if wxUSE_UNICODE
16306 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16307 #else
16308 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16309 #endif
16310 }
16311 {
16312 if (temp2)
16313 delete arg2;
16314 }
16315 return resultobj;
16316 fail:
16317 {
16318 if (temp2)
16319 delete arg2;
16320 }
16321 return NULL;
16322 }
16323
16324
16325 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16326 PyObject *resultobj = 0;
16327 wxImage *arg1 = (wxImage *) 0 ;
16328 wxString *arg2 = 0 ;
16329 int result;
16330 void *argp1 = 0 ;
16331 int res1 = 0 ;
16332 bool temp2 = false ;
16333 PyObject * obj0 = 0 ;
16334 PyObject * obj1 = 0 ;
16335 char * kwnames[] = {
16336 (char *) "self",(char *) "name", NULL
16337 };
16338
16339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
16340 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16341 if (!SWIG_IsOK(res1)) {
16342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
16343 }
16344 arg1 = reinterpret_cast< wxImage * >(argp1);
16345 {
16346 arg2 = wxString_in_helper(obj1);
16347 if (arg2 == NULL) SWIG_fail;
16348 temp2 = true;
16349 }
16350 {
16351 PyThreadState* __tstate = wxPyBeginAllowThreads();
16352 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
16353 wxPyEndAllowThreads(__tstate);
16354 if (PyErr_Occurred()) SWIG_fail;
16355 }
16356 resultobj = SWIG_From_int(static_cast< int >(result));
16357 {
16358 if (temp2)
16359 delete arg2;
16360 }
16361 return resultobj;
16362 fail:
16363 {
16364 if (temp2)
16365 delete arg2;
16366 }
16367 return NULL;
16368 }
16369
16370
16371 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16372 PyObject *resultobj = 0;
16373 wxImage *arg1 = (wxImage *) 0 ;
16374 wxString *arg2 = 0 ;
16375 bool result;
16376 void *argp1 = 0 ;
16377 int res1 = 0 ;
16378 bool temp2 = false ;
16379 PyObject * obj0 = 0 ;
16380 PyObject * obj1 = 0 ;
16381 char * kwnames[] = {
16382 (char *) "self",(char *) "name", NULL
16383 };
16384
16385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
16386 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16387 if (!SWIG_IsOK(res1)) {
16388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16389 }
16390 arg1 = reinterpret_cast< wxImage * >(argp1);
16391 {
16392 arg2 = wxString_in_helper(obj1);
16393 if (arg2 == NULL) SWIG_fail;
16394 temp2 = true;
16395 }
16396 {
16397 PyThreadState* __tstate = wxPyBeginAllowThreads();
16398 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
16399 wxPyEndAllowThreads(__tstate);
16400 if (PyErr_Occurred()) SWIG_fail;
16401 }
16402 {
16403 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16404 }
16405 {
16406 if (temp2)
16407 delete arg2;
16408 }
16409 return resultobj;
16410 fail:
16411 {
16412 if (temp2)
16413 delete arg2;
16414 }
16415 return NULL;
16416 }
16417
16418
16419 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16420 PyObject *resultobj = 0;
16421 wxImage *arg1 = (wxImage *) 0 ;
16422 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
16423 unsigned long result;
16424 void *argp1 = 0 ;
16425 int res1 = 0 ;
16426 unsigned long val2 ;
16427 int ecode2 = 0 ;
16428 PyObject * obj0 = 0 ;
16429 PyObject * obj1 = 0 ;
16430 char * kwnames[] = {
16431 (char *) "self",(char *) "stopafter", NULL
16432 };
16433
16434 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
16435 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16436 if (!SWIG_IsOK(res1)) {
16437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
16438 }
16439 arg1 = reinterpret_cast< wxImage * >(argp1);
16440 if (obj1) {
16441 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
16442 if (!SWIG_IsOK(ecode2)) {
16443 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
16444 }
16445 arg2 = static_cast< unsigned long >(val2);
16446 }
16447 {
16448 PyThreadState* __tstate = wxPyBeginAllowThreads();
16449 result = (unsigned long)(arg1)->CountColours(arg2);
16450 wxPyEndAllowThreads(__tstate);
16451 if (PyErr_Occurred()) SWIG_fail;
16452 }
16453 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16454 return resultobj;
16455 fail:
16456 return NULL;
16457 }
16458
16459
16460 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16461 PyObject *resultobj = 0;
16462 wxImage *arg1 = (wxImage *) 0 ;
16463 wxImageHistogram *arg2 = 0 ;
16464 unsigned long result;
16465 void *argp1 = 0 ;
16466 int res1 = 0 ;
16467 void *argp2 = 0 ;
16468 int res2 = 0 ;
16469 PyObject * obj0 = 0 ;
16470 PyObject * obj1 = 0 ;
16471 char * kwnames[] = {
16472 (char *) "self",(char *) "h", NULL
16473 };
16474
16475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
16476 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16477 if (!SWIG_IsOK(res1)) {
16478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
16479 }
16480 arg1 = reinterpret_cast< wxImage * >(argp1);
16481 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
16482 if (!SWIG_IsOK(res2)) {
16483 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16484 }
16485 if (!argp2) {
16486 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16487 }
16488 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
16489 {
16490 PyThreadState* __tstate = wxPyBeginAllowThreads();
16491 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
16492 wxPyEndAllowThreads(__tstate);
16493 if (PyErr_Occurred()) SWIG_fail;
16494 }
16495 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16496 return resultobj;
16497 fail:
16498 return NULL;
16499 }
16500
16501
16502 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16503 PyObject *resultobj = 0;
16504 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16505 void *argp1 = 0 ;
16506 int res1 = 0 ;
16507 PyObject * obj0 = 0 ;
16508 char * kwnames[] = {
16509 (char *) "handler", NULL
16510 };
16511
16512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
16513 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16514 if (!SWIG_IsOK(res1)) {
16515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16516 }
16517 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16518 {
16519 PyThreadState* __tstate = wxPyBeginAllowThreads();
16520 wxImage::AddHandler(arg1);
16521 wxPyEndAllowThreads(__tstate);
16522 if (PyErr_Occurred()) SWIG_fail;
16523 }
16524 resultobj = SWIG_Py_Void();
16525 return resultobj;
16526 fail:
16527 return NULL;
16528 }
16529
16530
16531 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16532 PyObject *resultobj = 0;
16533 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16534 void *argp1 = 0 ;
16535 int res1 = 0 ;
16536 PyObject * obj0 = 0 ;
16537 char * kwnames[] = {
16538 (char *) "handler", NULL
16539 };
16540
16541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
16542 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16543 if (!SWIG_IsOK(res1)) {
16544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16545 }
16546 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16547 {
16548 PyThreadState* __tstate = wxPyBeginAllowThreads();
16549 wxImage::InsertHandler(arg1);
16550 wxPyEndAllowThreads(__tstate);
16551 if (PyErr_Occurred()) SWIG_fail;
16552 }
16553 resultobj = SWIG_Py_Void();
16554 return resultobj;
16555 fail:
16556 return NULL;
16557 }
16558
16559
16560 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16561 PyObject *resultobj = 0;
16562 wxString *arg1 = 0 ;
16563 bool result;
16564 bool temp1 = false ;
16565 PyObject * obj0 = 0 ;
16566 char * kwnames[] = {
16567 (char *) "name", NULL
16568 };
16569
16570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
16571 {
16572 arg1 = wxString_in_helper(obj0);
16573 if (arg1 == NULL) SWIG_fail;
16574 temp1 = true;
16575 }
16576 {
16577 PyThreadState* __tstate = wxPyBeginAllowThreads();
16578 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
16579 wxPyEndAllowThreads(__tstate);
16580 if (PyErr_Occurred()) SWIG_fail;
16581 }
16582 {
16583 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16584 }
16585 {
16586 if (temp1)
16587 delete arg1;
16588 }
16589 return resultobj;
16590 fail:
16591 {
16592 if (temp1)
16593 delete arg1;
16594 }
16595 return NULL;
16596 }
16597
16598
16599 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16600 PyObject *resultobj = 0;
16601 PyObject *result = 0 ;
16602
16603 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
16604 {
16605 PyThreadState* __tstate = wxPyBeginAllowThreads();
16606 result = (PyObject *)wxImage_GetHandlers();
16607 wxPyEndAllowThreads(__tstate);
16608 if (PyErr_Occurred()) SWIG_fail;
16609 }
16610 resultobj = result;
16611 return resultobj;
16612 fail:
16613 return NULL;
16614 }
16615
16616
16617 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16618 PyObject *resultobj = 0;
16619 wxString result;
16620
16621 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
16622 {
16623 PyThreadState* __tstate = wxPyBeginAllowThreads();
16624 result = wxImage::GetImageExtWildcard();
16625 wxPyEndAllowThreads(__tstate);
16626 if (PyErr_Occurred()) SWIG_fail;
16627 }
16628 {
16629 #if wxUSE_UNICODE
16630 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16631 #else
16632 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16633 #endif
16634 }
16635 return resultobj;
16636 fail:
16637 return NULL;
16638 }
16639
16640
16641 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16642 PyObject *resultobj = 0;
16643 wxImage *arg1 = (wxImage *) 0 ;
16644 int arg2 = (int) -1 ;
16645 wxBitmap result;
16646 void *argp1 = 0 ;
16647 int res1 = 0 ;
16648 int val2 ;
16649 int ecode2 = 0 ;
16650 PyObject * obj0 = 0 ;
16651 PyObject * obj1 = 0 ;
16652 char * kwnames[] = {
16653 (char *) "self",(char *) "depth", NULL
16654 };
16655
16656 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
16657 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16658 if (!SWIG_IsOK(res1)) {
16659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16660 }
16661 arg1 = reinterpret_cast< wxImage * >(argp1);
16662 if (obj1) {
16663 ecode2 = SWIG_AsVal_int(obj1, &val2);
16664 if (!SWIG_IsOK(ecode2)) {
16665 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
16666 }
16667 arg2 = static_cast< int >(val2);
16668 }
16669 {
16670 if (!wxPyCheckForApp()) SWIG_fail;
16671 PyThreadState* __tstate = wxPyBeginAllowThreads();
16672 result = wxImage_ConvertToBitmap(arg1,arg2);
16673 wxPyEndAllowThreads(__tstate);
16674 if (PyErr_Occurred()) SWIG_fail;
16675 }
16676 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16677 return resultobj;
16678 fail:
16679 return NULL;
16680 }
16681
16682
16683 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16684 PyObject *resultobj = 0;
16685 wxImage *arg1 = (wxImage *) 0 ;
16686 byte arg2 ;
16687 byte arg3 ;
16688 byte arg4 ;
16689 wxBitmap result;
16690 void *argp1 = 0 ;
16691 int res1 = 0 ;
16692 unsigned char val2 ;
16693 int ecode2 = 0 ;
16694 unsigned char val3 ;
16695 int ecode3 = 0 ;
16696 unsigned char val4 ;
16697 int ecode4 = 0 ;
16698 PyObject * obj0 = 0 ;
16699 PyObject * obj1 = 0 ;
16700 PyObject * obj2 = 0 ;
16701 PyObject * obj3 = 0 ;
16702 char * kwnames[] = {
16703 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
16704 };
16705
16706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16707 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16708 if (!SWIG_IsOK(res1)) {
16709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16710 }
16711 arg1 = reinterpret_cast< wxImage * >(argp1);
16712 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16713 if (!SWIG_IsOK(ecode2)) {
16714 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
16715 }
16716 arg2 = static_cast< byte >(val2);
16717 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16718 if (!SWIG_IsOK(ecode3)) {
16719 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
16720 }
16721 arg3 = static_cast< byte >(val3);
16722 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16723 if (!SWIG_IsOK(ecode4)) {
16724 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
16725 }
16726 arg4 = static_cast< byte >(val4);
16727 {
16728 if (!wxPyCheckForApp()) SWIG_fail;
16729 PyThreadState* __tstate = wxPyBeginAllowThreads();
16730 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
16731 wxPyEndAllowThreads(__tstate);
16732 if (PyErr_Occurred()) SWIG_fail;
16733 }
16734 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16735 return resultobj;
16736 fail:
16737 return NULL;
16738 }
16739
16740
16741 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16742 PyObject *resultobj = 0;
16743 wxImage *arg1 = (wxImage *) 0 ;
16744 double arg2 ;
16745 void *argp1 = 0 ;
16746 int res1 = 0 ;
16747 double val2 ;
16748 int ecode2 = 0 ;
16749 PyObject * obj0 = 0 ;
16750 PyObject * obj1 = 0 ;
16751 char * kwnames[] = {
16752 (char *) "self",(char *) "angle", NULL
16753 };
16754
16755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
16756 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16757 if (!SWIG_IsOK(res1)) {
16758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
16759 }
16760 arg1 = reinterpret_cast< wxImage * >(argp1);
16761 ecode2 = SWIG_AsVal_double(obj1, &val2);
16762 if (!SWIG_IsOK(ecode2)) {
16763 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
16764 }
16765 arg2 = static_cast< double >(val2);
16766 {
16767 PyThreadState* __tstate = wxPyBeginAllowThreads();
16768 (arg1)->RotateHue(arg2);
16769 wxPyEndAllowThreads(__tstate);
16770 if (PyErr_Occurred()) SWIG_fail;
16771 }
16772 resultobj = SWIG_Py_Void();
16773 return resultobj;
16774 fail:
16775 return NULL;
16776 }
16777
16778
16779 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16780 PyObject *resultobj = 0;
16781 wxImage_RGBValue arg1 ;
16782 wxImage_HSVValue result;
16783 void *argp1 ;
16784 int res1 = 0 ;
16785 PyObject * obj0 = 0 ;
16786 char * kwnames[] = {
16787 (char *) "rgb", NULL
16788 };
16789
16790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
16791 {
16792 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
16793 if (!SWIG_IsOK(res1)) {
16794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16795 }
16796 if (!argp1) {
16797 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16798 } else {
16799 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
16800 arg1 = *temp;
16801 if (SWIG_IsNewObj(res1)) delete temp;
16802 }
16803 }
16804 {
16805 PyThreadState* __tstate = wxPyBeginAllowThreads();
16806 result = wxImage::RGBtoHSV(arg1);
16807 wxPyEndAllowThreads(__tstate);
16808 if (PyErr_Occurred()) SWIG_fail;
16809 }
16810 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
16811 return resultobj;
16812 fail:
16813 return NULL;
16814 }
16815
16816
16817 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16818 PyObject *resultobj = 0;
16819 wxImage_HSVValue arg1 ;
16820 wxImage_RGBValue result;
16821 void *argp1 ;
16822 int res1 = 0 ;
16823 PyObject * obj0 = 0 ;
16824 char * kwnames[] = {
16825 (char *) "hsv", NULL
16826 };
16827
16828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
16829 {
16830 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
16831 if (!SWIG_IsOK(res1)) {
16832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
16833 }
16834 if (!argp1) {
16835 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
16836 } else {
16837 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
16838 arg1 = *temp;
16839 if (SWIG_IsNewObj(res1)) delete temp;
16840 }
16841 }
16842 {
16843 PyThreadState* __tstate = wxPyBeginAllowThreads();
16844 result = wxImage::HSVtoRGB(arg1);
16845 wxPyEndAllowThreads(__tstate);
16846 if (PyErr_Occurred()) SWIG_fail;
16847 }
16848 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
16849 return resultobj;
16850 fail:
16851 return NULL;
16852 }
16853
16854
16855 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16856 PyObject *obj;
16857 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16858 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
16859 return SWIG_Py_Void();
16860 }
16861
16862 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16863 return SWIG_Python_InitShadowInstance(args);
16864 }
16865
16866 SWIGINTERN int NullImage_set(PyObject *) {
16867 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
16868 return 1;
16869 }
16870
16871
16872 SWIGINTERN PyObject *NullImage_get(void) {
16873 PyObject *pyobj = 0;
16874
16875 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
16876 return pyobj;
16877 }
16878
16879
16880 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
16881 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
16882 return 1;
16883 }
16884
16885
16886 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
16887 PyObject *pyobj = 0;
16888
16889 {
16890 #if wxUSE_UNICODE
16891 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
16892 #else
16893 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
16894 #endif
16895 }
16896 return pyobj;
16897 }
16898
16899
16900 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
16901 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
16902 return 1;
16903 }
16904
16905
16906 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
16907 PyObject *pyobj = 0;
16908
16909 {
16910 #if wxUSE_UNICODE
16911 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
16912 #else
16913 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
16914 #endif
16915 }
16916 return pyobj;
16917 }
16918
16919
16920 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
16921 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
16922 return 1;
16923 }
16924
16925
16926 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
16927 PyObject *pyobj = 0;
16928
16929 {
16930 #if wxUSE_UNICODE
16931 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
16932 #else
16933 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
16934 #endif
16935 }
16936 return pyobj;
16937 }
16938
16939
16940 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
16941 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
16942 return 1;
16943 }
16944
16945
16946 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
16947 PyObject *pyobj = 0;
16948
16949 {
16950 #if wxUSE_UNICODE
16951 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
16952 #else
16953 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
16954 #endif
16955 }
16956 return pyobj;
16957 }
16958
16959
16960 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
16961 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
16962 return 1;
16963 }
16964
16965
16966 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
16967 PyObject *pyobj = 0;
16968
16969 {
16970 #if wxUSE_UNICODE
16971 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
16972 #else
16973 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
16974 #endif
16975 }
16976 return pyobj;
16977 }
16978
16979
16980 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
16981 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
16982 return 1;
16983 }
16984
16985
16986 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
16987 PyObject *pyobj = 0;
16988
16989 {
16990 #if wxUSE_UNICODE
16991 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
16992 #else
16993 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
16994 #endif
16995 }
16996 return pyobj;
16997 }
16998
16999
17000 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
17001 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
17002 return 1;
17003 }
17004
17005
17006 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
17007 PyObject *pyobj = 0;
17008
17009 {
17010 #if wxUSE_UNICODE
17011 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17012 #else
17013 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17014 #endif
17015 }
17016 return pyobj;
17017 }
17018
17019
17020 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
17021 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
17022 return 1;
17023 }
17024
17025
17026 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
17027 PyObject *pyobj = 0;
17028
17029 {
17030 #if wxUSE_UNICODE
17031 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17032 #else
17033 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17034 #endif
17035 }
17036 return pyobj;
17037 }
17038
17039
17040 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
17041 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
17042 return 1;
17043 }
17044
17045
17046 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
17047 PyObject *pyobj = 0;
17048
17049 {
17050 #if wxUSE_UNICODE
17051 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17052 #else
17053 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17054 #endif
17055 }
17056 return pyobj;
17057 }
17058
17059
17060 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
17061 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
17062 return 1;
17063 }
17064
17065
17066 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
17067 PyObject *pyobj = 0;
17068
17069 {
17070 #if wxUSE_UNICODE
17071 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17072 #else
17073 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17074 #endif
17075 }
17076 return pyobj;
17077 }
17078
17079
17080 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
17081 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
17082 return 1;
17083 }
17084
17085
17086 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
17087 PyObject *pyobj = 0;
17088
17089 {
17090 #if wxUSE_UNICODE
17091 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17092 #else
17093 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17094 #endif
17095 }
17096 return pyobj;
17097 }
17098
17099
17100 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
17101 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
17102 return 1;
17103 }
17104
17105
17106 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
17107 PyObject *pyobj = 0;
17108
17109 {
17110 #if wxUSE_UNICODE
17111 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17112 #else
17113 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17114 #endif
17115 }
17116 return pyobj;
17117 }
17118
17119
17120 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
17121 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
17122 return 1;
17123 }
17124
17125
17126 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
17127 PyObject *pyobj = 0;
17128
17129 {
17130 #if wxUSE_UNICODE
17131 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17132 #else
17133 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17134 #endif
17135 }
17136 return pyobj;
17137 }
17138
17139
17140 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
17141 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
17142 return 1;
17143 }
17144
17145
17146 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
17147 PyObject *pyobj = 0;
17148
17149 {
17150 #if wxUSE_UNICODE
17151 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17152 #else
17153 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17154 #endif
17155 }
17156 return pyobj;
17157 }
17158
17159
17160 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
17161 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
17162 return 1;
17163 }
17164
17165
17166 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
17167 PyObject *pyobj = 0;
17168
17169 {
17170 #if wxUSE_UNICODE
17171 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17172 #else
17173 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17174 #endif
17175 }
17176 return pyobj;
17177 }
17178
17179
17180 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17181 PyObject *resultobj = 0;
17182 wxBMPHandler *result = 0 ;
17183
17184 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
17185 {
17186 PyThreadState* __tstate = wxPyBeginAllowThreads();
17187 result = (wxBMPHandler *)new wxBMPHandler();
17188 wxPyEndAllowThreads(__tstate);
17189 if (PyErr_Occurred()) SWIG_fail;
17190 }
17191 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
17192 return resultobj;
17193 fail:
17194 return NULL;
17195 }
17196
17197
17198 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17199 PyObject *obj;
17200 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17201 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
17202 return SWIG_Py_Void();
17203 }
17204
17205 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17206 return SWIG_Python_InitShadowInstance(args);
17207 }
17208
17209 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17210 PyObject *resultobj = 0;
17211 wxICOHandler *result = 0 ;
17212
17213 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
17214 {
17215 PyThreadState* __tstate = wxPyBeginAllowThreads();
17216 result = (wxICOHandler *)new wxICOHandler();
17217 wxPyEndAllowThreads(__tstate);
17218 if (PyErr_Occurred()) SWIG_fail;
17219 }
17220 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
17221 return resultobj;
17222 fail:
17223 return NULL;
17224 }
17225
17226
17227 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17228 PyObject *obj;
17229 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17230 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
17231 return SWIG_Py_Void();
17232 }
17233
17234 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17235 return SWIG_Python_InitShadowInstance(args);
17236 }
17237
17238 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17239 PyObject *resultobj = 0;
17240 wxCURHandler *result = 0 ;
17241
17242 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
17243 {
17244 PyThreadState* __tstate = wxPyBeginAllowThreads();
17245 result = (wxCURHandler *)new wxCURHandler();
17246 wxPyEndAllowThreads(__tstate);
17247 if (PyErr_Occurred()) SWIG_fail;
17248 }
17249 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
17250 return resultobj;
17251 fail:
17252 return NULL;
17253 }
17254
17255
17256 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17257 PyObject *obj;
17258 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17259 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
17260 return SWIG_Py_Void();
17261 }
17262
17263 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17264 return SWIG_Python_InitShadowInstance(args);
17265 }
17266
17267 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17268 PyObject *resultobj = 0;
17269 wxANIHandler *result = 0 ;
17270
17271 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
17272 {
17273 PyThreadState* __tstate = wxPyBeginAllowThreads();
17274 result = (wxANIHandler *)new wxANIHandler();
17275 wxPyEndAllowThreads(__tstate);
17276 if (PyErr_Occurred()) SWIG_fail;
17277 }
17278 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
17279 return resultobj;
17280 fail:
17281 return NULL;
17282 }
17283
17284
17285 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17286 PyObject *obj;
17287 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17288 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
17289 return SWIG_Py_Void();
17290 }
17291
17292 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17293 return SWIG_Python_InitShadowInstance(args);
17294 }
17295
17296 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17297 PyObject *resultobj = 0;
17298 wxPNGHandler *result = 0 ;
17299
17300 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
17301 {
17302 PyThreadState* __tstate = wxPyBeginAllowThreads();
17303 result = (wxPNGHandler *)new wxPNGHandler();
17304 wxPyEndAllowThreads(__tstate);
17305 if (PyErr_Occurred()) SWIG_fail;
17306 }
17307 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
17308 return resultobj;
17309 fail:
17310 return NULL;
17311 }
17312
17313
17314 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17315 PyObject *obj;
17316 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17317 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
17318 return SWIG_Py_Void();
17319 }
17320
17321 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17322 return SWIG_Python_InitShadowInstance(args);
17323 }
17324
17325 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17326 PyObject *resultobj = 0;
17327 wxGIFHandler *result = 0 ;
17328
17329 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
17330 {
17331 PyThreadState* __tstate = wxPyBeginAllowThreads();
17332 result = (wxGIFHandler *)new wxGIFHandler();
17333 wxPyEndAllowThreads(__tstate);
17334 if (PyErr_Occurred()) SWIG_fail;
17335 }
17336 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
17337 return resultobj;
17338 fail:
17339 return NULL;
17340 }
17341
17342
17343 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17344 PyObject *obj;
17345 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17346 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
17347 return SWIG_Py_Void();
17348 }
17349
17350 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17351 return SWIG_Python_InitShadowInstance(args);
17352 }
17353
17354 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17355 PyObject *resultobj = 0;
17356 wxPCXHandler *result = 0 ;
17357
17358 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
17359 {
17360 PyThreadState* __tstate = wxPyBeginAllowThreads();
17361 result = (wxPCXHandler *)new wxPCXHandler();
17362 wxPyEndAllowThreads(__tstate);
17363 if (PyErr_Occurred()) SWIG_fail;
17364 }
17365 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
17366 return resultobj;
17367 fail:
17368 return NULL;
17369 }
17370
17371
17372 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17373 PyObject *obj;
17374 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17375 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
17376 return SWIG_Py_Void();
17377 }
17378
17379 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17380 return SWIG_Python_InitShadowInstance(args);
17381 }
17382
17383 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17384 PyObject *resultobj = 0;
17385 wxJPEGHandler *result = 0 ;
17386
17387 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
17388 {
17389 PyThreadState* __tstate = wxPyBeginAllowThreads();
17390 result = (wxJPEGHandler *)new wxJPEGHandler();
17391 wxPyEndAllowThreads(__tstate);
17392 if (PyErr_Occurred()) SWIG_fail;
17393 }
17394 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
17395 return resultobj;
17396 fail:
17397 return NULL;
17398 }
17399
17400
17401 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17402 PyObject *obj;
17403 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17404 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
17405 return SWIG_Py_Void();
17406 }
17407
17408 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17409 return SWIG_Python_InitShadowInstance(args);
17410 }
17411
17412 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17413 PyObject *resultobj = 0;
17414 wxPNMHandler *result = 0 ;
17415
17416 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
17417 {
17418 PyThreadState* __tstate = wxPyBeginAllowThreads();
17419 result = (wxPNMHandler *)new wxPNMHandler();
17420 wxPyEndAllowThreads(__tstate);
17421 if (PyErr_Occurred()) SWIG_fail;
17422 }
17423 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
17424 return resultobj;
17425 fail:
17426 return NULL;
17427 }
17428
17429
17430 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17431 PyObject *obj;
17432 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17433 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
17434 return SWIG_Py_Void();
17435 }
17436
17437 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17438 return SWIG_Python_InitShadowInstance(args);
17439 }
17440
17441 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17442 PyObject *resultobj = 0;
17443 wxXPMHandler *result = 0 ;
17444
17445 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
17446 {
17447 PyThreadState* __tstate = wxPyBeginAllowThreads();
17448 result = (wxXPMHandler *)new wxXPMHandler();
17449 wxPyEndAllowThreads(__tstate);
17450 if (PyErr_Occurred()) SWIG_fail;
17451 }
17452 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
17453 return resultobj;
17454 fail:
17455 return NULL;
17456 }
17457
17458
17459 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17460 PyObject *obj;
17461 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17462 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
17463 return SWIG_Py_Void();
17464 }
17465
17466 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17467 return SWIG_Python_InitShadowInstance(args);
17468 }
17469
17470 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17471 PyObject *resultobj = 0;
17472 wxTIFFHandler *result = 0 ;
17473
17474 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
17475 {
17476 PyThreadState* __tstate = wxPyBeginAllowThreads();
17477 result = (wxTIFFHandler *)new wxTIFFHandler();
17478 wxPyEndAllowThreads(__tstate);
17479 if (PyErr_Occurred()) SWIG_fail;
17480 }
17481 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
17482 return resultobj;
17483 fail:
17484 return NULL;
17485 }
17486
17487
17488 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17489 PyObject *obj;
17490 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17491 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
17492 return SWIG_Py_Void();
17493 }
17494
17495 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17496 return SWIG_Python_InitShadowInstance(args);
17497 }
17498
17499 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17500 PyObject *resultobj = 0;
17501 wxImage *arg1 = 0 ;
17502 wxImage *arg2 = 0 ;
17503 int arg3 = (int) 236 ;
17504 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
17505 bool result;
17506 void *argp1 = 0 ;
17507 int res1 = 0 ;
17508 void *argp2 = 0 ;
17509 int res2 = 0 ;
17510 int val3 ;
17511 int ecode3 = 0 ;
17512 int val4 ;
17513 int ecode4 = 0 ;
17514 PyObject * obj0 = 0 ;
17515 PyObject * obj1 = 0 ;
17516 PyObject * obj2 = 0 ;
17517 PyObject * obj3 = 0 ;
17518 char * kwnames[] = {
17519 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
17520 };
17521
17522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17523 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
17524 if (!SWIG_IsOK(res1)) {
17525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17526 }
17527 if (!argp1) {
17528 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17529 }
17530 arg1 = reinterpret_cast< wxImage * >(argp1);
17531 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
17532 if (!SWIG_IsOK(res2)) {
17533 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17534 }
17535 if (!argp2) {
17536 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17537 }
17538 arg2 = reinterpret_cast< wxImage * >(argp2);
17539 if (obj2) {
17540 ecode3 = SWIG_AsVal_int(obj2, &val3);
17541 if (!SWIG_IsOK(ecode3)) {
17542 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
17543 }
17544 arg3 = static_cast< int >(val3);
17545 }
17546 if (obj3) {
17547 ecode4 = SWIG_AsVal_int(obj3, &val4);
17548 if (!SWIG_IsOK(ecode4)) {
17549 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
17550 }
17551 arg4 = static_cast< int >(val4);
17552 }
17553 {
17554 PyThreadState* __tstate = wxPyBeginAllowThreads();
17555 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
17556 wxPyEndAllowThreads(__tstate);
17557 if (PyErr_Occurred()) SWIG_fail;
17558 }
17559 {
17560 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17561 }
17562 return resultobj;
17563 fail:
17564 return NULL;
17565 }
17566
17567
17568 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17569 PyObject *obj;
17570 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17571 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
17572 return SWIG_Py_Void();
17573 }
17574
17575 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17576 PyObject *resultobj = 0;
17577 wxEvtHandler *result = 0 ;
17578
17579 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
17580 {
17581 PyThreadState* __tstate = wxPyBeginAllowThreads();
17582 result = (wxEvtHandler *)new wxEvtHandler();
17583 wxPyEndAllowThreads(__tstate);
17584 if (PyErr_Occurred()) SWIG_fail;
17585 }
17586 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
17587 return resultobj;
17588 fail:
17589 return NULL;
17590 }
17591
17592
17593 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17594 PyObject *resultobj = 0;
17595 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17596 wxEvtHandler *result = 0 ;
17597 void *argp1 = 0 ;
17598 int res1 = 0 ;
17599 PyObject *swig_obj[1] ;
17600
17601 if (!args) SWIG_fail;
17602 swig_obj[0] = args;
17603 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17604 if (!SWIG_IsOK(res1)) {
17605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17606 }
17607 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17608 {
17609 PyThreadState* __tstate = wxPyBeginAllowThreads();
17610 result = (wxEvtHandler *)(arg1)->GetNextHandler();
17611 wxPyEndAllowThreads(__tstate);
17612 if (PyErr_Occurred()) SWIG_fail;
17613 }
17614 {
17615 resultobj = wxPyMake_wxObject(result, 0);
17616 }
17617 return resultobj;
17618 fail:
17619 return NULL;
17620 }
17621
17622
17623 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17624 PyObject *resultobj = 0;
17625 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17626 wxEvtHandler *result = 0 ;
17627 void *argp1 = 0 ;
17628 int res1 = 0 ;
17629 PyObject *swig_obj[1] ;
17630
17631 if (!args) SWIG_fail;
17632 swig_obj[0] = args;
17633 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17634 if (!SWIG_IsOK(res1)) {
17635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17636 }
17637 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17638 {
17639 PyThreadState* __tstate = wxPyBeginAllowThreads();
17640 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
17641 wxPyEndAllowThreads(__tstate);
17642 if (PyErr_Occurred()) SWIG_fail;
17643 }
17644 {
17645 resultobj = wxPyMake_wxObject(result, 0);
17646 }
17647 return resultobj;
17648 fail:
17649 return NULL;
17650 }
17651
17652
17653 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17654 PyObject *resultobj = 0;
17655 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17656 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17657 void *argp1 = 0 ;
17658 int res1 = 0 ;
17659 void *argp2 = 0 ;
17660 int res2 = 0 ;
17661 PyObject * obj0 = 0 ;
17662 PyObject * obj1 = 0 ;
17663 char * kwnames[] = {
17664 (char *) "self",(char *) "handler", NULL
17665 };
17666
17667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17668 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17669 if (!SWIG_IsOK(res1)) {
17670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17671 }
17672 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17673 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17674 if (!SWIG_IsOK(res2)) {
17675 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17676 }
17677 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17678 {
17679 PyThreadState* __tstate = wxPyBeginAllowThreads();
17680 (arg1)->SetNextHandler(arg2);
17681 wxPyEndAllowThreads(__tstate);
17682 if (PyErr_Occurred()) SWIG_fail;
17683 }
17684 resultobj = SWIG_Py_Void();
17685 return resultobj;
17686 fail:
17687 return NULL;
17688 }
17689
17690
17691 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17692 PyObject *resultobj = 0;
17693 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17694 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17695 void *argp1 = 0 ;
17696 int res1 = 0 ;
17697 void *argp2 = 0 ;
17698 int res2 = 0 ;
17699 PyObject * obj0 = 0 ;
17700 PyObject * obj1 = 0 ;
17701 char * kwnames[] = {
17702 (char *) "self",(char *) "handler", NULL
17703 };
17704
17705 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17706 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17707 if (!SWIG_IsOK(res1)) {
17708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17709 }
17710 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17711 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17712 if (!SWIG_IsOK(res2)) {
17713 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17714 }
17715 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17716 {
17717 PyThreadState* __tstate = wxPyBeginAllowThreads();
17718 (arg1)->SetPreviousHandler(arg2);
17719 wxPyEndAllowThreads(__tstate);
17720 if (PyErr_Occurred()) SWIG_fail;
17721 }
17722 resultobj = SWIG_Py_Void();
17723 return resultobj;
17724 fail:
17725 return NULL;
17726 }
17727
17728
17729 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17730 PyObject *resultobj = 0;
17731 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17732 bool result;
17733 void *argp1 = 0 ;
17734 int res1 = 0 ;
17735 PyObject *swig_obj[1] ;
17736
17737 if (!args) SWIG_fail;
17738 swig_obj[0] = args;
17739 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17740 if (!SWIG_IsOK(res1)) {
17741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17742 }
17743 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17744 {
17745 PyThreadState* __tstate = wxPyBeginAllowThreads();
17746 result = (bool)(arg1)->GetEvtHandlerEnabled();
17747 wxPyEndAllowThreads(__tstate);
17748 if (PyErr_Occurred()) SWIG_fail;
17749 }
17750 {
17751 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17752 }
17753 return resultobj;
17754 fail:
17755 return NULL;
17756 }
17757
17758
17759 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17760 PyObject *resultobj = 0;
17761 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17762 bool arg2 ;
17763 void *argp1 = 0 ;
17764 int res1 = 0 ;
17765 bool val2 ;
17766 int ecode2 = 0 ;
17767 PyObject * obj0 = 0 ;
17768 PyObject * obj1 = 0 ;
17769 char * kwnames[] = {
17770 (char *) "self",(char *) "enabled", NULL
17771 };
17772
17773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
17774 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17775 if (!SWIG_IsOK(res1)) {
17776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17777 }
17778 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17779 ecode2 = SWIG_AsVal_bool(obj1, &val2);
17780 if (!SWIG_IsOK(ecode2)) {
17781 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
17782 }
17783 arg2 = static_cast< bool >(val2);
17784 {
17785 PyThreadState* __tstate = wxPyBeginAllowThreads();
17786 (arg1)->SetEvtHandlerEnabled(arg2);
17787 wxPyEndAllowThreads(__tstate);
17788 if (PyErr_Occurred()) SWIG_fail;
17789 }
17790 resultobj = SWIG_Py_Void();
17791 return resultobj;
17792 fail:
17793 return NULL;
17794 }
17795
17796
17797 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17798 PyObject *resultobj = 0;
17799 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17800 wxEvent *arg2 = 0 ;
17801 bool result;
17802 void *argp1 = 0 ;
17803 int res1 = 0 ;
17804 void *argp2 = 0 ;
17805 int res2 = 0 ;
17806 PyObject * obj0 = 0 ;
17807 PyObject * obj1 = 0 ;
17808 char * kwnames[] = {
17809 (char *) "self",(char *) "event", NULL
17810 };
17811
17812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
17813 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17814 if (!SWIG_IsOK(res1)) {
17815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17816 }
17817 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17818 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
17819 if (!SWIG_IsOK(res2)) {
17820 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17821 }
17822 if (!argp2) {
17823 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17824 }
17825 arg2 = reinterpret_cast< wxEvent * >(argp2);
17826 {
17827 PyThreadState* __tstate = wxPyBeginAllowThreads();
17828 result = (bool)(arg1)->ProcessEvent(*arg2);
17829 wxPyEndAllowThreads(__tstate);
17830 if (PyErr_Occurred()) SWIG_fail;
17831 }
17832 {
17833 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17834 }
17835 return resultobj;
17836 fail:
17837 return NULL;
17838 }
17839
17840
17841 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17842 PyObject *resultobj = 0;
17843 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17844 wxEvent *arg2 = 0 ;
17845 void *argp1 = 0 ;
17846 int res1 = 0 ;
17847 void *argp2 = 0 ;
17848 int res2 = 0 ;
17849 PyObject * obj0 = 0 ;
17850 PyObject * obj1 = 0 ;
17851 char * kwnames[] = {
17852 (char *) "self",(char *) "event", NULL
17853 };
17854
17855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
17856 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17857 if (!SWIG_IsOK(res1)) {
17858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17859 }
17860 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17861 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
17862 if (!SWIG_IsOK(res2)) {
17863 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17864 }
17865 if (!argp2) {
17866 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17867 }
17868 arg2 = reinterpret_cast< wxEvent * >(argp2);
17869 {
17870 PyThreadState* __tstate = wxPyBeginAllowThreads();
17871 (arg1)->AddPendingEvent(*arg2);
17872 wxPyEndAllowThreads(__tstate);
17873 if (PyErr_Occurred()) SWIG_fail;
17874 }
17875 resultobj = SWIG_Py_Void();
17876 return resultobj;
17877 fail:
17878 return NULL;
17879 }
17880
17881
17882 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17883 PyObject *resultobj = 0;
17884 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17885 void *argp1 = 0 ;
17886 int res1 = 0 ;
17887 PyObject *swig_obj[1] ;
17888
17889 if (!args) SWIG_fail;
17890 swig_obj[0] = args;
17891 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17892 if (!SWIG_IsOK(res1)) {
17893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17894 }
17895 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17896 {
17897 PyThreadState* __tstate = wxPyBeginAllowThreads();
17898 (arg1)->ProcessPendingEvents();
17899 wxPyEndAllowThreads(__tstate);
17900 if (PyErr_Occurred()) SWIG_fail;
17901 }
17902 resultobj = SWIG_Py_Void();
17903 return resultobj;
17904 fail:
17905 return NULL;
17906 }
17907
17908
17909 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17910 PyObject *resultobj = 0;
17911 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17912 int arg2 ;
17913 int arg3 ;
17914 int arg4 ;
17915 PyObject *arg5 = (PyObject *) 0 ;
17916 void *argp1 = 0 ;
17917 int res1 = 0 ;
17918 int val2 ;
17919 int ecode2 = 0 ;
17920 int val3 ;
17921 int ecode3 = 0 ;
17922 int val4 ;
17923 int ecode4 = 0 ;
17924 PyObject * obj0 = 0 ;
17925 PyObject * obj1 = 0 ;
17926 PyObject * obj2 = 0 ;
17927 PyObject * obj3 = 0 ;
17928 PyObject * obj4 = 0 ;
17929 char * kwnames[] = {
17930 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
17931 };
17932
17933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17934 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17935 if (!SWIG_IsOK(res1)) {
17936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17937 }
17938 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17939 ecode2 = SWIG_AsVal_int(obj1, &val2);
17940 if (!SWIG_IsOK(ecode2)) {
17941 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
17942 }
17943 arg2 = static_cast< int >(val2);
17944 ecode3 = SWIG_AsVal_int(obj2, &val3);
17945 if (!SWIG_IsOK(ecode3)) {
17946 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
17947 }
17948 arg3 = static_cast< int >(val3);
17949 ecode4 = SWIG_AsVal_int(obj3, &val4);
17950 if (!SWIG_IsOK(ecode4)) {
17951 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
17952 }
17953 arg4 = static_cast< int >(val4);
17954 arg5 = obj4;
17955 {
17956 PyThreadState* __tstate = wxPyBeginAllowThreads();
17957 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
17958 wxPyEndAllowThreads(__tstate);
17959 if (PyErr_Occurred()) SWIG_fail;
17960 }
17961 resultobj = SWIG_Py_Void();
17962 return resultobj;
17963 fail:
17964 return NULL;
17965 }
17966
17967
17968 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17969 PyObject *resultobj = 0;
17970 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17971 int arg2 ;
17972 int arg3 = (int) -1 ;
17973 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
17974 bool result;
17975 void *argp1 = 0 ;
17976 int res1 = 0 ;
17977 int val2 ;
17978 int ecode2 = 0 ;
17979 int val3 ;
17980 int ecode3 = 0 ;
17981 int val4 ;
17982 int ecode4 = 0 ;
17983 PyObject * obj0 = 0 ;
17984 PyObject * obj1 = 0 ;
17985 PyObject * obj2 = 0 ;
17986 PyObject * obj3 = 0 ;
17987 char * kwnames[] = {
17988 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
17989 };
17990
17991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17992 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17993 if (!SWIG_IsOK(res1)) {
17994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17995 }
17996 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17997 ecode2 = SWIG_AsVal_int(obj1, &val2);
17998 if (!SWIG_IsOK(ecode2)) {
17999 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
18000 }
18001 arg2 = static_cast< int >(val2);
18002 if (obj2) {
18003 ecode3 = SWIG_AsVal_int(obj2, &val3);
18004 if (!SWIG_IsOK(ecode3)) {
18005 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
18006 }
18007 arg3 = static_cast< int >(val3);
18008 }
18009 if (obj3) {
18010 ecode4 = SWIG_AsVal_int(obj3, &val4);
18011 if (!SWIG_IsOK(ecode4)) {
18012 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
18013 }
18014 arg4 = static_cast< wxEventType >(val4);
18015 }
18016 {
18017 PyThreadState* __tstate = wxPyBeginAllowThreads();
18018 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
18019 wxPyEndAllowThreads(__tstate);
18020 if (PyErr_Occurred()) SWIG_fail;
18021 }
18022 {
18023 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18024 }
18025 return resultobj;
18026 fail:
18027 return NULL;
18028 }
18029
18030
18031 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18032 PyObject *resultobj = 0;
18033 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18034 PyObject *arg2 = (PyObject *) 0 ;
18035 bool arg3 = (bool) true ;
18036 void *argp1 = 0 ;
18037 int res1 = 0 ;
18038 bool val3 ;
18039 int ecode3 = 0 ;
18040 PyObject * obj0 = 0 ;
18041 PyObject * obj1 = 0 ;
18042 PyObject * obj2 = 0 ;
18043 char * kwnames[] = {
18044 (char *) "self",(char *) "_self",(char *) "incref", NULL
18045 };
18046
18047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18049 if (!SWIG_IsOK(res1)) {
18050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18051 }
18052 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18053 arg2 = obj1;
18054 if (obj2) {
18055 ecode3 = SWIG_AsVal_bool(obj2, &val3);
18056 if (!SWIG_IsOK(ecode3)) {
18057 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
18058 }
18059 arg3 = static_cast< bool >(val3);
18060 }
18061 {
18062 PyThreadState* __tstate = wxPyBeginAllowThreads();
18063 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
18064 wxPyEndAllowThreads(__tstate);
18065 if (PyErr_Occurred()) SWIG_fail;
18066 }
18067 resultobj = SWIG_Py_Void();
18068 return resultobj;
18069 fail:
18070 return NULL;
18071 }
18072
18073
18074 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18075 PyObject *obj;
18076 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18077 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
18078 return SWIG_Py_Void();
18079 }
18080
18081 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18082 return SWIG_Python_InitShadowInstance(args);
18083 }
18084
18085 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18086 PyObject *resultobj = 0;
18087 wxEventType result;
18088
18089 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
18090 {
18091 PyThreadState* __tstate = wxPyBeginAllowThreads();
18092 result = (wxEventType)wxNewEventType();
18093 wxPyEndAllowThreads(__tstate);
18094 if (PyErr_Occurred()) SWIG_fail;
18095 }
18096 resultobj = SWIG_From_int(static_cast< int >(result));
18097 return resultobj;
18098 fail:
18099 return NULL;
18100 }
18101
18102
18103 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18104 PyObject *resultobj = 0;
18105 wxEvent *arg1 = (wxEvent *) 0 ;
18106 void *argp1 = 0 ;
18107 int res1 = 0 ;
18108 PyObject *swig_obj[1] ;
18109
18110 if (!args) SWIG_fail;
18111 swig_obj[0] = args;
18112 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
18113 if (!SWIG_IsOK(res1)) {
18114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
18115 }
18116 arg1 = reinterpret_cast< wxEvent * >(argp1);
18117 {
18118 PyThreadState* __tstate = wxPyBeginAllowThreads();
18119 delete arg1;
18120
18121 wxPyEndAllowThreads(__tstate);
18122 if (PyErr_Occurred()) SWIG_fail;
18123 }
18124 resultobj = SWIG_Py_Void();
18125 return resultobj;
18126 fail:
18127 return NULL;
18128 }
18129
18130
18131 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18132 PyObject *resultobj = 0;
18133 wxEvent *arg1 = (wxEvent *) 0 ;
18134 wxEventType arg2 ;
18135 void *argp1 = 0 ;
18136 int res1 = 0 ;
18137 int val2 ;
18138 int ecode2 = 0 ;
18139 PyObject * obj0 = 0 ;
18140 PyObject * obj1 = 0 ;
18141 char * kwnames[] = {
18142 (char *) "self",(char *) "typ", NULL
18143 };
18144
18145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
18146 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18147 if (!SWIG_IsOK(res1)) {
18148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
18149 }
18150 arg1 = reinterpret_cast< wxEvent * >(argp1);
18151 ecode2 = SWIG_AsVal_int(obj1, &val2);
18152 if (!SWIG_IsOK(ecode2)) {
18153 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
18154 }
18155 arg2 = static_cast< wxEventType >(val2);
18156 {
18157 PyThreadState* __tstate = wxPyBeginAllowThreads();
18158 (arg1)->SetEventType(arg2);
18159 wxPyEndAllowThreads(__tstate);
18160 if (PyErr_Occurred()) SWIG_fail;
18161 }
18162 resultobj = SWIG_Py_Void();
18163 return resultobj;
18164 fail:
18165 return NULL;
18166 }
18167
18168
18169 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18170 PyObject *resultobj = 0;
18171 wxEvent *arg1 = (wxEvent *) 0 ;
18172 wxEventType result;
18173 void *argp1 = 0 ;
18174 int res1 = 0 ;
18175 PyObject *swig_obj[1] ;
18176
18177 if (!args) SWIG_fail;
18178 swig_obj[0] = args;
18179 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18180 if (!SWIG_IsOK(res1)) {
18181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
18182 }
18183 arg1 = reinterpret_cast< wxEvent * >(argp1);
18184 {
18185 PyThreadState* __tstate = wxPyBeginAllowThreads();
18186 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
18187 wxPyEndAllowThreads(__tstate);
18188 if (PyErr_Occurred()) SWIG_fail;
18189 }
18190 resultobj = SWIG_From_int(static_cast< int >(result));
18191 return resultobj;
18192 fail:
18193 return NULL;
18194 }
18195
18196
18197 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18198 PyObject *resultobj = 0;
18199 wxEvent *arg1 = (wxEvent *) 0 ;
18200 wxObject *result = 0 ;
18201 void *argp1 = 0 ;
18202 int res1 = 0 ;
18203 PyObject *swig_obj[1] ;
18204
18205 if (!args) SWIG_fail;
18206 swig_obj[0] = args;
18207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18208 if (!SWIG_IsOK(res1)) {
18209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
18210 }
18211 arg1 = reinterpret_cast< wxEvent * >(argp1);
18212 {
18213 PyThreadState* __tstate = wxPyBeginAllowThreads();
18214 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
18215 wxPyEndAllowThreads(__tstate);
18216 if (PyErr_Occurred()) SWIG_fail;
18217 }
18218 {
18219 resultobj = wxPyMake_wxObject(result, (bool)0);
18220 }
18221 return resultobj;
18222 fail:
18223 return NULL;
18224 }
18225
18226
18227 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18228 PyObject *resultobj = 0;
18229 wxEvent *arg1 = (wxEvent *) 0 ;
18230 wxObject *arg2 = (wxObject *) 0 ;
18231 void *argp1 = 0 ;
18232 int res1 = 0 ;
18233 void *argp2 = 0 ;
18234 int res2 = 0 ;
18235 PyObject * obj0 = 0 ;
18236 PyObject * obj1 = 0 ;
18237 char * kwnames[] = {
18238 (char *) "self",(char *) "obj", NULL
18239 };
18240
18241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
18242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18243 if (!SWIG_IsOK(res1)) {
18244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
18245 }
18246 arg1 = reinterpret_cast< wxEvent * >(argp1);
18247 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
18248 if (!SWIG_IsOK(res2)) {
18249 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
18250 }
18251 arg2 = reinterpret_cast< wxObject * >(argp2);
18252 {
18253 PyThreadState* __tstate = wxPyBeginAllowThreads();
18254 (arg1)->SetEventObject(arg2);
18255 wxPyEndAllowThreads(__tstate);
18256 if (PyErr_Occurred()) SWIG_fail;
18257 }
18258 resultobj = SWIG_Py_Void();
18259 return resultobj;
18260 fail:
18261 return NULL;
18262 }
18263
18264
18265 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18266 PyObject *resultobj = 0;
18267 wxEvent *arg1 = (wxEvent *) 0 ;
18268 long result;
18269 void *argp1 = 0 ;
18270 int res1 = 0 ;
18271 PyObject *swig_obj[1] ;
18272
18273 if (!args) SWIG_fail;
18274 swig_obj[0] = args;
18275 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18276 if (!SWIG_IsOK(res1)) {
18277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
18278 }
18279 arg1 = reinterpret_cast< wxEvent * >(argp1);
18280 {
18281 PyThreadState* __tstate = wxPyBeginAllowThreads();
18282 result = (long)((wxEvent const *)arg1)->GetTimestamp();
18283 wxPyEndAllowThreads(__tstate);
18284 if (PyErr_Occurred()) SWIG_fail;
18285 }
18286 resultobj = SWIG_From_long(static_cast< long >(result));
18287 return resultobj;
18288 fail:
18289 return NULL;
18290 }
18291
18292
18293 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18294 PyObject *resultobj = 0;
18295 wxEvent *arg1 = (wxEvent *) 0 ;
18296 long arg2 = (long) 0 ;
18297 void *argp1 = 0 ;
18298 int res1 = 0 ;
18299 long val2 ;
18300 int ecode2 = 0 ;
18301 PyObject * obj0 = 0 ;
18302 PyObject * obj1 = 0 ;
18303 char * kwnames[] = {
18304 (char *) "self",(char *) "ts", NULL
18305 };
18306
18307 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
18308 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18309 if (!SWIG_IsOK(res1)) {
18310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
18311 }
18312 arg1 = reinterpret_cast< wxEvent * >(argp1);
18313 if (obj1) {
18314 ecode2 = SWIG_AsVal_long(obj1, &val2);
18315 if (!SWIG_IsOK(ecode2)) {
18316 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
18317 }
18318 arg2 = static_cast< long >(val2);
18319 }
18320 {
18321 PyThreadState* __tstate = wxPyBeginAllowThreads();
18322 (arg1)->SetTimestamp(arg2);
18323 wxPyEndAllowThreads(__tstate);
18324 if (PyErr_Occurred()) SWIG_fail;
18325 }
18326 resultobj = SWIG_Py_Void();
18327 return resultobj;
18328 fail:
18329 return NULL;
18330 }
18331
18332
18333 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18334 PyObject *resultobj = 0;
18335 wxEvent *arg1 = (wxEvent *) 0 ;
18336 int result;
18337 void *argp1 = 0 ;
18338 int res1 = 0 ;
18339 PyObject *swig_obj[1] ;
18340
18341 if (!args) SWIG_fail;
18342 swig_obj[0] = args;
18343 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18344 if (!SWIG_IsOK(res1)) {
18345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
18346 }
18347 arg1 = reinterpret_cast< wxEvent * >(argp1);
18348 {
18349 PyThreadState* __tstate = wxPyBeginAllowThreads();
18350 result = (int)((wxEvent const *)arg1)->GetId();
18351 wxPyEndAllowThreads(__tstate);
18352 if (PyErr_Occurred()) SWIG_fail;
18353 }
18354 resultobj = SWIG_From_int(static_cast< int >(result));
18355 return resultobj;
18356 fail:
18357 return NULL;
18358 }
18359
18360
18361 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18362 PyObject *resultobj = 0;
18363 wxEvent *arg1 = (wxEvent *) 0 ;
18364 int arg2 ;
18365 void *argp1 = 0 ;
18366 int res1 = 0 ;
18367 int val2 ;
18368 int ecode2 = 0 ;
18369 PyObject * obj0 = 0 ;
18370 PyObject * obj1 = 0 ;
18371 char * kwnames[] = {
18372 (char *) "self",(char *) "Id", NULL
18373 };
18374
18375 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
18376 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18377 if (!SWIG_IsOK(res1)) {
18378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
18379 }
18380 arg1 = reinterpret_cast< wxEvent * >(argp1);
18381 ecode2 = SWIG_AsVal_int(obj1, &val2);
18382 if (!SWIG_IsOK(ecode2)) {
18383 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
18384 }
18385 arg2 = static_cast< int >(val2);
18386 {
18387 PyThreadState* __tstate = wxPyBeginAllowThreads();
18388 (arg1)->SetId(arg2);
18389 wxPyEndAllowThreads(__tstate);
18390 if (PyErr_Occurred()) SWIG_fail;
18391 }
18392 resultobj = SWIG_Py_Void();
18393 return resultobj;
18394 fail:
18395 return NULL;
18396 }
18397
18398
18399 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18400 PyObject *resultobj = 0;
18401 wxEvent *arg1 = (wxEvent *) 0 ;
18402 bool result;
18403 void *argp1 = 0 ;
18404 int res1 = 0 ;
18405 PyObject *swig_obj[1] ;
18406
18407 if (!args) SWIG_fail;
18408 swig_obj[0] = args;
18409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18410 if (!SWIG_IsOK(res1)) {
18411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
18412 }
18413 arg1 = reinterpret_cast< wxEvent * >(argp1);
18414 {
18415 PyThreadState* __tstate = wxPyBeginAllowThreads();
18416 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
18417 wxPyEndAllowThreads(__tstate);
18418 if (PyErr_Occurred()) SWIG_fail;
18419 }
18420 {
18421 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18422 }
18423 return resultobj;
18424 fail:
18425 return NULL;
18426 }
18427
18428
18429 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18430 PyObject *resultobj = 0;
18431 wxEvent *arg1 = (wxEvent *) 0 ;
18432 bool arg2 = (bool) true ;
18433 void *argp1 = 0 ;
18434 int res1 = 0 ;
18435 bool val2 ;
18436 int ecode2 = 0 ;
18437 PyObject * obj0 = 0 ;
18438 PyObject * obj1 = 0 ;
18439 char * kwnames[] = {
18440 (char *) "self",(char *) "skip", NULL
18441 };
18442
18443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
18444 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18445 if (!SWIG_IsOK(res1)) {
18446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
18447 }
18448 arg1 = reinterpret_cast< wxEvent * >(argp1);
18449 if (obj1) {
18450 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18451 if (!SWIG_IsOK(ecode2)) {
18452 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
18453 }
18454 arg2 = static_cast< bool >(val2);
18455 }
18456 {
18457 PyThreadState* __tstate = wxPyBeginAllowThreads();
18458 (arg1)->Skip(arg2);
18459 wxPyEndAllowThreads(__tstate);
18460 if (PyErr_Occurred()) SWIG_fail;
18461 }
18462 resultobj = SWIG_Py_Void();
18463 return resultobj;
18464 fail:
18465 return NULL;
18466 }
18467
18468
18469 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18470 PyObject *resultobj = 0;
18471 wxEvent *arg1 = (wxEvent *) 0 ;
18472 bool result;
18473 void *argp1 = 0 ;
18474 int res1 = 0 ;
18475 PyObject *swig_obj[1] ;
18476
18477 if (!args) SWIG_fail;
18478 swig_obj[0] = args;
18479 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18480 if (!SWIG_IsOK(res1)) {
18481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
18482 }
18483 arg1 = reinterpret_cast< wxEvent * >(argp1);
18484 {
18485 PyThreadState* __tstate = wxPyBeginAllowThreads();
18486 result = (bool)((wxEvent const *)arg1)->GetSkipped();
18487 wxPyEndAllowThreads(__tstate);
18488 if (PyErr_Occurred()) SWIG_fail;
18489 }
18490 {
18491 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18492 }
18493 return resultobj;
18494 fail:
18495 return NULL;
18496 }
18497
18498
18499 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18500 PyObject *resultobj = 0;
18501 wxEvent *arg1 = (wxEvent *) 0 ;
18502 bool result;
18503 void *argp1 = 0 ;
18504 int res1 = 0 ;
18505 PyObject *swig_obj[1] ;
18506
18507 if (!args) SWIG_fail;
18508 swig_obj[0] = args;
18509 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18510 if (!SWIG_IsOK(res1)) {
18511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
18512 }
18513 arg1 = reinterpret_cast< wxEvent * >(argp1);
18514 {
18515 PyThreadState* __tstate = wxPyBeginAllowThreads();
18516 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
18517 wxPyEndAllowThreads(__tstate);
18518 if (PyErr_Occurred()) SWIG_fail;
18519 }
18520 {
18521 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18522 }
18523 return resultobj;
18524 fail:
18525 return NULL;
18526 }
18527
18528
18529 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18530 PyObject *resultobj = 0;
18531 wxEvent *arg1 = (wxEvent *) 0 ;
18532 int result;
18533 void *argp1 = 0 ;
18534 int res1 = 0 ;
18535 PyObject *swig_obj[1] ;
18536
18537 if (!args) SWIG_fail;
18538 swig_obj[0] = args;
18539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18540 if (!SWIG_IsOK(res1)) {
18541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18542 }
18543 arg1 = reinterpret_cast< wxEvent * >(argp1);
18544 {
18545 PyThreadState* __tstate = wxPyBeginAllowThreads();
18546 result = (int)(arg1)->StopPropagation();
18547 wxPyEndAllowThreads(__tstate);
18548 if (PyErr_Occurred()) SWIG_fail;
18549 }
18550 resultobj = SWIG_From_int(static_cast< int >(result));
18551 return resultobj;
18552 fail:
18553 return NULL;
18554 }
18555
18556
18557 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18558 PyObject *resultobj = 0;
18559 wxEvent *arg1 = (wxEvent *) 0 ;
18560 int arg2 ;
18561 void *argp1 = 0 ;
18562 int res1 = 0 ;
18563 int val2 ;
18564 int ecode2 = 0 ;
18565 PyObject * obj0 = 0 ;
18566 PyObject * obj1 = 0 ;
18567 char * kwnames[] = {
18568 (char *) "self",(char *) "propagationLevel", NULL
18569 };
18570
18571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
18572 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18573 if (!SWIG_IsOK(res1)) {
18574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18575 }
18576 arg1 = reinterpret_cast< wxEvent * >(argp1);
18577 ecode2 = SWIG_AsVal_int(obj1, &val2);
18578 if (!SWIG_IsOK(ecode2)) {
18579 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
18580 }
18581 arg2 = static_cast< int >(val2);
18582 {
18583 PyThreadState* __tstate = wxPyBeginAllowThreads();
18584 (arg1)->ResumePropagation(arg2);
18585 wxPyEndAllowThreads(__tstate);
18586 if (PyErr_Occurred()) SWIG_fail;
18587 }
18588 resultobj = SWIG_Py_Void();
18589 return resultobj;
18590 fail:
18591 return NULL;
18592 }
18593
18594
18595 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18596 PyObject *resultobj = 0;
18597 wxEvent *arg1 = (wxEvent *) 0 ;
18598 wxEvent *result = 0 ;
18599 void *argp1 = 0 ;
18600 int res1 = 0 ;
18601 PyObject *swig_obj[1] ;
18602
18603 if (!args) SWIG_fail;
18604 swig_obj[0] = args;
18605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18606 if (!SWIG_IsOK(res1)) {
18607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
18608 }
18609 arg1 = reinterpret_cast< wxEvent * >(argp1);
18610 {
18611 PyThreadState* __tstate = wxPyBeginAllowThreads();
18612 result = (wxEvent *)(arg1)->Clone();
18613 wxPyEndAllowThreads(__tstate);
18614 if (PyErr_Occurred()) SWIG_fail;
18615 }
18616 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
18617 return resultobj;
18618 fail:
18619 return NULL;
18620 }
18621
18622
18623 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18624 PyObject *obj;
18625 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18626 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
18627 return SWIG_Py_Void();
18628 }
18629
18630 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18631 PyObject *resultobj = 0;
18632 wxEvent *arg1 = 0 ;
18633 wxPropagationDisabler *result = 0 ;
18634 void *argp1 = 0 ;
18635 int res1 = 0 ;
18636 PyObject * obj0 = 0 ;
18637 char * kwnames[] = {
18638 (char *) "event", NULL
18639 };
18640
18641 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
18642 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18643 if (!SWIG_IsOK(res1)) {
18644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18645 }
18646 if (!argp1) {
18647 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18648 }
18649 arg1 = reinterpret_cast< wxEvent * >(argp1);
18650 {
18651 PyThreadState* __tstate = wxPyBeginAllowThreads();
18652 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
18653 wxPyEndAllowThreads(__tstate);
18654 if (PyErr_Occurred()) SWIG_fail;
18655 }
18656 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
18657 return resultobj;
18658 fail:
18659 return NULL;
18660 }
18661
18662
18663 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18664 PyObject *resultobj = 0;
18665 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
18666 void *argp1 = 0 ;
18667 int res1 = 0 ;
18668 PyObject *swig_obj[1] ;
18669
18670 if (!args) SWIG_fail;
18671 swig_obj[0] = args;
18672 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
18673 if (!SWIG_IsOK(res1)) {
18674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
18675 }
18676 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
18677 {
18678 PyThreadState* __tstate = wxPyBeginAllowThreads();
18679 delete arg1;
18680
18681 wxPyEndAllowThreads(__tstate);
18682 if (PyErr_Occurred()) SWIG_fail;
18683 }
18684 resultobj = SWIG_Py_Void();
18685 return resultobj;
18686 fail:
18687 return NULL;
18688 }
18689
18690
18691 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18692 PyObject *obj;
18693 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18694 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
18695 return SWIG_Py_Void();
18696 }
18697
18698 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18699 return SWIG_Python_InitShadowInstance(args);
18700 }
18701
18702 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18703 PyObject *resultobj = 0;
18704 wxEvent *arg1 = 0 ;
18705 wxPropagateOnce *result = 0 ;
18706 void *argp1 = 0 ;
18707 int res1 = 0 ;
18708 PyObject * obj0 = 0 ;
18709 char * kwnames[] = {
18710 (char *) "event", NULL
18711 };
18712
18713 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
18714 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18715 if (!SWIG_IsOK(res1)) {
18716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18717 }
18718 if (!argp1) {
18719 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18720 }
18721 arg1 = reinterpret_cast< wxEvent * >(argp1);
18722 {
18723 PyThreadState* __tstate = wxPyBeginAllowThreads();
18724 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
18725 wxPyEndAllowThreads(__tstate);
18726 if (PyErr_Occurred()) SWIG_fail;
18727 }
18728 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
18729 return resultobj;
18730 fail:
18731 return NULL;
18732 }
18733
18734
18735 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18736 PyObject *resultobj = 0;
18737 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
18738 void *argp1 = 0 ;
18739 int res1 = 0 ;
18740 PyObject *swig_obj[1] ;
18741
18742 if (!args) SWIG_fail;
18743 swig_obj[0] = args;
18744 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
18745 if (!SWIG_IsOK(res1)) {
18746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
18747 }
18748 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
18749 {
18750 PyThreadState* __tstate = wxPyBeginAllowThreads();
18751 delete arg1;
18752
18753 wxPyEndAllowThreads(__tstate);
18754 if (PyErr_Occurred()) SWIG_fail;
18755 }
18756 resultobj = SWIG_Py_Void();
18757 return resultobj;
18758 fail:
18759 return NULL;
18760 }
18761
18762
18763 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18764 PyObject *obj;
18765 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18766 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
18767 return SWIG_Py_Void();
18768 }
18769
18770 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18771 return SWIG_Python_InitShadowInstance(args);
18772 }
18773
18774 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18775 PyObject *resultobj = 0;
18776 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
18777 int arg2 = (int) 0 ;
18778 wxCommandEvent *result = 0 ;
18779 int val1 ;
18780 int ecode1 = 0 ;
18781 int val2 ;
18782 int ecode2 = 0 ;
18783 PyObject * obj0 = 0 ;
18784 PyObject * obj1 = 0 ;
18785 char * kwnames[] = {
18786 (char *) "commandType",(char *) "winid", NULL
18787 };
18788
18789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18790 if (obj0) {
18791 ecode1 = SWIG_AsVal_int(obj0, &val1);
18792 if (!SWIG_IsOK(ecode1)) {
18793 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
18794 }
18795 arg1 = static_cast< wxEventType >(val1);
18796 }
18797 if (obj1) {
18798 ecode2 = SWIG_AsVal_int(obj1, &val2);
18799 if (!SWIG_IsOK(ecode2)) {
18800 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
18801 }
18802 arg2 = static_cast< int >(val2);
18803 }
18804 {
18805 PyThreadState* __tstate = wxPyBeginAllowThreads();
18806 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
18807 wxPyEndAllowThreads(__tstate);
18808 if (PyErr_Occurred()) SWIG_fail;
18809 }
18810 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
18811 return resultobj;
18812 fail:
18813 return NULL;
18814 }
18815
18816
18817 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18818 PyObject *resultobj = 0;
18819 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18820 int result;
18821 void *argp1 = 0 ;
18822 int res1 = 0 ;
18823 PyObject *swig_obj[1] ;
18824
18825 if (!args) SWIG_fail;
18826 swig_obj[0] = args;
18827 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18828 if (!SWIG_IsOK(res1)) {
18829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18830 }
18831 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18832 {
18833 PyThreadState* __tstate = wxPyBeginAllowThreads();
18834 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
18835 wxPyEndAllowThreads(__tstate);
18836 if (PyErr_Occurred()) SWIG_fail;
18837 }
18838 resultobj = SWIG_From_int(static_cast< int >(result));
18839 return resultobj;
18840 fail:
18841 return NULL;
18842 }
18843
18844
18845 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18846 PyObject *resultobj = 0;
18847 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18848 wxString *arg2 = 0 ;
18849 void *argp1 = 0 ;
18850 int res1 = 0 ;
18851 bool temp2 = false ;
18852 PyObject * obj0 = 0 ;
18853 PyObject * obj1 = 0 ;
18854 char * kwnames[] = {
18855 (char *) "self",(char *) "s", NULL
18856 };
18857
18858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
18859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18860 if (!SWIG_IsOK(res1)) {
18861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
18862 }
18863 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18864 {
18865 arg2 = wxString_in_helper(obj1);
18866 if (arg2 == NULL) SWIG_fail;
18867 temp2 = true;
18868 }
18869 {
18870 PyThreadState* __tstate = wxPyBeginAllowThreads();
18871 (arg1)->SetString((wxString const &)*arg2);
18872 wxPyEndAllowThreads(__tstate);
18873 if (PyErr_Occurred()) SWIG_fail;
18874 }
18875 resultobj = SWIG_Py_Void();
18876 {
18877 if (temp2)
18878 delete arg2;
18879 }
18880 return resultobj;
18881 fail:
18882 {
18883 if (temp2)
18884 delete arg2;
18885 }
18886 return NULL;
18887 }
18888
18889
18890 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18891 PyObject *resultobj = 0;
18892 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18893 wxString result;
18894 void *argp1 = 0 ;
18895 int res1 = 0 ;
18896 PyObject *swig_obj[1] ;
18897
18898 if (!args) SWIG_fail;
18899 swig_obj[0] = args;
18900 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18901 if (!SWIG_IsOK(res1)) {
18902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18903 }
18904 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18905 {
18906 PyThreadState* __tstate = wxPyBeginAllowThreads();
18907 result = ((wxCommandEvent const *)arg1)->GetString();
18908 wxPyEndAllowThreads(__tstate);
18909 if (PyErr_Occurred()) SWIG_fail;
18910 }
18911 {
18912 #if wxUSE_UNICODE
18913 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18914 #else
18915 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18916 #endif
18917 }
18918 return resultobj;
18919 fail:
18920 return NULL;
18921 }
18922
18923
18924 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18925 PyObject *resultobj = 0;
18926 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18927 bool result;
18928 void *argp1 = 0 ;
18929 int res1 = 0 ;
18930 PyObject *swig_obj[1] ;
18931
18932 if (!args) SWIG_fail;
18933 swig_obj[0] = args;
18934 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18935 if (!SWIG_IsOK(res1)) {
18936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18937 }
18938 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18939 {
18940 PyThreadState* __tstate = wxPyBeginAllowThreads();
18941 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
18942 wxPyEndAllowThreads(__tstate);
18943 if (PyErr_Occurred()) SWIG_fail;
18944 }
18945 {
18946 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18947 }
18948 return resultobj;
18949 fail:
18950 return NULL;
18951 }
18952
18953
18954 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18955 PyObject *resultobj = 0;
18956 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18957 bool result;
18958 void *argp1 = 0 ;
18959 int res1 = 0 ;
18960 PyObject *swig_obj[1] ;
18961
18962 if (!args) SWIG_fail;
18963 swig_obj[0] = args;
18964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18965 if (!SWIG_IsOK(res1)) {
18966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18967 }
18968 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18969 {
18970 PyThreadState* __tstate = wxPyBeginAllowThreads();
18971 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
18972 wxPyEndAllowThreads(__tstate);
18973 if (PyErr_Occurred()) SWIG_fail;
18974 }
18975 {
18976 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18977 }
18978 return resultobj;
18979 fail:
18980 return NULL;
18981 }
18982
18983
18984 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18985 PyObject *resultobj = 0;
18986 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18987 long arg2 ;
18988 void *argp1 = 0 ;
18989 int res1 = 0 ;
18990 long val2 ;
18991 int ecode2 = 0 ;
18992 PyObject * obj0 = 0 ;
18993 PyObject * obj1 = 0 ;
18994 char * kwnames[] = {
18995 (char *) "self",(char *) "extraLong", NULL
18996 };
18997
18998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
18999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19000 if (!SWIG_IsOK(res1)) {
19001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19002 }
19003 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19004 ecode2 = SWIG_AsVal_long(obj1, &val2);
19005 if (!SWIG_IsOK(ecode2)) {
19006 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
19007 }
19008 arg2 = static_cast< long >(val2);
19009 {
19010 PyThreadState* __tstate = wxPyBeginAllowThreads();
19011 (arg1)->SetExtraLong(arg2);
19012 wxPyEndAllowThreads(__tstate);
19013 if (PyErr_Occurred()) SWIG_fail;
19014 }
19015 resultobj = SWIG_Py_Void();
19016 return resultobj;
19017 fail:
19018 return NULL;
19019 }
19020
19021
19022 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19023 PyObject *resultobj = 0;
19024 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19025 long result;
19026 void *argp1 = 0 ;
19027 int res1 = 0 ;
19028 PyObject *swig_obj[1] ;
19029
19030 if (!args) SWIG_fail;
19031 swig_obj[0] = args;
19032 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19033 if (!SWIG_IsOK(res1)) {
19034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19035 }
19036 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19037 {
19038 PyThreadState* __tstate = wxPyBeginAllowThreads();
19039 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
19040 wxPyEndAllowThreads(__tstate);
19041 if (PyErr_Occurred()) SWIG_fail;
19042 }
19043 resultobj = SWIG_From_long(static_cast< long >(result));
19044 return resultobj;
19045 fail:
19046 return NULL;
19047 }
19048
19049
19050 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19051 PyObject *resultobj = 0;
19052 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19053 int arg2 ;
19054 void *argp1 = 0 ;
19055 int res1 = 0 ;
19056 int val2 ;
19057 int ecode2 = 0 ;
19058 PyObject * obj0 = 0 ;
19059 PyObject * obj1 = 0 ;
19060 char * kwnames[] = {
19061 (char *) "self",(char *) "i", NULL
19062 };
19063
19064 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
19065 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19066 if (!SWIG_IsOK(res1)) {
19067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19068 }
19069 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19070 ecode2 = SWIG_AsVal_int(obj1, &val2);
19071 if (!SWIG_IsOK(ecode2)) {
19072 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
19073 }
19074 arg2 = static_cast< int >(val2);
19075 {
19076 PyThreadState* __tstate = wxPyBeginAllowThreads();
19077 (arg1)->SetInt(arg2);
19078 wxPyEndAllowThreads(__tstate);
19079 if (PyErr_Occurred()) SWIG_fail;
19080 }
19081 resultobj = SWIG_Py_Void();
19082 return resultobj;
19083 fail:
19084 return NULL;
19085 }
19086
19087
19088 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19089 PyObject *resultobj = 0;
19090 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19091 long result;
19092 void *argp1 = 0 ;
19093 int res1 = 0 ;
19094 PyObject *swig_obj[1] ;
19095
19096 if (!args) SWIG_fail;
19097 swig_obj[0] = args;
19098 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19099 if (!SWIG_IsOK(res1)) {
19100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19101 }
19102 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19103 {
19104 PyThreadState* __tstate = wxPyBeginAllowThreads();
19105 result = (long)((wxCommandEvent const *)arg1)->GetInt();
19106 wxPyEndAllowThreads(__tstate);
19107 if (PyErr_Occurred()) SWIG_fail;
19108 }
19109 resultobj = SWIG_From_long(static_cast< long >(result));
19110 return resultobj;
19111 fail:
19112 return NULL;
19113 }
19114
19115
19116 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19117 PyObject *resultobj = 0;
19118 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19119 PyObject *result = 0 ;
19120 void *argp1 = 0 ;
19121 int res1 = 0 ;
19122 PyObject *swig_obj[1] ;
19123
19124 if (!args) SWIG_fail;
19125 swig_obj[0] = args;
19126 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19127 if (!SWIG_IsOK(res1)) {
19128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19129 }
19130 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19131 {
19132 PyThreadState* __tstate = wxPyBeginAllowThreads();
19133 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
19134 wxPyEndAllowThreads(__tstate);
19135 if (PyErr_Occurred()) SWIG_fail;
19136 }
19137 resultobj = result;
19138 return resultobj;
19139 fail:
19140 return NULL;
19141 }
19142
19143
19144 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19145 PyObject *resultobj = 0;
19146 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19147 PyObject *arg2 = (PyObject *) 0 ;
19148 void *argp1 = 0 ;
19149 int res1 = 0 ;
19150 PyObject * obj0 = 0 ;
19151 PyObject * obj1 = 0 ;
19152 char * kwnames[] = {
19153 (char *) "self",(char *) "clientData", NULL
19154 };
19155
19156 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
19157 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19158 if (!SWIG_IsOK(res1)) {
19159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19160 }
19161 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19162 arg2 = obj1;
19163 {
19164 PyThreadState* __tstate = wxPyBeginAllowThreads();
19165 wxCommandEvent_SetClientData(arg1,arg2);
19166 wxPyEndAllowThreads(__tstate);
19167 if (PyErr_Occurred()) SWIG_fail;
19168 }
19169 resultobj = SWIG_Py_Void();
19170 return resultobj;
19171 fail:
19172 return NULL;
19173 }
19174
19175
19176 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19177 PyObject *resultobj = 0;
19178 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19179 wxEvent *result = 0 ;
19180 void *argp1 = 0 ;
19181 int res1 = 0 ;
19182 PyObject *swig_obj[1] ;
19183
19184 if (!args) SWIG_fail;
19185 swig_obj[0] = args;
19186 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19187 if (!SWIG_IsOK(res1)) {
19188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19189 }
19190 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19191 {
19192 PyThreadState* __tstate = wxPyBeginAllowThreads();
19193 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
19194 wxPyEndAllowThreads(__tstate);
19195 if (PyErr_Occurred()) SWIG_fail;
19196 }
19197 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
19198 return resultobj;
19199 fail:
19200 return NULL;
19201 }
19202
19203
19204 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19205 PyObject *obj;
19206 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19207 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
19208 return SWIG_Py_Void();
19209 }
19210
19211 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19212 return SWIG_Python_InitShadowInstance(args);
19213 }
19214
19215 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19216 PyObject *resultobj = 0;
19217 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19218 int arg2 = (int) 0 ;
19219 wxNotifyEvent *result = 0 ;
19220 int val1 ;
19221 int ecode1 = 0 ;
19222 int val2 ;
19223 int ecode2 = 0 ;
19224 PyObject * obj0 = 0 ;
19225 PyObject * obj1 = 0 ;
19226 char * kwnames[] = {
19227 (char *) "commandType",(char *) "winid", NULL
19228 };
19229
19230 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19231 if (obj0) {
19232 ecode1 = SWIG_AsVal_int(obj0, &val1);
19233 if (!SWIG_IsOK(ecode1)) {
19234 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19235 }
19236 arg1 = static_cast< wxEventType >(val1);
19237 }
19238 if (obj1) {
19239 ecode2 = SWIG_AsVal_int(obj1, &val2);
19240 if (!SWIG_IsOK(ecode2)) {
19241 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
19242 }
19243 arg2 = static_cast< int >(val2);
19244 }
19245 {
19246 PyThreadState* __tstate = wxPyBeginAllowThreads();
19247 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
19248 wxPyEndAllowThreads(__tstate);
19249 if (PyErr_Occurred()) SWIG_fail;
19250 }
19251 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
19252 return resultobj;
19253 fail:
19254 return NULL;
19255 }
19256
19257
19258 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19259 PyObject *resultobj = 0;
19260 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19261 void *argp1 = 0 ;
19262 int res1 = 0 ;
19263 PyObject *swig_obj[1] ;
19264
19265 if (!args) SWIG_fail;
19266 swig_obj[0] = args;
19267 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19268 if (!SWIG_IsOK(res1)) {
19269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19270 }
19271 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19272 {
19273 PyThreadState* __tstate = wxPyBeginAllowThreads();
19274 (arg1)->Veto();
19275 wxPyEndAllowThreads(__tstate);
19276 if (PyErr_Occurred()) SWIG_fail;
19277 }
19278 resultobj = SWIG_Py_Void();
19279 return resultobj;
19280 fail:
19281 return NULL;
19282 }
19283
19284
19285 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19286 PyObject *resultobj = 0;
19287 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19288 void *argp1 = 0 ;
19289 int res1 = 0 ;
19290 PyObject *swig_obj[1] ;
19291
19292 if (!args) SWIG_fail;
19293 swig_obj[0] = args;
19294 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19295 if (!SWIG_IsOK(res1)) {
19296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19297 }
19298 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19299 {
19300 PyThreadState* __tstate = wxPyBeginAllowThreads();
19301 (arg1)->Allow();
19302 wxPyEndAllowThreads(__tstate);
19303 if (PyErr_Occurred()) SWIG_fail;
19304 }
19305 resultobj = SWIG_Py_Void();
19306 return resultobj;
19307 fail:
19308 return NULL;
19309 }
19310
19311
19312 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19313 PyObject *resultobj = 0;
19314 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19315 bool result;
19316 void *argp1 = 0 ;
19317 int res1 = 0 ;
19318 PyObject *swig_obj[1] ;
19319
19320 if (!args) SWIG_fail;
19321 swig_obj[0] = args;
19322 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19323 if (!SWIG_IsOK(res1)) {
19324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19325 }
19326 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19327 {
19328 PyThreadState* __tstate = wxPyBeginAllowThreads();
19329 result = (bool)(arg1)->IsAllowed();
19330 wxPyEndAllowThreads(__tstate);
19331 if (PyErr_Occurred()) SWIG_fail;
19332 }
19333 {
19334 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19335 }
19336 return resultobj;
19337 fail:
19338 return NULL;
19339 }
19340
19341
19342 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19343 PyObject *obj;
19344 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19345 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
19346 return SWIG_Py_Void();
19347 }
19348
19349 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19350 return SWIG_Python_InitShadowInstance(args);
19351 }
19352
19353 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19354 PyObject *resultobj = 0;
19355 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19356 int arg2 = (int) 0 ;
19357 int arg3 = (int) 0 ;
19358 int arg4 = (int) 0 ;
19359 wxScrollEvent *result = 0 ;
19360 int val1 ;
19361 int ecode1 = 0 ;
19362 int val2 ;
19363 int ecode2 = 0 ;
19364 int val3 ;
19365 int ecode3 = 0 ;
19366 int val4 ;
19367 int ecode4 = 0 ;
19368 PyObject * obj0 = 0 ;
19369 PyObject * obj1 = 0 ;
19370 PyObject * obj2 = 0 ;
19371 PyObject * obj3 = 0 ;
19372 char * kwnames[] = {
19373 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
19374 };
19375
19376 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19377 if (obj0) {
19378 ecode1 = SWIG_AsVal_int(obj0, &val1);
19379 if (!SWIG_IsOK(ecode1)) {
19380 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19381 }
19382 arg1 = static_cast< wxEventType >(val1);
19383 }
19384 if (obj1) {
19385 ecode2 = SWIG_AsVal_int(obj1, &val2);
19386 if (!SWIG_IsOK(ecode2)) {
19387 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
19388 }
19389 arg2 = static_cast< int >(val2);
19390 }
19391 if (obj2) {
19392 ecode3 = SWIG_AsVal_int(obj2, &val3);
19393 if (!SWIG_IsOK(ecode3)) {
19394 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
19395 }
19396 arg3 = static_cast< int >(val3);
19397 }
19398 if (obj3) {
19399 ecode4 = SWIG_AsVal_int(obj3, &val4);
19400 if (!SWIG_IsOK(ecode4)) {
19401 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
19402 }
19403 arg4 = static_cast< int >(val4);
19404 }
19405 {
19406 PyThreadState* __tstate = wxPyBeginAllowThreads();
19407 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
19408 wxPyEndAllowThreads(__tstate);
19409 if (PyErr_Occurred()) SWIG_fail;
19410 }
19411 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
19412 return resultobj;
19413 fail:
19414 return NULL;
19415 }
19416
19417
19418 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19419 PyObject *resultobj = 0;
19420 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19421 int result;
19422 void *argp1 = 0 ;
19423 int res1 = 0 ;
19424 PyObject *swig_obj[1] ;
19425
19426 if (!args) SWIG_fail;
19427 swig_obj[0] = args;
19428 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19429 if (!SWIG_IsOK(res1)) {
19430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19431 }
19432 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19433 {
19434 PyThreadState* __tstate = wxPyBeginAllowThreads();
19435 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
19436 wxPyEndAllowThreads(__tstate);
19437 if (PyErr_Occurred()) SWIG_fail;
19438 }
19439 resultobj = SWIG_From_int(static_cast< int >(result));
19440 return resultobj;
19441 fail:
19442 return NULL;
19443 }
19444
19445
19446 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19447 PyObject *resultobj = 0;
19448 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19449 int result;
19450 void *argp1 = 0 ;
19451 int res1 = 0 ;
19452 PyObject *swig_obj[1] ;
19453
19454 if (!args) SWIG_fail;
19455 swig_obj[0] = args;
19456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19457 if (!SWIG_IsOK(res1)) {
19458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19459 }
19460 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19461 {
19462 PyThreadState* __tstate = wxPyBeginAllowThreads();
19463 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
19464 wxPyEndAllowThreads(__tstate);
19465 if (PyErr_Occurred()) SWIG_fail;
19466 }
19467 resultobj = SWIG_From_int(static_cast< int >(result));
19468 return resultobj;
19469 fail:
19470 return NULL;
19471 }
19472
19473
19474 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19475 PyObject *resultobj = 0;
19476 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19477 int arg2 ;
19478 void *argp1 = 0 ;
19479 int res1 = 0 ;
19480 int val2 ;
19481 int ecode2 = 0 ;
19482 PyObject * obj0 = 0 ;
19483 PyObject * obj1 = 0 ;
19484 char * kwnames[] = {
19485 (char *) "self",(char *) "orient", NULL
19486 };
19487
19488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19489 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19490 if (!SWIG_IsOK(res1)) {
19491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19492 }
19493 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19494 ecode2 = SWIG_AsVal_int(obj1, &val2);
19495 if (!SWIG_IsOK(ecode2)) {
19496 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19497 }
19498 arg2 = static_cast< int >(val2);
19499 {
19500 PyThreadState* __tstate = wxPyBeginAllowThreads();
19501 (arg1)->SetOrientation(arg2);
19502 wxPyEndAllowThreads(__tstate);
19503 if (PyErr_Occurred()) SWIG_fail;
19504 }
19505 resultobj = SWIG_Py_Void();
19506 return resultobj;
19507 fail:
19508 return NULL;
19509 }
19510
19511
19512 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19513 PyObject *resultobj = 0;
19514 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19515 int arg2 ;
19516 void *argp1 = 0 ;
19517 int res1 = 0 ;
19518 int val2 ;
19519 int ecode2 = 0 ;
19520 PyObject * obj0 = 0 ;
19521 PyObject * obj1 = 0 ;
19522 char * kwnames[] = {
19523 (char *) "self",(char *) "pos", NULL
19524 };
19525
19526 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19527 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19528 if (!SWIG_IsOK(res1)) {
19529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19530 }
19531 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19532 ecode2 = SWIG_AsVal_int(obj1, &val2);
19533 if (!SWIG_IsOK(ecode2)) {
19534 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19535 }
19536 arg2 = static_cast< int >(val2);
19537 {
19538 PyThreadState* __tstate = wxPyBeginAllowThreads();
19539 (arg1)->SetPosition(arg2);
19540 wxPyEndAllowThreads(__tstate);
19541 if (PyErr_Occurred()) SWIG_fail;
19542 }
19543 resultobj = SWIG_Py_Void();
19544 return resultobj;
19545 fail:
19546 return NULL;
19547 }
19548
19549
19550 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19551 PyObject *obj;
19552 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19553 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
19554 return SWIG_Py_Void();
19555 }
19556
19557 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19558 return SWIG_Python_InitShadowInstance(args);
19559 }
19560
19561 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19562 PyObject *resultobj = 0;
19563 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19564 int arg2 = (int) 0 ;
19565 int arg3 = (int) 0 ;
19566 wxScrollWinEvent *result = 0 ;
19567 int val1 ;
19568 int ecode1 = 0 ;
19569 int val2 ;
19570 int ecode2 = 0 ;
19571 int val3 ;
19572 int ecode3 = 0 ;
19573 PyObject * obj0 = 0 ;
19574 PyObject * obj1 = 0 ;
19575 PyObject * obj2 = 0 ;
19576 char * kwnames[] = {
19577 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
19578 };
19579
19580 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19581 if (obj0) {
19582 ecode1 = SWIG_AsVal_int(obj0, &val1);
19583 if (!SWIG_IsOK(ecode1)) {
19584 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19585 }
19586 arg1 = static_cast< wxEventType >(val1);
19587 }
19588 if (obj1) {
19589 ecode2 = SWIG_AsVal_int(obj1, &val2);
19590 if (!SWIG_IsOK(ecode2)) {
19591 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
19592 }
19593 arg2 = static_cast< int >(val2);
19594 }
19595 if (obj2) {
19596 ecode3 = SWIG_AsVal_int(obj2, &val3);
19597 if (!SWIG_IsOK(ecode3)) {
19598 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
19599 }
19600 arg3 = static_cast< int >(val3);
19601 }
19602 {
19603 PyThreadState* __tstate = wxPyBeginAllowThreads();
19604 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
19605 wxPyEndAllowThreads(__tstate);
19606 if (PyErr_Occurred()) SWIG_fail;
19607 }
19608 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
19609 return resultobj;
19610 fail:
19611 return NULL;
19612 }
19613
19614
19615 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19616 PyObject *resultobj = 0;
19617 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19618 int result;
19619 void *argp1 = 0 ;
19620 int res1 = 0 ;
19621 PyObject *swig_obj[1] ;
19622
19623 if (!args) SWIG_fail;
19624 swig_obj[0] = args;
19625 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19626 if (!SWIG_IsOK(res1)) {
19627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19628 }
19629 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19630 {
19631 PyThreadState* __tstate = wxPyBeginAllowThreads();
19632 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
19633 wxPyEndAllowThreads(__tstate);
19634 if (PyErr_Occurred()) SWIG_fail;
19635 }
19636 resultobj = SWIG_From_int(static_cast< int >(result));
19637 return resultobj;
19638 fail:
19639 return NULL;
19640 }
19641
19642
19643 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19644 PyObject *resultobj = 0;
19645 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19646 int result;
19647 void *argp1 = 0 ;
19648 int res1 = 0 ;
19649 PyObject *swig_obj[1] ;
19650
19651 if (!args) SWIG_fail;
19652 swig_obj[0] = args;
19653 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19654 if (!SWIG_IsOK(res1)) {
19655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19656 }
19657 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19658 {
19659 PyThreadState* __tstate = wxPyBeginAllowThreads();
19660 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
19661 wxPyEndAllowThreads(__tstate);
19662 if (PyErr_Occurred()) SWIG_fail;
19663 }
19664 resultobj = SWIG_From_int(static_cast< int >(result));
19665 return resultobj;
19666 fail:
19667 return NULL;
19668 }
19669
19670
19671 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19672 PyObject *resultobj = 0;
19673 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19674 int arg2 ;
19675 void *argp1 = 0 ;
19676 int res1 = 0 ;
19677 int val2 ;
19678 int ecode2 = 0 ;
19679 PyObject * obj0 = 0 ;
19680 PyObject * obj1 = 0 ;
19681 char * kwnames[] = {
19682 (char *) "self",(char *) "orient", NULL
19683 };
19684
19685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19686 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19687 if (!SWIG_IsOK(res1)) {
19688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19689 }
19690 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19691 ecode2 = SWIG_AsVal_int(obj1, &val2);
19692 if (!SWIG_IsOK(ecode2)) {
19693 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19694 }
19695 arg2 = static_cast< int >(val2);
19696 {
19697 PyThreadState* __tstate = wxPyBeginAllowThreads();
19698 (arg1)->SetOrientation(arg2);
19699 wxPyEndAllowThreads(__tstate);
19700 if (PyErr_Occurred()) SWIG_fail;
19701 }
19702 resultobj = SWIG_Py_Void();
19703 return resultobj;
19704 fail:
19705 return NULL;
19706 }
19707
19708
19709 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19710 PyObject *resultobj = 0;
19711 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19712 int arg2 ;
19713 void *argp1 = 0 ;
19714 int res1 = 0 ;
19715 int val2 ;
19716 int ecode2 = 0 ;
19717 PyObject * obj0 = 0 ;
19718 PyObject * obj1 = 0 ;
19719 char * kwnames[] = {
19720 (char *) "self",(char *) "pos", NULL
19721 };
19722
19723 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19724 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19725 if (!SWIG_IsOK(res1)) {
19726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19727 }
19728 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19729 ecode2 = SWIG_AsVal_int(obj1, &val2);
19730 if (!SWIG_IsOK(ecode2)) {
19731 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19732 }
19733 arg2 = static_cast< int >(val2);
19734 {
19735 PyThreadState* __tstate = wxPyBeginAllowThreads();
19736 (arg1)->SetPosition(arg2);
19737 wxPyEndAllowThreads(__tstate);
19738 if (PyErr_Occurred()) SWIG_fail;
19739 }
19740 resultobj = SWIG_Py_Void();
19741 return resultobj;
19742 fail:
19743 return NULL;
19744 }
19745
19746
19747 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19748 PyObject *obj;
19749 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19750 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
19751 return SWIG_Py_Void();
19752 }
19753
19754 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19755 return SWIG_Python_InitShadowInstance(args);
19756 }
19757
19758 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19759 PyObject *resultobj = 0;
19760 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19761 wxMouseEvent *result = 0 ;
19762 int val1 ;
19763 int ecode1 = 0 ;
19764 PyObject * obj0 = 0 ;
19765 char * kwnames[] = {
19766 (char *) "mouseType", NULL
19767 };
19768
19769 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
19770 if (obj0) {
19771 ecode1 = SWIG_AsVal_int(obj0, &val1);
19772 if (!SWIG_IsOK(ecode1)) {
19773 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19774 }
19775 arg1 = static_cast< wxEventType >(val1);
19776 }
19777 {
19778 PyThreadState* __tstate = wxPyBeginAllowThreads();
19779 result = (wxMouseEvent *)new wxMouseEvent(arg1);
19780 wxPyEndAllowThreads(__tstate);
19781 if (PyErr_Occurred()) SWIG_fail;
19782 }
19783 {
19784 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
19785 }
19786 return resultobj;
19787 fail:
19788 return NULL;
19789 }
19790
19791
19792 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19793 PyObject *resultobj = 0;
19794 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19795 bool result;
19796 void *argp1 = 0 ;
19797 int res1 = 0 ;
19798 PyObject *swig_obj[1] ;
19799
19800 if (!args) SWIG_fail;
19801 swig_obj[0] = args;
19802 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19803 if (!SWIG_IsOK(res1)) {
19804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19805 }
19806 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19807 {
19808 PyThreadState* __tstate = wxPyBeginAllowThreads();
19809 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
19810 wxPyEndAllowThreads(__tstate);
19811 if (PyErr_Occurred()) SWIG_fail;
19812 }
19813 {
19814 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19815 }
19816 return resultobj;
19817 fail:
19818 return NULL;
19819 }
19820
19821
19822 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19823 PyObject *resultobj = 0;
19824 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19825 int arg2 = (int) wxMOUSE_BTN_ANY ;
19826 bool result;
19827 void *argp1 = 0 ;
19828 int res1 = 0 ;
19829 int val2 ;
19830 int ecode2 = 0 ;
19831 PyObject * obj0 = 0 ;
19832 PyObject * obj1 = 0 ;
19833 char * kwnames[] = {
19834 (char *) "self",(char *) "but", NULL
19835 };
19836
19837 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
19838 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19839 if (!SWIG_IsOK(res1)) {
19840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19841 }
19842 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19843 if (obj1) {
19844 ecode2 = SWIG_AsVal_int(obj1, &val2);
19845 if (!SWIG_IsOK(ecode2)) {
19846 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
19847 }
19848 arg2 = static_cast< int >(val2);
19849 }
19850 {
19851 PyThreadState* __tstate = wxPyBeginAllowThreads();
19852 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
19853 wxPyEndAllowThreads(__tstate);
19854 if (PyErr_Occurred()) SWIG_fail;
19855 }
19856 {
19857 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19858 }
19859 return resultobj;
19860 fail:
19861 return NULL;
19862 }
19863
19864
19865 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19866 PyObject *resultobj = 0;
19867 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19868 int arg2 = (int) wxMOUSE_BTN_ANY ;
19869 bool result;
19870 void *argp1 = 0 ;
19871 int res1 = 0 ;
19872 int val2 ;
19873 int ecode2 = 0 ;
19874 PyObject * obj0 = 0 ;
19875 PyObject * obj1 = 0 ;
19876 char * kwnames[] = {
19877 (char *) "self",(char *) "but", NULL
19878 };
19879
19880 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
19881 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19882 if (!SWIG_IsOK(res1)) {
19883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19884 }
19885 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19886 if (obj1) {
19887 ecode2 = SWIG_AsVal_int(obj1, &val2);
19888 if (!SWIG_IsOK(ecode2)) {
19889 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
19890 }
19891 arg2 = static_cast< int >(val2);
19892 }
19893 {
19894 PyThreadState* __tstate = wxPyBeginAllowThreads();
19895 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
19896 wxPyEndAllowThreads(__tstate);
19897 if (PyErr_Occurred()) SWIG_fail;
19898 }
19899 {
19900 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19901 }
19902 return resultobj;
19903 fail:
19904 return NULL;
19905 }
19906
19907
19908 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19909 PyObject *resultobj = 0;
19910 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19911 int arg2 = (int) wxMOUSE_BTN_ANY ;
19912 bool result;
19913 void *argp1 = 0 ;
19914 int res1 = 0 ;
19915 int val2 ;
19916 int ecode2 = 0 ;
19917 PyObject * obj0 = 0 ;
19918 PyObject * obj1 = 0 ;
19919 char * kwnames[] = {
19920 (char *) "self",(char *) "but", NULL
19921 };
19922
19923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
19924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19925 if (!SWIG_IsOK(res1)) {
19926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19927 }
19928 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19929 if (obj1) {
19930 ecode2 = SWIG_AsVal_int(obj1, &val2);
19931 if (!SWIG_IsOK(ecode2)) {
19932 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
19933 }
19934 arg2 = static_cast< int >(val2);
19935 }
19936 {
19937 PyThreadState* __tstate = wxPyBeginAllowThreads();
19938 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
19939 wxPyEndAllowThreads(__tstate);
19940 if (PyErr_Occurred()) SWIG_fail;
19941 }
19942 {
19943 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19944 }
19945 return resultobj;
19946 fail:
19947 return NULL;
19948 }
19949
19950
19951 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19952 PyObject *resultobj = 0;
19953 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19954 int arg2 ;
19955 bool result;
19956 void *argp1 = 0 ;
19957 int res1 = 0 ;
19958 int val2 ;
19959 int ecode2 = 0 ;
19960 PyObject * obj0 = 0 ;
19961 PyObject * obj1 = 0 ;
19962 char * kwnames[] = {
19963 (char *) "self",(char *) "button", NULL
19964 };
19965
19966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
19967 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19968 if (!SWIG_IsOK(res1)) {
19969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19970 }
19971 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19972 ecode2 = SWIG_AsVal_int(obj1, &val2);
19973 if (!SWIG_IsOK(ecode2)) {
19974 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
19975 }
19976 arg2 = static_cast< int >(val2);
19977 {
19978 PyThreadState* __tstate = wxPyBeginAllowThreads();
19979 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
19980 wxPyEndAllowThreads(__tstate);
19981 if (PyErr_Occurred()) SWIG_fail;
19982 }
19983 {
19984 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19985 }
19986 return resultobj;
19987 fail:
19988 return NULL;
19989 }
19990
19991
19992 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19993 PyObject *resultobj = 0;
19994 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19995 int arg2 ;
19996 bool result;
19997 void *argp1 = 0 ;
19998 int res1 = 0 ;
19999 int val2 ;
20000 int ecode2 = 0 ;
20001 PyObject * obj0 = 0 ;
20002 PyObject * obj1 = 0 ;
20003 char * kwnames[] = {
20004 (char *) "self",(char *) "but", NULL
20005 };
20006
20007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
20008 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20009 if (!SWIG_IsOK(res1)) {
20010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20011 }
20012 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20013 ecode2 = SWIG_AsVal_int(obj1, &val2);
20014 if (!SWIG_IsOK(ecode2)) {
20015 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
20016 }
20017 arg2 = static_cast< int >(val2);
20018 {
20019 PyThreadState* __tstate = wxPyBeginAllowThreads();
20020 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
20021 wxPyEndAllowThreads(__tstate);
20022 if (PyErr_Occurred()) SWIG_fail;
20023 }
20024 {
20025 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20026 }
20027 return resultobj;
20028 fail:
20029 return NULL;
20030 }
20031
20032
20033 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20034 PyObject *resultobj = 0;
20035 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20036 int result;
20037 void *argp1 = 0 ;
20038 int res1 = 0 ;
20039 PyObject *swig_obj[1] ;
20040
20041 if (!args) SWIG_fail;
20042 swig_obj[0] = args;
20043 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20044 if (!SWIG_IsOK(res1)) {
20045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20046 }
20047 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20048 {
20049 PyThreadState* __tstate = wxPyBeginAllowThreads();
20050 result = (int)((wxMouseEvent const *)arg1)->GetButton();
20051 wxPyEndAllowThreads(__tstate);
20052 if (PyErr_Occurred()) SWIG_fail;
20053 }
20054 resultobj = SWIG_From_int(static_cast< int >(result));
20055 return resultobj;
20056 fail:
20057 return NULL;
20058 }
20059
20060
20061 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20062 PyObject *resultobj = 0;
20063 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20064 bool result;
20065 void *argp1 = 0 ;
20066 int res1 = 0 ;
20067 PyObject *swig_obj[1] ;
20068
20069 if (!args) SWIG_fail;
20070 swig_obj[0] = args;
20071 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20072 if (!SWIG_IsOK(res1)) {
20073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20074 }
20075 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20076 {
20077 PyThreadState* __tstate = wxPyBeginAllowThreads();
20078 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
20079 wxPyEndAllowThreads(__tstate);
20080 if (PyErr_Occurred()) SWIG_fail;
20081 }
20082 {
20083 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20084 }
20085 return resultobj;
20086 fail:
20087 return NULL;
20088 }
20089
20090
20091 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20092 PyObject *resultobj = 0;
20093 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20094 bool result;
20095 void *argp1 = 0 ;
20096 int res1 = 0 ;
20097 PyObject *swig_obj[1] ;
20098
20099 if (!args) SWIG_fail;
20100 swig_obj[0] = args;
20101 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20102 if (!SWIG_IsOK(res1)) {
20103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20104 }
20105 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20106 {
20107 PyThreadState* __tstate = wxPyBeginAllowThreads();
20108 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
20109 wxPyEndAllowThreads(__tstate);
20110 if (PyErr_Occurred()) SWIG_fail;
20111 }
20112 {
20113 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20114 }
20115 return resultobj;
20116 fail:
20117 return NULL;
20118 }
20119
20120
20121 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20122 PyObject *resultobj = 0;
20123 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20124 bool result;
20125 void *argp1 = 0 ;
20126 int res1 = 0 ;
20127 PyObject *swig_obj[1] ;
20128
20129 if (!args) SWIG_fail;
20130 swig_obj[0] = args;
20131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20132 if (!SWIG_IsOK(res1)) {
20133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20134 }
20135 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20136 {
20137 PyThreadState* __tstate = wxPyBeginAllowThreads();
20138 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
20139 wxPyEndAllowThreads(__tstate);
20140 if (PyErr_Occurred()) SWIG_fail;
20141 }
20142 {
20143 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20144 }
20145 return resultobj;
20146 fail:
20147 return NULL;
20148 }
20149
20150
20151 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20152 PyObject *resultobj = 0;
20153 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20154 bool result;
20155 void *argp1 = 0 ;
20156 int res1 = 0 ;
20157 PyObject *swig_obj[1] ;
20158
20159 if (!args) SWIG_fail;
20160 swig_obj[0] = args;
20161 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20162 if (!SWIG_IsOK(res1)) {
20163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20164 }
20165 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20166 {
20167 PyThreadState* __tstate = wxPyBeginAllowThreads();
20168 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
20169 wxPyEndAllowThreads(__tstate);
20170 if (PyErr_Occurred()) SWIG_fail;
20171 }
20172 {
20173 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20174 }
20175 return resultobj;
20176 fail:
20177 return NULL;
20178 }
20179
20180
20181 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20182 PyObject *resultobj = 0;
20183 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20184 bool result;
20185 void *argp1 = 0 ;
20186 int res1 = 0 ;
20187 PyObject *swig_obj[1] ;
20188
20189 if (!args) SWIG_fail;
20190 swig_obj[0] = args;
20191 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20192 if (!SWIG_IsOK(res1)) {
20193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20194 }
20195 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20196 {
20197 PyThreadState* __tstate = wxPyBeginAllowThreads();
20198 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
20199 wxPyEndAllowThreads(__tstate);
20200 if (PyErr_Occurred()) SWIG_fail;
20201 }
20202 {
20203 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20204 }
20205 return resultobj;
20206 fail:
20207 return NULL;
20208 }
20209
20210
20211 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20212 PyObject *resultobj = 0;
20213 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20214 bool result;
20215 void *argp1 = 0 ;
20216 int res1 = 0 ;
20217 PyObject *swig_obj[1] ;
20218
20219 if (!args) SWIG_fail;
20220 swig_obj[0] = args;
20221 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20222 if (!SWIG_IsOK(res1)) {
20223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20224 }
20225 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20226 {
20227 PyThreadState* __tstate = wxPyBeginAllowThreads();
20228 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
20229 wxPyEndAllowThreads(__tstate);
20230 if (PyErr_Occurred()) SWIG_fail;
20231 }
20232 {
20233 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20234 }
20235 return resultobj;
20236 fail:
20237 return NULL;
20238 }
20239
20240
20241 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20242 PyObject *resultobj = 0;
20243 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20244 bool result;
20245 void *argp1 = 0 ;
20246 int res1 = 0 ;
20247 PyObject *swig_obj[1] ;
20248
20249 if (!args) SWIG_fail;
20250 swig_obj[0] = args;
20251 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20252 if (!SWIG_IsOK(res1)) {
20253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20254 }
20255 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20256 {
20257 PyThreadState* __tstate = wxPyBeginAllowThreads();
20258 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
20259 wxPyEndAllowThreads(__tstate);
20260 if (PyErr_Occurred()) SWIG_fail;
20261 }
20262 {
20263 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20264 }
20265 return resultobj;
20266 fail:
20267 return NULL;
20268 }
20269
20270
20271 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20272 PyObject *resultobj = 0;
20273 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20274 bool result;
20275 void *argp1 = 0 ;
20276 int res1 = 0 ;
20277 PyObject *swig_obj[1] ;
20278
20279 if (!args) SWIG_fail;
20280 swig_obj[0] = args;
20281 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20282 if (!SWIG_IsOK(res1)) {
20283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20284 }
20285 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20286 {
20287 PyThreadState* __tstate = wxPyBeginAllowThreads();
20288 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
20289 wxPyEndAllowThreads(__tstate);
20290 if (PyErr_Occurred()) SWIG_fail;
20291 }
20292 {
20293 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20294 }
20295 return resultobj;
20296 fail:
20297 return NULL;
20298 }
20299
20300
20301 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20302 PyObject *resultobj = 0;
20303 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20304 bool result;
20305 void *argp1 = 0 ;
20306 int res1 = 0 ;
20307 PyObject *swig_obj[1] ;
20308
20309 if (!args) SWIG_fail;
20310 swig_obj[0] = args;
20311 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20312 if (!SWIG_IsOK(res1)) {
20313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20314 }
20315 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20316 {
20317 PyThreadState* __tstate = wxPyBeginAllowThreads();
20318 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
20319 wxPyEndAllowThreads(__tstate);
20320 if (PyErr_Occurred()) SWIG_fail;
20321 }
20322 {
20323 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20324 }
20325 return resultobj;
20326 fail:
20327 return NULL;
20328 }
20329
20330
20331 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20332 PyObject *resultobj = 0;
20333 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20334 bool result;
20335 void *argp1 = 0 ;
20336 int res1 = 0 ;
20337 PyObject *swig_obj[1] ;
20338
20339 if (!args) SWIG_fail;
20340 swig_obj[0] = args;
20341 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20342 if (!SWIG_IsOK(res1)) {
20343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20344 }
20345 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20346 {
20347 PyThreadState* __tstate = wxPyBeginAllowThreads();
20348 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
20349 wxPyEndAllowThreads(__tstate);
20350 if (PyErr_Occurred()) SWIG_fail;
20351 }
20352 {
20353 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20354 }
20355 return resultobj;
20356 fail:
20357 return NULL;
20358 }
20359
20360
20361 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20362 PyObject *resultobj = 0;
20363 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20364 bool result;
20365 void *argp1 = 0 ;
20366 int res1 = 0 ;
20367 PyObject *swig_obj[1] ;
20368
20369 if (!args) SWIG_fail;
20370 swig_obj[0] = args;
20371 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20372 if (!SWIG_IsOK(res1)) {
20373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20374 }
20375 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20376 {
20377 PyThreadState* __tstate = wxPyBeginAllowThreads();
20378 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
20379 wxPyEndAllowThreads(__tstate);
20380 if (PyErr_Occurred()) SWIG_fail;
20381 }
20382 {
20383 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20384 }
20385 return resultobj;
20386 fail:
20387 return NULL;
20388 }
20389
20390
20391 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20392 PyObject *resultobj = 0;
20393 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20394 bool result;
20395 void *argp1 = 0 ;
20396 int res1 = 0 ;
20397 PyObject *swig_obj[1] ;
20398
20399 if (!args) SWIG_fail;
20400 swig_obj[0] = args;
20401 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20402 if (!SWIG_IsOK(res1)) {
20403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20404 }
20405 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20406 {
20407 PyThreadState* __tstate = wxPyBeginAllowThreads();
20408 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
20409 wxPyEndAllowThreads(__tstate);
20410 if (PyErr_Occurred()) SWIG_fail;
20411 }
20412 {
20413 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20414 }
20415 return resultobj;
20416 fail:
20417 return NULL;
20418 }
20419
20420
20421 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20422 PyObject *resultobj = 0;
20423 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20424 bool result;
20425 void *argp1 = 0 ;
20426 int res1 = 0 ;
20427 PyObject *swig_obj[1] ;
20428
20429 if (!args) SWIG_fail;
20430 swig_obj[0] = args;
20431 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20432 if (!SWIG_IsOK(res1)) {
20433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20434 }
20435 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20436 {
20437 PyThreadState* __tstate = wxPyBeginAllowThreads();
20438 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
20439 wxPyEndAllowThreads(__tstate);
20440 if (PyErr_Occurred()) SWIG_fail;
20441 }
20442 {
20443 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20444 }
20445 return resultobj;
20446 fail:
20447 return NULL;
20448 }
20449
20450
20451 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20452 PyObject *resultobj = 0;
20453 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20454 bool result;
20455 void *argp1 = 0 ;
20456 int res1 = 0 ;
20457 PyObject *swig_obj[1] ;
20458
20459 if (!args) SWIG_fail;
20460 swig_obj[0] = args;
20461 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20462 if (!SWIG_IsOK(res1)) {
20463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20464 }
20465 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20466 {
20467 PyThreadState* __tstate = wxPyBeginAllowThreads();
20468 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
20469 wxPyEndAllowThreads(__tstate);
20470 if (PyErr_Occurred()) SWIG_fail;
20471 }
20472 {
20473 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20474 }
20475 return resultobj;
20476 fail:
20477 return NULL;
20478 }
20479
20480
20481 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20482 PyObject *resultobj = 0;
20483 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20484 bool result;
20485 void *argp1 = 0 ;
20486 int res1 = 0 ;
20487 PyObject *swig_obj[1] ;
20488
20489 if (!args) SWIG_fail;
20490 swig_obj[0] = args;
20491 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20492 if (!SWIG_IsOK(res1)) {
20493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20494 }
20495 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20496 {
20497 PyThreadState* __tstate = wxPyBeginAllowThreads();
20498 result = (bool)(arg1)->LeftIsDown();
20499 wxPyEndAllowThreads(__tstate);
20500 if (PyErr_Occurred()) SWIG_fail;
20501 }
20502 {
20503 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20504 }
20505 return resultobj;
20506 fail:
20507 return NULL;
20508 }
20509
20510
20511 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20512 PyObject *resultobj = 0;
20513 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20514 bool result;
20515 void *argp1 = 0 ;
20516 int res1 = 0 ;
20517 PyObject *swig_obj[1] ;
20518
20519 if (!args) SWIG_fail;
20520 swig_obj[0] = args;
20521 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20522 if (!SWIG_IsOK(res1)) {
20523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20524 }
20525 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20526 {
20527 PyThreadState* __tstate = wxPyBeginAllowThreads();
20528 result = (bool)(arg1)->MiddleIsDown();
20529 wxPyEndAllowThreads(__tstate);
20530 if (PyErr_Occurred()) SWIG_fail;
20531 }
20532 {
20533 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20534 }
20535 return resultobj;
20536 fail:
20537 return NULL;
20538 }
20539
20540
20541 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20542 PyObject *resultobj = 0;
20543 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20544 bool result;
20545 void *argp1 = 0 ;
20546 int res1 = 0 ;
20547 PyObject *swig_obj[1] ;
20548
20549 if (!args) SWIG_fail;
20550 swig_obj[0] = args;
20551 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20552 if (!SWIG_IsOK(res1)) {
20553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20554 }
20555 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20556 {
20557 PyThreadState* __tstate = wxPyBeginAllowThreads();
20558 result = (bool)(arg1)->RightIsDown();
20559 wxPyEndAllowThreads(__tstate);
20560 if (PyErr_Occurred()) SWIG_fail;
20561 }
20562 {
20563 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20564 }
20565 return resultobj;
20566 fail:
20567 return NULL;
20568 }
20569
20570
20571 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20572 PyObject *resultobj = 0;
20573 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20574 bool result;
20575 void *argp1 = 0 ;
20576 int res1 = 0 ;
20577 PyObject *swig_obj[1] ;
20578
20579 if (!args) SWIG_fail;
20580 swig_obj[0] = args;
20581 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20582 if (!SWIG_IsOK(res1)) {
20583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20584 }
20585 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20586 {
20587 PyThreadState* __tstate = wxPyBeginAllowThreads();
20588 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
20589 wxPyEndAllowThreads(__tstate);
20590 if (PyErr_Occurred()) SWIG_fail;
20591 }
20592 {
20593 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20594 }
20595 return resultobj;
20596 fail:
20597 return NULL;
20598 }
20599
20600
20601 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20602 PyObject *resultobj = 0;
20603 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20604 bool result;
20605 void *argp1 = 0 ;
20606 int res1 = 0 ;
20607 PyObject *swig_obj[1] ;
20608
20609 if (!args) SWIG_fail;
20610 swig_obj[0] = args;
20611 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20612 if (!SWIG_IsOK(res1)) {
20613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20614 }
20615 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20616 {
20617 PyThreadState* __tstate = wxPyBeginAllowThreads();
20618 result = (bool)((wxMouseEvent const *)arg1)->Moving();
20619 wxPyEndAllowThreads(__tstate);
20620 if (PyErr_Occurred()) SWIG_fail;
20621 }
20622 {
20623 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20624 }
20625 return resultobj;
20626 fail:
20627 return NULL;
20628 }
20629
20630
20631 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20632 PyObject *resultobj = 0;
20633 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20634 bool result;
20635 void *argp1 = 0 ;
20636 int res1 = 0 ;
20637 PyObject *swig_obj[1] ;
20638
20639 if (!args) SWIG_fail;
20640 swig_obj[0] = args;
20641 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20642 if (!SWIG_IsOK(res1)) {
20643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20644 }
20645 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20646 {
20647 PyThreadState* __tstate = wxPyBeginAllowThreads();
20648 result = (bool)((wxMouseEvent const *)arg1)->Entering();
20649 wxPyEndAllowThreads(__tstate);
20650 if (PyErr_Occurred()) SWIG_fail;
20651 }
20652 {
20653 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20654 }
20655 return resultobj;
20656 fail:
20657 return NULL;
20658 }
20659
20660
20661 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20662 PyObject *resultobj = 0;
20663 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20664 bool result;
20665 void *argp1 = 0 ;
20666 int res1 = 0 ;
20667 PyObject *swig_obj[1] ;
20668
20669 if (!args) SWIG_fail;
20670 swig_obj[0] = args;
20671 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20672 if (!SWIG_IsOK(res1)) {
20673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20674 }
20675 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20676 {
20677 PyThreadState* __tstate = wxPyBeginAllowThreads();
20678 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
20679 wxPyEndAllowThreads(__tstate);
20680 if (PyErr_Occurred()) SWIG_fail;
20681 }
20682 {
20683 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20684 }
20685 return resultobj;
20686 fail:
20687 return NULL;
20688 }
20689
20690
20691 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20692 PyObject *resultobj = 0;
20693 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20694 wxPoint result;
20695 void *argp1 = 0 ;
20696 int res1 = 0 ;
20697 PyObject *swig_obj[1] ;
20698
20699 if (!args) SWIG_fail;
20700 swig_obj[0] = args;
20701 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20702 if (!SWIG_IsOK(res1)) {
20703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20704 }
20705 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20706 {
20707 PyThreadState* __tstate = wxPyBeginAllowThreads();
20708 result = (arg1)->GetPosition();
20709 wxPyEndAllowThreads(__tstate);
20710 if (PyErr_Occurred()) SWIG_fail;
20711 }
20712 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20713 return resultobj;
20714 fail:
20715 return NULL;
20716 }
20717
20718
20719 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20720 PyObject *resultobj = 0;
20721 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20722 long *arg2 = (long *) 0 ;
20723 long *arg3 = (long *) 0 ;
20724 void *argp1 = 0 ;
20725 int res1 = 0 ;
20726 long temp2 ;
20727 int res2 = SWIG_TMPOBJ ;
20728 long temp3 ;
20729 int res3 = SWIG_TMPOBJ ;
20730 PyObject *swig_obj[1] ;
20731
20732 arg2 = &temp2;
20733 arg3 = &temp3;
20734 if (!args) SWIG_fail;
20735 swig_obj[0] = args;
20736 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20737 if (!SWIG_IsOK(res1)) {
20738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20739 }
20740 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20741 {
20742 PyThreadState* __tstate = wxPyBeginAllowThreads();
20743 (arg1)->GetPosition(arg2,arg3);
20744 wxPyEndAllowThreads(__tstate);
20745 if (PyErr_Occurred()) SWIG_fail;
20746 }
20747 resultobj = SWIG_Py_Void();
20748 if (SWIG_IsTmpObj(res2)) {
20749 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
20750 } else {
20751 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20752 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
20753 }
20754 if (SWIG_IsTmpObj(res3)) {
20755 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
20756 } else {
20757 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20758 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
20759 }
20760 return resultobj;
20761 fail:
20762 return NULL;
20763 }
20764
20765
20766 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20767 PyObject *resultobj = 0;
20768 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20769 wxDC *arg2 = 0 ;
20770 wxPoint result;
20771 void *argp1 = 0 ;
20772 int res1 = 0 ;
20773 void *argp2 = 0 ;
20774 int res2 = 0 ;
20775 PyObject * obj0 = 0 ;
20776 PyObject * obj1 = 0 ;
20777 char * kwnames[] = {
20778 (char *) "self",(char *) "dc", NULL
20779 };
20780
20781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
20782 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20783 if (!SWIG_IsOK(res1)) {
20784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20785 }
20786 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20787 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
20788 if (!SWIG_IsOK(res2)) {
20789 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
20790 }
20791 if (!argp2) {
20792 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
20793 }
20794 arg2 = reinterpret_cast< wxDC * >(argp2);
20795 {
20796 PyThreadState* __tstate = wxPyBeginAllowThreads();
20797 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
20798 wxPyEndAllowThreads(__tstate);
20799 if (PyErr_Occurred()) SWIG_fail;
20800 }
20801 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20802 return resultobj;
20803 fail:
20804 return NULL;
20805 }
20806
20807
20808 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20809 PyObject *resultobj = 0;
20810 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20811 int result;
20812 void *argp1 = 0 ;
20813 int res1 = 0 ;
20814 PyObject *swig_obj[1] ;
20815
20816 if (!args) SWIG_fail;
20817 swig_obj[0] = args;
20818 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20819 if (!SWIG_IsOK(res1)) {
20820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20821 }
20822 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20823 {
20824 PyThreadState* __tstate = wxPyBeginAllowThreads();
20825 result = (int)((wxMouseEvent const *)arg1)->GetX();
20826 wxPyEndAllowThreads(__tstate);
20827 if (PyErr_Occurred()) SWIG_fail;
20828 }
20829 resultobj = SWIG_From_int(static_cast< int >(result));
20830 return resultobj;
20831 fail:
20832 return NULL;
20833 }
20834
20835
20836 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20837 PyObject *resultobj = 0;
20838 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20839 int result;
20840 void *argp1 = 0 ;
20841 int res1 = 0 ;
20842 PyObject *swig_obj[1] ;
20843
20844 if (!args) SWIG_fail;
20845 swig_obj[0] = args;
20846 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20847 if (!SWIG_IsOK(res1)) {
20848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20849 }
20850 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20851 {
20852 PyThreadState* __tstate = wxPyBeginAllowThreads();
20853 result = (int)((wxMouseEvent const *)arg1)->GetY();
20854 wxPyEndAllowThreads(__tstate);
20855 if (PyErr_Occurred()) SWIG_fail;
20856 }
20857 resultobj = SWIG_From_int(static_cast< int >(result));
20858 return resultobj;
20859 fail:
20860 return NULL;
20861 }
20862
20863
20864 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20865 PyObject *resultobj = 0;
20866 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20867 int result;
20868 void *argp1 = 0 ;
20869 int res1 = 0 ;
20870 PyObject *swig_obj[1] ;
20871
20872 if (!args) SWIG_fail;
20873 swig_obj[0] = args;
20874 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20875 if (!SWIG_IsOK(res1)) {
20876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20877 }
20878 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20879 {
20880 PyThreadState* __tstate = wxPyBeginAllowThreads();
20881 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
20882 wxPyEndAllowThreads(__tstate);
20883 if (PyErr_Occurred()) SWIG_fail;
20884 }
20885 resultobj = SWIG_From_int(static_cast< int >(result));
20886 return resultobj;
20887 fail:
20888 return NULL;
20889 }
20890
20891
20892 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20893 PyObject *resultobj = 0;
20894 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20895 int result;
20896 void *argp1 = 0 ;
20897 int res1 = 0 ;
20898 PyObject *swig_obj[1] ;
20899
20900 if (!args) SWIG_fail;
20901 swig_obj[0] = args;
20902 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20903 if (!SWIG_IsOK(res1)) {
20904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20905 }
20906 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20907 {
20908 PyThreadState* __tstate = wxPyBeginAllowThreads();
20909 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
20910 wxPyEndAllowThreads(__tstate);
20911 if (PyErr_Occurred()) SWIG_fail;
20912 }
20913 resultobj = SWIG_From_int(static_cast< int >(result));
20914 return resultobj;
20915 fail:
20916 return NULL;
20917 }
20918
20919
20920 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20921 PyObject *resultobj = 0;
20922 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20923 int result;
20924 void *argp1 = 0 ;
20925 int res1 = 0 ;
20926 PyObject *swig_obj[1] ;
20927
20928 if (!args) SWIG_fail;
20929 swig_obj[0] = args;
20930 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20931 if (!SWIG_IsOK(res1)) {
20932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20933 }
20934 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20935 {
20936 PyThreadState* __tstate = wxPyBeginAllowThreads();
20937 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
20938 wxPyEndAllowThreads(__tstate);
20939 if (PyErr_Occurred()) SWIG_fail;
20940 }
20941 resultobj = SWIG_From_int(static_cast< int >(result));
20942 return resultobj;
20943 fail:
20944 return NULL;
20945 }
20946
20947
20948 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20949 PyObject *resultobj = 0;
20950 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20951 bool result;
20952 void *argp1 = 0 ;
20953 int res1 = 0 ;
20954 PyObject *swig_obj[1] ;
20955
20956 if (!args) SWIG_fail;
20957 swig_obj[0] = args;
20958 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20959 if (!SWIG_IsOK(res1)) {
20960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20961 }
20962 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20963 {
20964 PyThreadState* __tstate = wxPyBeginAllowThreads();
20965 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
20966 wxPyEndAllowThreads(__tstate);
20967 if (PyErr_Occurred()) SWIG_fail;
20968 }
20969 {
20970 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20971 }
20972 return resultobj;
20973 fail:
20974 return NULL;
20975 }
20976
20977
20978 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20979 PyObject *resultobj = 0;
20980 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20981 int arg2 ;
20982 void *argp1 = 0 ;
20983 int res1 = 0 ;
20984 int val2 ;
20985 int ecode2 = 0 ;
20986 PyObject *swig_obj[2] ;
20987
20988 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
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_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20992 }
20993 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20994 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
20995 if (!SWIG_IsOK(ecode2)) {
20996 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
20997 }
20998 arg2 = static_cast< int >(val2);
20999 if (arg1) (arg1)->m_x = arg2;
21000
21001 resultobj = SWIG_Py_Void();
21002 return resultobj;
21003 fail:
21004 return NULL;
21005 }
21006
21007
21008 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21009 PyObject *resultobj = 0;
21010 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21011 int result;
21012 void *argp1 = 0 ;
21013 int res1 = 0 ;
21014 PyObject *swig_obj[1] ;
21015
21016 if (!args) SWIG_fail;
21017 swig_obj[0] = args;
21018 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21019 if (!SWIG_IsOK(res1)) {
21020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21021 }
21022 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21023 result = (int) ((arg1)->m_x);
21024 resultobj = SWIG_From_int(static_cast< int >(result));
21025 return resultobj;
21026 fail:
21027 return NULL;
21028 }
21029
21030
21031 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21032 PyObject *resultobj = 0;
21033 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21034 int arg2 ;
21035 void *argp1 = 0 ;
21036 int res1 = 0 ;
21037 int val2 ;
21038 int ecode2 = 0 ;
21039 PyObject *swig_obj[2] ;
21040
21041 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
21042 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21043 if (!SWIG_IsOK(res1)) {
21044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21045 }
21046 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21047 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21048 if (!SWIG_IsOK(ecode2)) {
21049 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
21050 }
21051 arg2 = static_cast< int >(val2);
21052 if (arg1) (arg1)->m_y = arg2;
21053
21054 resultobj = SWIG_Py_Void();
21055 return resultobj;
21056 fail:
21057 return NULL;
21058 }
21059
21060
21061 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21062 PyObject *resultobj = 0;
21063 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21064 int result;
21065 void *argp1 = 0 ;
21066 int res1 = 0 ;
21067 PyObject *swig_obj[1] ;
21068
21069 if (!args) SWIG_fail;
21070 swig_obj[0] = args;
21071 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21072 if (!SWIG_IsOK(res1)) {
21073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21074 }
21075 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21076 result = (int) ((arg1)->m_y);
21077 resultobj = SWIG_From_int(static_cast< int >(result));
21078 return resultobj;
21079 fail:
21080 return NULL;
21081 }
21082
21083
21084 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21085 PyObject *resultobj = 0;
21086 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21087 bool arg2 ;
21088 void *argp1 = 0 ;
21089 int res1 = 0 ;
21090 bool val2 ;
21091 int ecode2 = 0 ;
21092 PyObject *swig_obj[2] ;
21093
21094 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
21095 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21096 if (!SWIG_IsOK(res1)) {
21097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21098 }
21099 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21100 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21101 if (!SWIG_IsOK(ecode2)) {
21102 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
21103 }
21104 arg2 = static_cast< bool >(val2);
21105 if (arg1) (arg1)->m_leftDown = arg2;
21106
21107 resultobj = SWIG_Py_Void();
21108 return resultobj;
21109 fail:
21110 return NULL;
21111 }
21112
21113
21114 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21115 PyObject *resultobj = 0;
21116 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21117 bool result;
21118 void *argp1 = 0 ;
21119 int res1 = 0 ;
21120 PyObject *swig_obj[1] ;
21121
21122 if (!args) SWIG_fail;
21123 swig_obj[0] = args;
21124 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21125 if (!SWIG_IsOK(res1)) {
21126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21127 }
21128 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21129 result = (bool) ((arg1)->m_leftDown);
21130 {
21131 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21132 }
21133 return resultobj;
21134 fail:
21135 return NULL;
21136 }
21137
21138
21139 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21140 PyObject *resultobj = 0;
21141 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21142 bool arg2 ;
21143 void *argp1 = 0 ;
21144 int res1 = 0 ;
21145 bool val2 ;
21146 int ecode2 = 0 ;
21147 PyObject *swig_obj[2] ;
21148
21149 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
21150 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21151 if (!SWIG_IsOK(res1)) {
21152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21153 }
21154 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21155 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21156 if (!SWIG_IsOK(ecode2)) {
21157 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
21158 }
21159 arg2 = static_cast< bool >(val2);
21160 if (arg1) (arg1)->m_middleDown = arg2;
21161
21162 resultobj = SWIG_Py_Void();
21163 return resultobj;
21164 fail:
21165 return NULL;
21166 }
21167
21168
21169 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21170 PyObject *resultobj = 0;
21171 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21172 bool result;
21173 void *argp1 = 0 ;
21174 int res1 = 0 ;
21175 PyObject *swig_obj[1] ;
21176
21177 if (!args) SWIG_fail;
21178 swig_obj[0] = args;
21179 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21180 if (!SWIG_IsOK(res1)) {
21181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21182 }
21183 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21184 result = (bool) ((arg1)->m_middleDown);
21185 {
21186 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21187 }
21188 return resultobj;
21189 fail:
21190 return NULL;
21191 }
21192
21193
21194 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21195 PyObject *resultobj = 0;
21196 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21197 bool arg2 ;
21198 void *argp1 = 0 ;
21199 int res1 = 0 ;
21200 bool val2 ;
21201 int ecode2 = 0 ;
21202 PyObject *swig_obj[2] ;
21203
21204 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
21205 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21206 if (!SWIG_IsOK(res1)) {
21207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21208 }
21209 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21210 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21211 if (!SWIG_IsOK(ecode2)) {
21212 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
21213 }
21214 arg2 = static_cast< bool >(val2);
21215 if (arg1) (arg1)->m_rightDown = arg2;
21216
21217 resultobj = SWIG_Py_Void();
21218 return resultobj;
21219 fail:
21220 return NULL;
21221 }
21222
21223
21224 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21225 PyObject *resultobj = 0;
21226 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21227 bool result;
21228 void *argp1 = 0 ;
21229 int res1 = 0 ;
21230 PyObject *swig_obj[1] ;
21231
21232 if (!args) SWIG_fail;
21233 swig_obj[0] = args;
21234 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21235 if (!SWIG_IsOK(res1)) {
21236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21237 }
21238 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21239 result = (bool) ((arg1)->m_rightDown);
21240 {
21241 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21242 }
21243 return resultobj;
21244 fail:
21245 return NULL;
21246 }
21247
21248
21249 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21250 PyObject *resultobj = 0;
21251 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21252 bool arg2 ;
21253 void *argp1 = 0 ;
21254 int res1 = 0 ;
21255 bool val2 ;
21256 int ecode2 = 0 ;
21257 PyObject *swig_obj[2] ;
21258
21259 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
21260 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21261 if (!SWIG_IsOK(res1)) {
21262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21263 }
21264 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21265 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21266 if (!SWIG_IsOK(ecode2)) {
21267 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
21268 }
21269 arg2 = static_cast< bool >(val2);
21270 if (arg1) (arg1)->m_controlDown = arg2;
21271
21272 resultobj = SWIG_Py_Void();
21273 return resultobj;
21274 fail:
21275 return NULL;
21276 }
21277
21278
21279 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21280 PyObject *resultobj = 0;
21281 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21282 bool result;
21283 void *argp1 = 0 ;
21284 int res1 = 0 ;
21285 PyObject *swig_obj[1] ;
21286
21287 if (!args) SWIG_fail;
21288 swig_obj[0] = args;
21289 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21290 if (!SWIG_IsOK(res1)) {
21291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21292 }
21293 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21294 result = (bool) ((arg1)->m_controlDown);
21295 {
21296 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21297 }
21298 return resultobj;
21299 fail:
21300 return NULL;
21301 }
21302
21303
21304 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21305 PyObject *resultobj = 0;
21306 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21307 bool arg2 ;
21308 void *argp1 = 0 ;
21309 int res1 = 0 ;
21310 bool val2 ;
21311 int ecode2 = 0 ;
21312 PyObject *swig_obj[2] ;
21313
21314 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
21315 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21316 if (!SWIG_IsOK(res1)) {
21317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21318 }
21319 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21320 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21321 if (!SWIG_IsOK(ecode2)) {
21322 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
21323 }
21324 arg2 = static_cast< bool >(val2);
21325 if (arg1) (arg1)->m_shiftDown = arg2;
21326
21327 resultobj = SWIG_Py_Void();
21328 return resultobj;
21329 fail:
21330 return NULL;
21331 }
21332
21333
21334 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21335 PyObject *resultobj = 0;
21336 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21337 bool result;
21338 void *argp1 = 0 ;
21339 int res1 = 0 ;
21340 PyObject *swig_obj[1] ;
21341
21342 if (!args) SWIG_fail;
21343 swig_obj[0] = args;
21344 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21345 if (!SWIG_IsOK(res1)) {
21346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21347 }
21348 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21349 result = (bool) ((arg1)->m_shiftDown);
21350 {
21351 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21352 }
21353 return resultobj;
21354 fail:
21355 return NULL;
21356 }
21357
21358
21359 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21360 PyObject *resultobj = 0;
21361 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21362 bool arg2 ;
21363 void *argp1 = 0 ;
21364 int res1 = 0 ;
21365 bool val2 ;
21366 int ecode2 = 0 ;
21367 PyObject *swig_obj[2] ;
21368
21369 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
21370 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21371 if (!SWIG_IsOK(res1)) {
21372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21373 }
21374 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21375 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21376 if (!SWIG_IsOK(ecode2)) {
21377 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
21378 }
21379 arg2 = static_cast< bool >(val2);
21380 if (arg1) (arg1)->m_altDown = arg2;
21381
21382 resultobj = SWIG_Py_Void();
21383 return resultobj;
21384 fail:
21385 return NULL;
21386 }
21387
21388
21389 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21390 PyObject *resultobj = 0;
21391 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21392 bool result;
21393 void *argp1 = 0 ;
21394 int res1 = 0 ;
21395 PyObject *swig_obj[1] ;
21396
21397 if (!args) SWIG_fail;
21398 swig_obj[0] = args;
21399 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21400 if (!SWIG_IsOK(res1)) {
21401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21402 }
21403 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21404 result = (bool) ((arg1)->m_altDown);
21405 {
21406 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21407 }
21408 return resultobj;
21409 fail:
21410 return NULL;
21411 }
21412
21413
21414 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21415 PyObject *resultobj = 0;
21416 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21417 bool arg2 ;
21418 void *argp1 = 0 ;
21419 int res1 = 0 ;
21420 bool val2 ;
21421 int ecode2 = 0 ;
21422 PyObject *swig_obj[2] ;
21423
21424 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
21425 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21426 if (!SWIG_IsOK(res1)) {
21427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21428 }
21429 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21430 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21431 if (!SWIG_IsOK(ecode2)) {
21432 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
21433 }
21434 arg2 = static_cast< bool >(val2);
21435 if (arg1) (arg1)->m_metaDown = arg2;
21436
21437 resultobj = SWIG_Py_Void();
21438 return resultobj;
21439 fail:
21440 return NULL;
21441 }
21442
21443
21444 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21445 PyObject *resultobj = 0;
21446 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21447 bool result;
21448 void *argp1 = 0 ;
21449 int res1 = 0 ;
21450 PyObject *swig_obj[1] ;
21451
21452 if (!args) SWIG_fail;
21453 swig_obj[0] = args;
21454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21455 if (!SWIG_IsOK(res1)) {
21456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21457 }
21458 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21459 result = (bool) ((arg1)->m_metaDown);
21460 {
21461 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21462 }
21463 return resultobj;
21464 fail:
21465 return NULL;
21466 }
21467
21468
21469 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_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_wheelRotation_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_wheelRotation_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_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
21488 }
21489 arg2 = static_cast< int >(val2);
21490 if (arg1) (arg1)->m_wheelRotation = arg2;
21491
21492 resultobj = SWIG_Py_Void();
21493 return resultobj;
21494 fail:
21495 return NULL;
21496 }
21497
21498
21499 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_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_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21512 }
21513 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21514 result = (int) ((arg1)->m_wheelRotation);
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_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21523 PyObject *resultobj = 0;
21524 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21525 int arg2 ;
21526 void *argp1 = 0 ;
21527 int res1 = 0 ;
21528 int val2 ;
21529 int ecode2 = 0 ;
21530 PyObject *swig_obj[2] ;
21531
21532 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_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_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21536 }
21537 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21538 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21539 if (!SWIG_IsOK(ecode2)) {
21540 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
21541 }
21542 arg2 = static_cast< int >(val2);
21543 if (arg1) (arg1)->m_wheelDelta = arg2;
21544
21545 resultobj = SWIG_Py_Void();
21546 return resultobj;
21547 fail:
21548 return NULL;
21549 }
21550
21551
21552 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21553 PyObject *resultobj = 0;
21554 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21555 int 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_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21565 }
21566 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21567 result = (int) ((arg1)->m_wheelDelta);
21568 resultobj = SWIG_From_int(static_cast< int >(result));
21569 return resultobj;
21570 fail:
21571 return NULL;
21572 }
21573
21574
21575 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21576 PyObject *resultobj = 0;
21577 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21578 int arg2 ;
21579 void *argp1 = 0 ;
21580 int res1 = 0 ;
21581 int val2 ;
21582 int ecode2 = 0 ;
21583 PyObject *swig_obj[2] ;
21584
21585 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
21586 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21587 if (!SWIG_IsOK(res1)) {
21588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21589 }
21590 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21591 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21592 if (!SWIG_IsOK(ecode2)) {
21593 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
21594 }
21595 arg2 = static_cast< int >(val2);
21596 if (arg1) (arg1)->m_linesPerAction = arg2;
21597
21598 resultobj = SWIG_Py_Void();
21599 return resultobj;
21600 fail:
21601 return NULL;
21602 }
21603
21604
21605 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21606 PyObject *resultobj = 0;
21607 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21608 int result;
21609 void *argp1 = 0 ;
21610 int res1 = 0 ;
21611 PyObject *swig_obj[1] ;
21612
21613 if (!args) SWIG_fail;
21614 swig_obj[0] = args;
21615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21616 if (!SWIG_IsOK(res1)) {
21617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21618 }
21619 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21620 result = (int) ((arg1)->m_linesPerAction);
21621 resultobj = SWIG_From_int(static_cast< int >(result));
21622 return resultobj;
21623 fail:
21624 return NULL;
21625 }
21626
21627
21628 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21629 PyObject *obj;
21630 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21631 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
21632 return SWIG_Py_Void();
21633 }
21634
21635 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21636 return SWIG_Python_InitShadowInstance(args);
21637 }
21638
21639 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21640 PyObject *resultobj = 0;
21641 int arg1 = (int) 0 ;
21642 int arg2 = (int) 0 ;
21643 wxSetCursorEvent *result = 0 ;
21644 int val1 ;
21645 int ecode1 = 0 ;
21646 int val2 ;
21647 int ecode2 = 0 ;
21648 PyObject * obj0 = 0 ;
21649 PyObject * obj1 = 0 ;
21650 char * kwnames[] = {
21651 (char *) "x",(char *) "y", NULL
21652 };
21653
21654 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21655 if (obj0) {
21656 ecode1 = SWIG_AsVal_int(obj0, &val1);
21657 if (!SWIG_IsOK(ecode1)) {
21658 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
21659 }
21660 arg1 = static_cast< int >(val1);
21661 }
21662 if (obj1) {
21663 ecode2 = SWIG_AsVal_int(obj1, &val2);
21664 if (!SWIG_IsOK(ecode2)) {
21665 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
21666 }
21667 arg2 = static_cast< int >(val2);
21668 }
21669 {
21670 PyThreadState* __tstate = wxPyBeginAllowThreads();
21671 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
21672 wxPyEndAllowThreads(__tstate);
21673 if (PyErr_Occurred()) SWIG_fail;
21674 }
21675 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
21676 return resultobj;
21677 fail:
21678 return NULL;
21679 }
21680
21681
21682 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21683 PyObject *resultobj = 0;
21684 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21685 int result;
21686 void *argp1 = 0 ;
21687 int res1 = 0 ;
21688 PyObject *swig_obj[1] ;
21689
21690 if (!args) SWIG_fail;
21691 swig_obj[0] = args;
21692 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21693 if (!SWIG_IsOK(res1)) {
21694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21695 }
21696 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21697 {
21698 PyThreadState* __tstate = wxPyBeginAllowThreads();
21699 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
21700 wxPyEndAllowThreads(__tstate);
21701 if (PyErr_Occurred()) SWIG_fail;
21702 }
21703 resultobj = SWIG_From_int(static_cast< int >(result));
21704 return resultobj;
21705 fail:
21706 return NULL;
21707 }
21708
21709
21710 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21711 PyObject *resultobj = 0;
21712 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21713 int result;
21714 void *argp1 = 0 ;
21715 int res1 = 0 ;
21716 PyObject *swig_obj[1] ;
21717
21718 if (!args) SWIG_fail;
21719 swig_obj[0] = args;
21720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21721 if (!SWIG_IsOK(res1)) {
21722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21723 }
21724 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21725 {
21726 PyThreadState* __tstate = wxPyBeginAllowThreads();
21727 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
21728 wxPyEndAllowThreads(__tstate);
21729 if (PyErr_Occurred()) SWIG_fail;
21730 }
21731 resultobj = SWIG_From_int(static_cast< int >(result));
21732 return resultobj;
21733 fail:
21734 return NULL;
21735 }
21736
21737
21738 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21739 PyObject *resultobj = 0;
21740 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21741 wxCursor *arg2 = 0 ;
21742 void *argp1 = 0 ;
21743 int res1 = 0 ;
21744 void *argp2 = 0 ;
21745 int res2 = 0 ;
21746 PyObject * obj0 = 0 ;
21747 PyObject * obj1 = 0 ;
21748 char * kwnames[] = {
21749 (char *) "self",(char *) "cursor", NULL
21750 };
21751
21752 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
21753 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21754 if (!SWIG_IsOK(res1)) {
21755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
21756 }
21757 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21758 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
21759 if (!SWIG_IsOK(res2)) {
21760 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21761 }
21762 if (!argp2) {
21763 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21764 }
21765 arg2 = reinterpret_cast< wxCursor * >(argp2);
21766 {
21767 PyThreadState* __tstate = wxPyBeginAllowThreads();
21768 (arg1)->SetCursor((wxCursor const &)*arg2);
21769 wxPyEndAllowThreads(__tstate);
21770 if (PyErr_Occurred()) SWIG_fail;
21771 }
21772 resultobj = SWIG_Py_Void();
21773 return resultobj;
21774 fail:
21775 return NULL;
21776 }
21777
21778
21779 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21780 PyObject *resultobj = 0;
21781 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21782 wxCursor *result = 0 ;
21783 void *argp1 = 0 ;
21784 int res1 = 0 ;
21785 PyObject *swig_obj[1] ;
21786
21787 if (!args) SWIG_fail;
21788 swig_obj[0] = args;
21789 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21790 if (!SWIG_IsOK(res1)) {
21791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21792 }
21793 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21794 {
21795 PyThreadState* __tstate = wxPyBeginAllowThreads();
21796 {
21797 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
21798 result = (wxCursor *) &_result_ref;
21799 }
21800 wxPyEndAllowThreads(__tstate);
21801 if (PyErr_Occurred()) SWIG_fail;
21802 }
21803 {
21804 wxCursor* resultptr = new wxCursor(*result);
21805 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
21806 }
21807 return resultobj;
21808 fail:
21809 return NULL;
21810 }
21811
21812
21813 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21814 PyObject *resultobj = 0;
21815 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21816 bool result;
21817 void *argp1 = 0 ;
21818 int res1 = 0 ;
21819 PyObject *swig_obj[1] ;
21820
21821 if (!args) SWIG_fail;
21822 swig_obj[0] = args;
21823 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21824 if (!SWIG_IsOK(res1)) {
21825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21826 }
21827 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21828 {
21829 PyThreadState* __tstate = wxPyBeginAllowThreads();
21830 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
21831 wxPyEndAllowThreads(__tstate);
21832 if (PyErr_Occurred()) SWIG_fail;
21833 }
21834 {
21835 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21836 }
21837 return resultobj;
21838 fail:
21839 return NULL;
21840 }
21841
21842
21843 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21844 PyObject *obj;
21845 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21846 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
21847 return SWIG_Py_Void();
21848 }
21849
21850 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21851 return SWIG_Python_InitShadowInstance(args);
21852 }
21853
21854 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21855 PyObject *resultobj = 0;
21856 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21857 wxKeyEvent *result = 0 ;
21858 int val1 ;
21859 int ecode1 = 0 ;
21860 PyObject * obj0 = 0 ;
21861 char * kwnames[] = {
21862 (char *) "eventType", NULL
21863 };
21864
21865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
21866 if (obj0) {
21867 ecode1 = SWIG_AsVal_int(obj0, &val1);
21868 if (!SWIG_IsOK(ecode1)) {
21869 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
21870 }
21871 arg1 = static_cast< wxEventType >(val1);
21872 }
21873 {
21874 PyThreadState* __tstate = wxPyBeginAllowThreads();
21875 result = (wxKeyEvent *)new wxKeyEvent(arg1);
21876 wxPyEndAllowThreads(__tstate);
21877 if (PyErr_Occurred()) SWIG_fail;
21878 }
21879 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
21880 return resultobj;
21881 fail:
21882 return NULL;
21883 }
21884
21885
21886 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21887 PyObject *resultobj = 0;
21888 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21889 int result;
21890 void *argp1 = 0 ;
21891 int res1 = 0 ;
21892 PyObject *swig_obj[1] ;
21893
21894 if (!args) SWIG_fail;
21895 swig_obj[0] = args;
21896 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21897 if (!SWIG_IsOK(res1)) {
21898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21899 }
21900 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21901 {
21902 PyThreadState* __tstate = wxPyBeginAllowThreads();
21903 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
21904 wxPyEndAllowThreads(__tstate);
21905 if (PyErr_Occurred()) SWIG_fail;
21906 }
21907 resultobj = SWIG_From_int(static_cast< int >(result));
21908 return resultobj;
21909 fail:
21910 return NULL;
21911 }
21912
21913
21914 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21915 PyObject *resultobj = 0;
21916 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21917 bool result;
21918 void *argp1 = 0 ;
21919 int res1 = 0 ;
21920 PyObject *swig_obj[1] ;
21921
21922 if (!args) SWIG_fail;
21923 swig_obj[0] = args;
21924 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21925 if (!SWIG_IsOK(res1)) {
21926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21927 }
21928 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21929 {
21930 PyThreadState* __tstate = wxPyBeginAllowThreads();
21931 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
21932 wxPyEndAllowThreads(__tstate);
21933 if (PyErr_Occurred()) SWIG_fail;
21934 }
21935 {
21936 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21937 }
21938 return resultobj;
21939 fail:
21940 return NULL;
21941 }
21942
21943
21944 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21945 PyObject *resultobj = 0;
21946 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21947 bool result;
21948 void *argp1 = 0 ;
21949 int res1 = 0 ;
21950 PyObject *swig_obj[1] ;
21951
21952 if (!args) SWIG_fail;
21953 swig_obj[0] = args;
21954 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21955 if (!SWIG_IsOK(res1)) {
21956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21957 }
21958 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21959 {
21960 PyThreadState* __tstate = wxPyBeginAllowThreads();
21961 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
21962 wxPyEndAllowThreads(__tstate);
21963 if (PyErr_Occurred()) SWIG_fail;
21964 }
21965 {
21966 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21967 }
21968 return resultobj;
21969 fail:
21970 return NULL;
21971 }
21972
21973
21974 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21975 PyObject *resultobj = 0;
21976 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21977 bool result;
21978 void *argp1 = 0 ;
21979 int res1 = 0 ;
21980 PyObject *swig_obj[1] ;
21981
21982 if (!args) SWIG_fail;
21983 swig_obj[0] = args;
21984 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21985 if (!SWIG_IsOK(res1)) {
21986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21987 }
21988 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21989 {
21990 PyThreadState* __tstate = wxPyBeginAllowThreads();
21991 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
21992 wxPyEndAllowThreads(__tstate);
21993 if (PyErr_Occurred()) SWIG_fail;
21994 }
21995 {
21996 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21997 }
21998 return resultobj;
21999 fail:
22000 return NULL;
22001 }
22002
22003
22004 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22005 PyObject *resultobj = 0;
22006 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22007 bool result;
22008 void *argp1 = 0 ;
22009 int res1 = 0 ;
22010 PyObject *swig_obj[1] ;
22011
22012 if (!args) SWIG_fail;
22013 swig_obj[0] = args;
22014 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22015 if (!SWIG_IsOK(res1)) {
22016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22017 }
22018 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22019 {
22020 PyThreadState* __tstate = wxPyBeginAllowThreads();
22021 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
22022 wxPyEndAllowThreads(__tstate);
22023 if (PyErr_Occurred()) SWIG_fail;
22024 }
22025 {
22026 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22027 }
22028 return resultobj;
22029 fail:
22030 return NULL;
22031 }
22032
22033
22034 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22035 PyObject *resultobj = 0;
22036 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22037 bool result;
22038 void *argp1 = 0 ;
22039 int res1 = 0 ;
22040 PyObject *swig_obj[1] ;
22041
22042 if (!args) SWIG_fail;
22043 swig_obj[0] = args;
22044 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22045 if (!SWIG_IsOK(res1)) {
22046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22047 }
22048 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22049 {
22050 PyThreadState* __tstate = wxPyBeginAllowThreads();
22051 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
22052 wxPyEndAllowThreads(__tstate);
22053 if (PyErr_Occurred()) SWIG_fail;
22054 }
22055 {
22056 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22057 }
22058 return resultobj;
22059 fail:
22060 return NULL;
22061 }
22062
22063
22064 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22065 PyObject *resultobj = 0;
22066 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22067 bool result;
22068 void *argp1 = 0 ;
22069 int res1 = 0 ;
22070 PyObject *swig_obj[1] ;
22071
22072 if (!args) SWIG_fail;
22073 swig_obj[0] = args;
22074 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22075 if (!SWIG_IsOK(res1)) {
22076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22077 }
22078 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22079 {
22080 PyThreadState* __tstate = wxPyBeginAllowThreads();
22081 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
22082 wxPyEndAllowThreads(__tstate);
22083 if (PyErr_Occurred()) SWIG_fail;
22084 }
22085 {
22086 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22087 }
22088 return resultobj;
22089 fail:
22090 return NULL;
22091 }
22092
22093
22094 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22095 PyObject *resultobj = 0;
22096 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22097 int result;
22098 void *argp1 = 0 ;
22099 int res1 = 0 ;
22100 PyObject *swig_obj[1] ;
22101
22102 if (!args) SWIG_fail;
22103 swig_obj[0] = args;
22104 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22105 if (!SWIG_IsOK(res1)) {
22106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22107 }
22108 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22109 {
22110 PyThreadState* __tstate = wxPyBeginAllowThreads();
22111 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
22112 wxPyEndAllowThreads(__tstate);
22113 if (PyErr_Occurred()) SWIG_fail;
22114 }
22115 resultobj = SWIG_From_int(static_cast< int >(result));
22116 return resultobj;
22117 fail:
22118 return NULL;
22119 }
22120
22121
22122 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22123 PyObject *resultobj = 0;
22124 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22125 int result;
22126 void *argp1 = 0 ;
22127 int res1 = 0 ;
22128 PyObject *swig_obj[1] ;
22129
22130 if (!args) SWIG_fail;
22131 swig_obj[0] = args;
22132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22133 if (!SWIG_IsOK(res1)) {
22134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22135 }
22136 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22137 {
22138 PyThreadState* __tstate = wxPyBeginAllowThreads();
22139 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
22140 wxPyEndAllowThreads(__tstate);
22141 if (PyErr_Occurred()) SWIG_fail;
22142 }
22143 resultobj = SWIG_From_int(static_cast< int >(result));
22144 return resultobj;
22145 fail:
22146 return NULL;
22147 }
22148
22149
22150 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22151 PyObject *resultobj = 0;
22152 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22153 unsigned int result;
22154 void *argp1 = 0 ;
22155 int res1 = 0 ;
22156 PyObject *swig_obj[1] ;
22157
22158 if (!args) SWIG_fail;
22159 swig_obj[0] = args;
22160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22161 if (!SWIG_IsOK(res1)) {
22162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22163 }
22164 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22165 {
22166 PyThreadState* __tstate = wxPyBeginAllowThreads();
22167 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
22168 wxPyEndAllowThreads(__tstate);
22169 if (PyErr_Occurred()) SWIG_fail;
22170 }
22171 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22172 return resultobj;
22173 fail:
22174 return NULL;
22175 }
22176
22177
22178 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22179 PyObject *resultobj = 0;
22180 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22181 unsigned int result;
22182 void *argp1 = 0 ;
22183 int res1 = 0 ;
22184 PyObject *swig_obj[1] ;
22185
22186 if (!args) SWIG_fail;
22187 swig_obj[0] = args;
22188 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22189 if (!SWIG_IsOK(res1)) {
22190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22191 }
22192 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22193 {
22194 PyThreadState* __tstate = wxPyBeginAllowThreads();
22195 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
22196 wxPyEndAllowThreads(__tstate);
22197 if (PyErr_Occurred()) SWIG_fail;
22198 }
22199 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22200 return resultobj;
22201 fail:
22202 return NULL;
22203 }
22204
22205
22206 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22207 PyObject *resultobj = 0;
22208 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22209 wxPoint result;
22210 void *argp1 = 0 ;
22211 int res1 = 0 ;
22212 PyObject *swig_obj[1] ;
22213
22214 if (!args) SWIG_fail;
22215 swig_obj[0] = args;
22216 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22217 if (!SWIG_IsOK(res1)) {
22218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22219 }
22220 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22221 {
22222 PyThreadState* __tstate = wxPyBeginAllowThreads();
22223 result = (arg1)->GetPosition();
22224 wxPyEndAllowThreads(__tstate);
22225 if (PyErr_Occurred()) SWIG_fail;
22226 }
22227 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
22228 return resultobj;
22229 fail:
22230 return NULL;
22231 }
22232
22233
22234 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22235 PyObject *resultobj = 0;
22236 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22237 long *arg2 = (long *) 0 ;
22238 long *arg3 = (long *) 0 ;
22239 void *argp1 = 0 ;
22240 int res1 = 0 ;
22241 long temp2 ;
22242 int res2 = SWIG_TMPOBJ ;
22243 long temp3 ;
22244 int res3 = SWIG_TMPOBJ ;
22245 PyObject *swig_obj[1] ;
22246
22247 arg2 = &temp2;
22248 arg3 = &temp3;
22249 if (!args) SWIG_fail;
22250 swig_obj[0] = args;
22251 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22252 if (!SWIG_IsOK(res1)) {
22253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22254 }
22255 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22256 {
22257 PyThreadState* __tstate = wxPyBeginAllowThreads();
22258 (arg1)->GetPosition(arg2,arg3);
22259 wxPyEndAllowThreads(__tstate);
22260 if (PyErr_Occurred()) SWIG_fail;
22261 }
22262 resultobj = SWIG_Py_Void();
22263 if (SWIG_IsTmpObj(res2)) {
22264 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
22265 } else {
22266 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22267 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
22268 }
22269 if (SWIG_IsTmpObj(res3)) {
22270 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
22271 } else {
22272 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22273 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
22274 }
22275 return resultobj;
22276 fail:
22277 return NULL;
22278 }
22279
22280
22281 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22282 PyObject *resultobj = 0;
22283 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22284 int result;
22285 void *argp1 = 0 ;
22286 int res1 = 0 ;
22287 PyObject *swig_obj[1] ;
22288
22289 if (!args) SWIG_fail;
22290 swig_obj[0] = args;
22291 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22292 if (!SWIG_IsOK(res1)) {
22293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22294 }
22295 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22296 {
22297 PyThreadState* __tstate = wxPyBeginAllowThreads();
22298 result = (int)((wxKeyEvent const *)arg1)->GetX();
22299 wxPyEndAllowThreads(__tstate);
22300 if (PyErr_Occurred()) SWIG_fail;
22301 }
22302 resultobj = SWIG_From_int(static_cast< int >(result));
22303 return resultobj;
22304 fail:
22305 return NULL;
22306 }
22307
22308
22309 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22310 PyObject *resultobj = 0;
22311 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22312 int result;
22313 void *argp1 = 0 ;
22314 int res1 = 0 ;
22315 PyObject *swig_obj[1] ;
22316
22317 if (!args) SWIG_fail;
22318 swig_obj[0] = args;
22319 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22320 if (!SWIG_IsOK(res1)) {
22321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22322 }
22323 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22324 {
22325 PyThreadState* __tstate = wxPyBeginAllowThreads();
22326 result = (int)((wxKeyEvent const *)arg1)->GetY();
22327 wxPyEndAllowThreads(__tstate);
22328 if (PyErr_Occurred()) SWIG_fail;
22329 }
22330 resultobj = SWIG_From_int(static_cast< int >(result));
22331 return resultobj;
22332 fail:
22333 return NULL;
22334 }
22335
22336
22337 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22338 PyObject *resultobj = 0;
22339 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22340 int arg2 ;
22341 void *argp1 = 0 ;
22342 int res1 = 0 ;
22343 int val2 ;
22344 int ecode2 = 0 ;
22345 PyObject *swig_obj[2] ;
22346
22347 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
22348 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22349 if (!SWIG_IsOK(res1)) {
22350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22351 }
22352 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22353 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22354 if (!SWIG_IsOK(ecode2)) {
22355 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
22356 }
22357 arg2 = static_cast< int >(val2);
22358 if (arg1) (arg1)->m_x = arg2;
22359
22360 resultobj = SWIG_Py_Void();
22361 return resultobj;
22362 fail:
22363 return NULL;
22364 }
22365
22366
22367 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22368 PyObject *resultobj = 0;
22369 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22370 int result;
22371 void *argp1 = 0 ;
22372 int res1 = 0 ;
22373 PyObject *swig_obj[1] ;
22374
22375 if (!args) SWIG_fail;
22376 swig_obj[0] = args;
22377 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22378 if (!SWIG_IsOK(res1)) {
22379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22380 }
22381 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22382 result = (int) ((arg1)->m_x);
22383 resultobj = SWIG_From_int(static_cast< int >(result));
22384 return resultobj;
22385 fail:
22386 return NULL;
22387 }
22388
22389
22390 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22391 PyObject *resultobj = 0;
22392 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22393 int arg2 ;
22394 void *argp1 = 0 ;
22395 int res1 = 0 ;
22396 int val2 ;
22397 int ecode2 = 0 ;
22398 PyObject *swig_obj[2] ;
22399
22400 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
22401 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22402 if (!SWIG_IsOK(res1)) {
22403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22404 }
22405 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22406 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22407 if (!SWIG_IsOK(ecode2)) {
22408 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
22409 }
22410 arg2 = static_cast< int >(val2);
22411 if (arg1) (arg1)->m_y = arg2;
22412
22413 resultobj = SWIG_Py_Void();
22414 return resultobj;
22415 fail:
22416 return NULL;
22417 }
22418
22419
22420 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22421 PyObject *resultobj = 0;
22422 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22423 int result;
22424 void *argp1 = 0 ;
22425 int res1 = 0 ;
22426 PyObject *swig_obj[1] ;
22427
22428 if (!args) SWIG_fail;
22429 swig_obj[0] = args;
22430 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22431 if (!SWIG_IsOK(res1)) {
22432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22433 }
22434 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22435 result = (int) ((arg1)->m_y);
22436 resultobj = SWIG_From_int(static_cast< int >(result));
22437 return resultobj;
22438 fail:
22439 return NULL;
22440 }
22441
22442
22443 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22444 PyObject *resultobj = 0;
22445 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22446 long arg2 ;
22447 void *argp1 = 0 ;
22448 int res1 = 0 ;
22449 long val2 ;
22450 int ecode2 = 0 ;
22451 PyObject *swig_obj[2] ;
22452
22453 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
22454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22455 if (!SWIG_IsOK(res1)) {
22456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22457 }
22458 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22459 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
22460 if (!SWIG_IsOK(ecode2)) {
22461 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
22462 }
22463 arg2 = static_cast< long >(val2);
22464 if (arg1) (arg1)->m_keyCode = arg2;
22465
22466 resultobj = SWIG_Py_Void();
22467 return resultobj;
22468 fail:
22469 return NULL;
22470 }
22471
22472
22473 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22474 PyObject *resultobj = 0;
22475 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22476 long result;
22477 void *argp1 = 0 ;
22478 int res1 = 0 ;
22479 PyObject *swig_obj[1] ;
22480
22481 if (!args) SWIG_fail;
22482 swig_obj[0] = args;
22483 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22484 if (!SWIG_IsOK(res1)) {
22485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22486 }
22487 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22488 result = (long) ((arg1)->m_keyCode);
22489 resultobj = SWIG_From_long(static_cast< long >(result));
22490 return resultobj;
22491 fail:
22492 return NULL;
22493 }
22494
22495
22496 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22497 PyObject *resultobj = 0;
22498 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22499 bool arg2 ;
22500 void *argp1 = 0 ;
22501 int res1 = 0 ;
22502 bool val2 ;
22503 int ecode2 = 0 ;
22504 PyObject *swig_obj[2] ;
22505
22506 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
22507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22508 if (!SWIG_IsOK(res1)) {
22509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22510 }
22511 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22512 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22513 if (!SWIG_IsOK(ecode2)) {
22514 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
22515 }
22516 arg2 = static_cast< bool >(val2);
22517 if (arg1) (arg1)->m_controlDown = arg2;
22518
22519 resultobj = SWIG_Py_Void();
22520 return resultobj;
22521 fail:
22522 return NULL;
22523 }
22524
22525
22526 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22527 PyObject *resultobj = 0;
22528 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22529 bool result;
22530 void *argp1 = 0 ;
22531 int res1 = 0 ;
22532 PyObject *swig_obj[1] ;
22533
22534 if (!args) SWIG_fail;
22535 swig_obj[0] = args;
22536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22537 if (!SWIG_IsOK(res1)) {
22538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22539 }
22540 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22541 result = (bool) ((arg1)->m_controlDown);
22542 {
22543 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22544 }
22545 return resultobj;
22546 fail:
22547 return NULL;
22548 }
22549
22550
22551 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22552 PyObject *resultobj = 0;
22553 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22554 bool arg2 ;
22555 void *argp1 = 0 ;
22556 int res1 = 0 ;
22557 bool val2 ;
22558 int ecode2 = 0 ;
22559 PyObject *swig_obj[2] ;
22560
22561 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
22562 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22563 if (!SWIG_IsOK(res1)) {
22564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22565 }
22566 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22567 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22568 if (!SWIG_IsOK(ecode2)) {
22569 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
22570 }
22571 arg2 = static_cast< bool >(val2);
22572 if (arg1) (arg1)->m_shiftDown = arg2;
22573
22574 resultobj = SWIG_Py_Void();
22575 return resultobj;
22576 fail:
22577 return NULL;
22578 }
22579
22580
22581 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22582 PyObject *resultobj = 0;
22583 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22584 bool result;
22585 void *argp1 = 0 ;
22586 int res1 = 0 ;
22587 PyObject *swig_obj[1] ;
22588
22589 if (!args) SWIG_fail;
22590 swig_obj[0] = args;
22591 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22592 if (!SWIG_IsOK(res1)) {
22593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22594 }
22595 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22596 result = (bool) ((arg1)->m_shiftDown);
22597 {
22598 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22599 }
22600 return resultobj;
22601 fail:
22602 return NULL;
22603 }
22604
22605
22606 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22607 PyObject *resultobj = 0;
22608 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22609 bool arg2 ;
22610 void *argp1 = 0 ;
22611 int res1 = 0 ;
22612 bool val2 ;
22613 int ecode2 = 0 ;
22614 PyObject *swig_obj[2] ;
22615
22616 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
22617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22618 if (!SWIG_IsOK(res1)) {
22619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22620 }
22621 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22622 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22623 if (!SWIG_IsOK(ecode2)) {
22624 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
22625 }
22626 arg2 = static_cast< bool >(val2);
22627 if (arg1) (arg1)->m_altDown = arg2;
22628
22629 resultobj = SWIG_Py_Void();
22630 return resultobj;
22631 fail:
22632 return NULL;
22633 }
22634
22635
22636 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22637 PyObject *resultobj = 0;
22638 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22639 bool result;
22640 void *argp1 = 0 ;
22641 int res1 = 0 ;
22642 PyObject *swig_obj[1] ;
22643
22644 if (!args) SWIG_fail;
22645 swig_obj[0] = args;
22646 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22647 if (!SWIG_IsOK(res1)) {
22648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22649 }
22650 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22651 result = (bool) ((arg1)->m_altDown);
22652 {
22653 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22654 }
22655 return resultobj;
22656 fail:
22657 return NULL;
22658 }
22659
22660
22661 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22662 PyObject *resultobj = 0;
22663 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22664 bool arg2 ;
22665 void *argp1 = 0 ;
22666 int res1 = 0 ;
22667 bool val2 ;
22668 int ecode2 = 0 ;
22669 PyObject *swig_obj[2] ;
22670
22671 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
22672 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22673 if (!SWIG_IsOK(res1)) {
22674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22675 }
22676 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22677 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22678 if (!SWIG_IsOK(ecode2)) {
22679 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
22680 }
22681 arg2 = static_cast< bool >(val2);
22682 if (arg1) (arg1)->m_metaDown = arg2;
22683
22684 resultobj = SWIG_Py_Void();
22685 return resultobj;
22686 fail:
22687 return NULL;
22688 }
22689
22690
22691 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22692 PyObject *resultobj = 0;
22693 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22694 bool result;
22695 void *argp1 = 0 ;
22696 int res1 = 0 ;
22697 PyObject *swig_obj[1] ;
22698
22699 if (!args) SWIG_fail;
22700 swig_obj[0] = args;
22701 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22702 if (!SWIG_IsOK(res1)) {
22703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22704 }
22705 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22706 result = (bool) ((arg1)->m_metaDown);
22707 {
22708 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22709 }
22710 return resultobj;
22711 fail:
22712 return NULL;
22713 }
22714
22715
22716 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22717 PyObject *resultobj = 0;
22718 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22719 bool arg2 ;
22720 void *argp1 = 0 ;
22721 int res1 = 0 ;
22722 bool val2 ;
22723 int ecode2 = 0 ;
22724 PyObject *swig_obj[2] ;
22725
22726 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
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_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22730 }
22731 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22732 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22733 if (!SWIG_IsOK(ecode2)) {
22734 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
22735 }
22736 arg2 = static_cast< bool >(val2);
22737 if (arg1) (arg1)->m_scanCode = arg2;
22738
22739 resultobj = SWIG_Py_Void();
22740 return resultobj;
22741 fail:
22742 return NULL;
22743 }
22744
22745
22746 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22747 PyObject *resultobj = 0;
22748 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22749 bool result;
22750 void *argp1 = 0 ;
22751 int res1 = 0 ;
22752 PyObject *swig_obj[1] ;
22753
22754 if (!args) SWIG_fail;
22755 swig_obj[0] = args;
22756 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22757 if (!SWIG_IsOK(res1)) {
22758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22759 }
22760 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22761 result = (bool) ((arg1)->m_scanCode);
22762 {
22763 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22764 }
22765 return resultobj;
22766 fail:
22767 return NULL;
22768 }
22769
22770
22771 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22772 PyObject *resultobj = 0;
22773 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22774 unsigned int arg2 ;
22775 void *argp1 = 0 ;
22776 int res1 = 0 ;
22777 unsigned int val2 ;
22778 int ecode2 = 0 ;
22779 PyObject *swig_obj[2] ;
22780
22781 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
22782 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22783 if (!SWIG_IsOK(res1)) {
22784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22785 }
22786 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22787 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
22788 if (!SWIG_IsOK(ecode2)) {
22789 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
22790 }
22791 arg2 = static_cast< unsigned int >(val2);
22792 if (arg1) (arg1)->m_rawCode = arg2;
22793
22794 resultobj = SWIG_Py_Void();
22795 return resultobj;
22796 fail:
22797 return NULL;
22798 }
22799
22800
22801 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22802 PyObject *resultobj = 0;
22803 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22804 unsigned int result;
22805 void *argp1 = 0 ;
22806 int res1 = 0 ;
22807 PyObject *swig_obj[1] ;
22808
22809 if (!args) SWIG_fail;
22810 swig_obj[0] = args;
22811 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22812 if (!SWIG_IsOK(res1)) {
22813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22814 }
22815 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22816 result = (unsigned int) ((arg1)->m_rawCode);
22817 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22818 return resultobj;
22819 fail:
22820 return NULL;
22821 }
22822
22823
22824 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22825 PyObject *resultobj = 0;
22826 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22827 unsigned int arg2 ;
22828 void *argp1 = 0 ;
22829 int res1 = 0 ;
22830 unsigned int val2 ;
22831 int ecode2 = 0 ;
22832 PyObject *swig_obj[2] ;
22833
22834 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
22835 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22836 if (!SWIG_IsOK(res1)) {
22837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22838 }
22839 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22840 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
22841 if (!SWIG_IsOK(ecode2)) {
22842 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
22843 }
22844 arg2 = static_cast< unsigned int >(val2);
22845 if (arg1) (arg1)->m_rawFlags = arg2;
22846
22847 resultobj = SWIG_Py_Void();
22848 return resultobj;
22849 fail:
22850 return NULL;
22851 }
22852
22853
22854 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22855 PyObject *resultobj = 0;
22856 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22857 unsigned int result;
22858 void *argp1 = 0 ;
22859 int res1 = 0 ;
22860 PyObject *swig_obj[1] ;
22861
22862 if (!args) SWIG_fail;
22863 swig_obj[0] = args;
22864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22865 if (!SWIG_IsOK(res1)) {
22866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22867 }
22868 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22869 result = (unsigned int) ((arg1)->m_rawFlags);
22870 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22871 return resultobj;
22872 fail:
22873 return NULL;
22874 }
22875
22876
22877 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22878 PyObject *obj;
22879 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22880 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
22881 return SWIG_Py_Void();
22882 }
22883
22884 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22885 return SWIG_Python_InitShadowInstance(args);
22886 }
22887
22888 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22889 PyObject *resultobj = 0;
22890 wxSize const &arg1_defvalue = wxDefaultSize ;
22891 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
22892 int arg2 = (int) 0 ;
22893 wxSizeEvent *result = 0 ;
22894 wxSize temp1 ;
22895 int val2 ;
22896 int ecode2 = 0 ;
22897 PyObject * obj0 = 0 ;
22898 PyObject * obj1 = 0 ;
22899 char * kwnames[] = {
22900 (char *) "sz",(char *) "winid", NULL
22901 };
22902
22903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
22904 if (obj0) {
22905 {
22906 arg1 = &temp1;
22907 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
22908 }
22909 }
22910 if (obj1) {
22911 ecode2 = SWIG_AsVal_int(obj1, &val2);
22912 if (!SWIG_IsOK(ecode2)) {
22913 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
22914 }
22915 arg2 = static_cast< int >(val2);
22916 }
22917 {
22918 PyThreadState* __tstate = wxPyBeginAllowThreads();
22919 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
22920 wxPyEndAllowThreads(__tstate);
22921 if (PyErr_Occurred()) SWIG_fail;
22922 }
22923 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
22924 return resultobj;
22925 fail:
22926 return NULL;
22927 }
22928
22929
22930 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22931 PyObject *resultobj = 0;
22932 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
22933 wxSize result;
22934 void *argp1 = 0 ;
22935 int res1 = 0 ;
22936 PyObject *swig_obj[1] ;
22937
22938 if (!args) SWIG_fail;
22939 swig_obj[0] = args;
22940 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
22941 if (!SWIG_IsOK(res1)) {
22942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
22943 }
22944 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
22945 {
22946 PyThreadState* __tstate = wxPyBeginAllowThreads();
22947 result = ((wxSizeEvent const *)arg1)->GetSize();
22948 wxPyEndAllowThreads(__tstate);
22949 if (PyErr_Occurred()) SWIG_fail;
22950 }
22951 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
22952 return resultobj;
22953 fail:
22954 return NULL;
22955 }
22956
22957
22958 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22959 PyObject *resultobj = 0;
22960 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
22961 wxRect result;
22962 void *argp1 = 0 ;
22963 int res1 = 0 ;
22964 PyObject *swig_obj[1] ;
22965
22966 if (!args) SWIG_fail;
22967 swig_obj[0] = args;
22968 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
22969 if (!SWIG_IsOK(res1)) {
22970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
22971 }
22972 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
22973 {
22974 PyThreadState* __tstate = wxPyBeginAllowThreads();
22975 result = ((wxSizeEvent const *)arg1)->GetRect();
22976 wxPyEndAllowThreads(__tstate);
22977 if (PyErr_Occurred()) SWIG_fail;
22978 }
22979 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
22980 return resultobj;
22981 fail:
22982 return NULL;
22983 }
22984
22985
22986 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22987 PyObject *resultobj = 0;
22988 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
22989 wxRect arg2 ;
22990 void *argp1 = 0 ;
22991 int res1 = 0 ;
22992 void *argp2 ;
22993 int res2 = 0 ;
22994 PyObject * obj0 = 0 ;
22995 PyObject * obj1 = 0 ;
22996 char * kwnames[] = {
22997 (char *) "self",(char *) "rect", NULL
22998 };
22999
23000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23001 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23002 if (!SWIG_IsOK(res1)) {
23003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23004 }
23005 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23006 {
23007 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
23008 if (!SWIG_IsOK(res2)) {
23009 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23010 }
23011 if (!argp2) {
23012 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23013 } else {
23014 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
23015 arg2 = *temp;
23016 if (SWIG_IsNewObj(res2)) delete temp;
23017 }
23018 }
23019 {
23020 PyThreadState* __tstate = wxPyBeginAllowThreads();
23021 (arg1)->SetRect(arg2);
23022 wxPyEndAllowThreads(__tstate);
23023 if (PyErr_Occurred()) SWIG_fail;
23024 }
23025 resultobj = SWIG_Py_Void();
23026 return resultobj;
23027 fail:
23028 return NULL;
23029 }
23030
23031
23032 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23033 PyObject *resultobj = 0;
23034 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23035 wxSize arg2 ;
23036 void *argp1 = 0 ;
23037 int res1 = 0 ;
23038 void *argp2 ;
23039 int res2 = 0 ;
23040 PyObject * obj0 = 0 ;
23041 PyObject * obj1 = 0 ;
23042 char * kwnames[] = {
23043 (char *) "self",(char *) "size", NULL
23044 };
23045
23046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
23047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23048 if (!SWIG_IsOK(res1)) {
23049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23050 }
23051 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23052 {
23053 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
23054 if (!SWIG_IsOK(res2)) {
23055 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23056 }
23057 if (!argp2) {
23058 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23059 } else {
23060 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
23061 arg2 = *temp;
23062 if (SWIG_IsNewObj(res2)) delete temp;
23063 }
23064 }
23065 {
23066 PyThreadState* __tstate = wxPyBeginAllowThreads();
23067 wxSizeEvent_SetSize(arg1,arg2);
23068 wxPyEndAllowThreads(__tstate);
23069 if (PyErr_Occurred()) SWIG_fail;
23070 }
23071 resultobj = SWIG_Py_Void();
23072 return resultobj;
23073 fail:
23074 return NULL;
23075 }
23076
23077
23078 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23079 PyObject *resultobj = 0;
23080 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23081 wxSize *arg2 = (wxSize *) 0 ;
23082 void *argp1 = 0 ;
23083 int res1 = 0 ;
23084 void *argp2 = 0 ;
23085 int res2 = 0 ;
23086 PyObject *swig_obj[2] ;
23087
23088 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
23089 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23090 if (!SWIG_IsOK(res1)) {
23091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23092 }
23093 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23094 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
23095 if (!SWIG_IsOK(res2)) {
23096 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
23097 }
23098 arg2 = reinterpret_cast< wxSize * >(argp2);
23099 if (arg1) (arg1)->m_size = *arg2;
23100
23101 resultobj = SWIG_Py_Void();
23102 return resultobj;
23103 fail:
23104 return NULL;
23105 }
23106
23107
23108 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23109 PyObject *resultobj = 0;
23110 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23111 wxSize *result = 0 ;
23112 void *argp1 = 0 ;
23113 int res1 = 0 ;
23114 PyObject *swig_obj[1] ;
23115
23116 if (!args) SWIG_fail;
23117 swig_obj[0] = args;
23118 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23119 if (!SWIG_IsOK(res1)) {
23120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23121 }
23122 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23123 result = (wxSize *)& ((arg1)->m_size);
23124 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
23125 return resultobj;
23126 fail:
23127 return NULL;
23128 }
23129
23130
23131 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23132 PyObject *resultobj = 0;
23133 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23134 wxRect *arg2 = (wxRect *) 0 ;
23135 void *argp1 = 0 ;
23136 int res1 = 0 ;
23137 void *argp2 = 0 ;
23138 int res2 = 0 ;
23139 PyObject *swig_obj[2] ;
23140
23141 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
23142 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23143 if (!SWIG_IsOK(res1)) {
23144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23145 }
23146 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23147 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
23148 if (!SWIG_IsOK(res2)) {
23149 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
23150 }
23151 arg2 = reinterpret_cast< wxRect * >(argp2);
23152 if (arg1) (arg1)->m_rect = *arg2;
23153
23154 resultobj = SWIG_Py_Void();
23155 return resultobj;
23156 fail:
23157 return NULL;
23158 }
23159
23160
23161 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23162 PyObject *resultobj = 0;
23163 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23164 wxRect *result = 0 ;
23165 void *argp1 = 0 ;
23166 int res1 = 0 ;
23167 PyObject *swig_obj[1] ;
23168
23169 if (!args) SWIG_fail;
23170 swig_obj[0] = args;
23171 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23172 if (!SWIG_IsOK(res1)) {
23173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23174 }
23175 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23176 result = (wxRect *)& ((arg1)->m_rect);
23177 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
23178 return resultobj;
23179 fail:
23180 return NULL;
23181 }
23182
23183
23184 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23185 PyObject *obj;
23186 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23187 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
23188 return SWIG_Py_Void();
23189 }
23190
23191 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23192 return SWIG_Python_InitShadowInstance(args);
23193 }
23194
23195 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23196 PyObject *resultobj = 0;
23197 wxPoint const &arg1_defvalue = wxDefaultPosition ;
23198 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
23199 int arg2 = (int) 0 ;
23200 wxMoveEvent *result = 0 ;
23201 wxPoint temp1 ;
23202 int val2 ;
23203 int ecode2 = 0 ;
23204 PyObject * obj0 = 0 ;
23205 PyObject * obj1 = 0 ;
23206 char * kwnames[] = {
23207 (char *) "pos",(char *) "winid", NULL
23208 };
23209
23210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23211 if (obj0) {
23212 {
23213 arg1 = &temp1;
23214 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
23215 }
23216 }
23217 if (obj1) {
23218 ecode2 = SWIG_AsVal_int(obj1, &val2);
23219 if (!SWIG_IsOK(ecode2)) {
23220 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
23221 }
23222 arg2 = static_cast< int >(val2);
23223 }
23224 {
23225 PyThreadState* __tstate = wxPyBeginAllowThreads();
23226 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
23227 wxPyEndAllowThreads(__tstate);
23228 if (PyErr_Occurred()) SWIG_fail;
23229 }
23230 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
23231 return resultobj;
23232 fail:
23233 return NULL;
23234 }
23235
23236
23237 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23238 PyObject *resultobj = 0;
23239 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23240 wxPoint result;
23241 void *argp1 = 0 ;
23242 int res1 = 0 ;
23243 PyObject *swig_obj[1] ;
23244
23245 if (!args) SWIG_fail;
23246 swig_obj[0] = args;
23247 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23248 if (!SWIG_IsOK(res1)) {
23249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23250 }
23251 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23252 {
23253 PyThreadState* __tstate = wxPyBeginAllowThreads();
23254 result = ((wxMoveEvent const *)arg1)->GetPosition();
23255 wxPyEndAllowThreads(__tstate);
23256 if (PyErr_Occurred()) SWIG_fail;
23257 }
23258 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23259 return resultobj;
23260 fail:
23261 return NULL;
23262 }
23263
23264
23265 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23266 PyObject *resultobj = 0;
23267 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23268 wxRect result;
23269 void *argp1 = 0 ;
23270 int res1 = 0 ;
23271 PyObject *swig_obj[1] ;
23272
23273 if (!args) SWIG_fail;
23274 swig_obj[0] = args;
23275 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23276 if (!SWIG_IsOK(res1)) {
23277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23278 }
23279 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23280 {
23281 PyThreadState* __tstate = wxPyBeginAllowThreads();
23282 result = ((wxMoveEvent const *)arg1)->GetRect();
23283 wxPyEndAllowThreads(__tstate);
23284 if (PyErr_Occurred()) SWIG_fail;
23285 }
23286 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23287 return resultobj;
23288 fail:
23289 return NULL;
23290 }
23291
23292
23293 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23294 PyObject *resultobj = 0;
23295 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23296 wxRect *arg2 = 0 ;
23297 void *argp1 = 0 ;
23298 int res1 = 0 ;
23299 wxRect temp2 ;
23300 PyObject * obj0 = 0 ;
23301 PyObject * obj1 = 0 ;
23302 char * kwnames[] = {
23303 (char *) "self",(char *) "rect", NULL
23304 };
23305
23306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23307 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23308 if (!SWIG_IsOK(res1)) {
23309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23310 }
23311 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23312 {
23313 arg2 = &temp2;
23314 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
23315 }
23316 {
23317 PyThreadState* __tstate = wxPyBeginAllowThreads();
23318 (arg1)->SetRect((wxRect const &)*arg2);
23319 wxPyEndAllowThreads(__tstate);
23320 if (PyErr_Occurred()) SWIG_fail;
23321 }
23322 resultobj = SWIG_Py_Void();
23323 return resultobj;
23324 fail:
23325 return NULL;
23326 }
23327
23328
23329 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23330 PyObject *resultobj = 0;
23331 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23332 wxPoint *arg2 = 0 ;
23333 void *argp1 = 0 ;
23334 int res1 = 0 ;
23335 wxPoint temp2 ;
23336 PyObject * obj0 = 0 ;
23337 PyObject * obj1 = 0 ;
23338 char * kwnames[] = {
23339 (char *) "self",(char *) "pos", NULL
23340 };
23341
23342 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23343 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23344 if (!SWIG_IsOK(res1)) {
23345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23346 }
23347 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23348 {
23349 arg2 = &temp2;
23350 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
23351 }
23352 {
23353 PyThreadState* __tstate = wxPyBeginAllowThreads();
23354 (arg1)->SetPosition((wxPoint const &)*arg2);
23355 wxPyEndAllowThreads(__tstate);
23356 if (PyErr_Occurred()) SWIG_fail;
23357 }
23358 resultobj = SWIG_Py_Void();
23359 return resultobj;
23360 fail:
23361 return NULL;
23362 }
23363
23364
23365 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23366 PyObject *obj;
23367 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23368 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
23369 return SWIG_Py_Void();
23370 }
23371
23372 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23373 return SWIG_Python_InitShadowInstance(args);
23374 }
23375
23376 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23377 PyObject *resultobj = 0;
23378 int arg1 = (int) 0 ;
23379 wxPaintEvent *result = 0 ;
23380 int val1 ;
23381 int ecode1 = 0 ;
23382 PyObject * obj0 = 0 ;
23383 char * kwnames[] = {
23384 (char *) "Id", NULL
23385 };
23386
23387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
23388 if (obj0) {
23389 ecode1 = SWIG_AsVal_int(obj0, &val1);
23390 if (!SWIG_IsOK(ecode1)) {
23391 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
23392 }
23393 arg1 = static_cast< int >(val1);
23394 }
23395 {
23396 PyThreadState* __tstate = wxPyBeginAllowThreads();
23397 result = (wxPaintEvent *)new wxPaintEvent(arg1);
23398 wxPyEndAllowThreads(__tstate);
23399 if (PyErr_Occurred()) SWIG_fail;
23400 }
23401 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
23402 return resultobj;
23403 fail:
23404 return NULL;
23405 }
23406
23407
23408 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23409 PyObject *obj;
23410 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23411 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
23412 return SWIG_Py_Void();
23413 }
23414
23415 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23416 return SWIG_Python_InitShadowInstance(args);
23417 }
23418
23419 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23420 PyObject *resultobj = 0;
23421 int arg1 = (int) 0 ;
23422 wxNcPaintEvent *result = 0 ;
23423 int val1 ;
23424 int ecode1 = 0 ;
23425 PyObject * obj0 = 0 ;
23426 char * kwnames[] = {
23427 (char *) "winid", NULL
23428 };
23429
23430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
23431 if (obj0) {
23432 ecode1 = SWIG_AsVal_int(obj0, &val1);
23433 if (!SWIG_IsOK(ecode1)) {
23434 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
23435 }
23436 arg1 = static_cast< int >(val1);
23437 }
23438 {
23439 PyThreadState* __tstate = wxPyBeginAllowThreads();
23440 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
23441 wxPyEndAllowThreads(__tstate);
23442 if (PyErr_Occurred()) SWIG_fail;
23443 }
23444 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
23445 return resultobj;
23446 fail:
23447 return NULL;
23448 }
23449
23450
23451 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23452 PyObject *obj;
23453 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23454 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
23455 return SWIG_Py_Void();
23456 }
23457
23458 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23459 return SWIG_Python_InitShadowInstance(args);
23460 }
23461
23462 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23463 PyObject *resultobj = 0;
23464 int arg1 = (int) 0 ;
23465 wxDC *arg2 = (wxDC *) NULL ;
23466 wxEraseEvent *result = 0 ;
23467 int val1 ;
23468 int ecode1 = 0 ;
23469 void *argp2 = 0 ;
23470 int res2 = 0 ;
23471 PyObject * obj0 = 0 ;
23472 PyObject * obj1 = 0 ;
23473 char * kwnames[] = {
23474 (char *) "Id",(char *) "dc", NULL
23475 };
23476
23477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23478 if (obj0) {
23479 ecode1 = SWIG_AsVal_int(obj0, &val1);
23480 if (!SWIG_IsOK(ecode1)) {
23481 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
23482 }
23483 arg1 = static_cast< int >(val1);
23484 }
23485 if (obj1) {
23486 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
23487 if (!SWIG_IsOK(res2)) {
23488 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
23489 }
23490 arg2 = reinterpret_cast< wxDC * >(argp2);
23491 }
23492 {
23493 PyThreadState* __tstate = wxPyBeginAllowThreads();
23494 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
23495 wxPyEndAllowThreads(__tstate);
23496 if (PyErr_Occurred()) SWIG_fail;
23497 }
23498 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
23499 return resultobj;
23500 fail:
23501 return NULL;
23502 }
23503
23504
23505 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23506 PyObject *resultobj = 0;
23507 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
23508 wxDC *result = 0 ;
23509 void *argp1 = 0 ;
23510 int res1 = 0 ;
23511 PyObject *swig_obj[1] ;
23512
23513 if (!args) SWIG_fail;
23514 swig_obj[0] = args;
23515 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
23516 if (!SWIG_IsOK(res1)) {
23517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
23518 }
23519 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
23520 {
23521 PyThreadState* __tstate = wxPyBeginAllowThreads();
23522 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
23523 wxPyEndAllowThreads(__tstate);
23524 if (PyErr_Occurred()) SWIG_fail;
23525 }
23526 {
23527 resultobj = wxPyMake_wxObject(result, (bool)0);
23528 }
23529 return resultobj;
23530 fail:
23531 return NULL;
23532 }
23533
23534
23535 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23536 PyObject *obj;
23537 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23538 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
23539 return SWIG_Py_Void();
23540 }
23541
23542 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23543 return SWIG_Python_InitShadowInstance(args);
23544 }
23545
23546 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23547 PyObject *resultobj = 0;
23548 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23549 int arg2 = (int) 0 ;
23550 wxFocusEvent *result = 0 ;
23551 int val1 ;
23552 int ecode1 = 0 ;
23553 int val2 ;
23554 int ecode2 = 0 ;
23555 PyObject * obj0 = 0 ;
23556 PyObject * obj1 = 0 ;
23557 char * kwnames[] = {
23558 (char *) "type",(char *) "winid", NULL
23559 };
23560
23561 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23562 if (obj0) {
23563 ecode1 = SWIG_AsVal_int(obj0, &val1);
23564 if (!SWIG_IsOK(ecode1)) {
23565 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23566 }
23567 arg1 = static_cast< wxEventType >(val1);
23568 }
23569 if (obj1) {
23570 ecode2 = SWIG_AsVal_int(obj1, &val2);
23571 if (!SWIG_IsOK(ecode2)) {
23572 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
23573 }
23574 arg2 = static_cast< int >(val2);
23575 }
23576 {
23577 PyThreadState* __tstate = wxPyBeginAllowThreads();
23578 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
23579 wxPyEndAllowThreads(__tstate);
23580 if (PyErr_Occurred()) SWIG_fail;
23581 }
23582 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
23583 return resultobj;
23584 fail:
23585 return NULL;
23586 }
23587
23588
23589 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23590 PyObject *resultobj = 0;
23591 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23592 wxWindow *result = 0 ;
23593 void *argp1 = 0 ;
23594 int res1 = 0 ;
23595 PyObject *swig_obj[1] ;
23596
23597 if (!args) SWIG_fail;
23598 swig_obj[0] = args;
23599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23600 if (!SWIG_IsOK(res1)) {
23601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
23602 }
23603 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23604 {
23605 PyThreadState* __tstate = wxPyBeginAllowThreads();
23606 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
23607 wxPyEndAllowThreads(__tstate);
23608 if (PyErr_Occurred()) SWIG_fail;
23609 }
23610 {
23611 resultobj = wxPyMake_wxObject(result, (bool)0);
23612 }
23613 return resultobj;
23614 fail:
23615 return NULL;
23616 }
23617
23618
23619 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23620 PyObject *resultobj = 0;
23621 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23622 wxWindow *arg2 = (wxWindow *) 0 ;
23623 void *argp1 = 0 ;
23624 int res1 = 0 ;
23625 void *argp2 = 0 ;
23626 int res2 = 0 ;
23627 PyObject * obj0 = 0 ;
23628 PyObject * obj1 = 0 ;
23629 char * kwnames[] = {
23630 (char *) "self",(char *) "win", NULL
23631 };
23632
23633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
23634 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23635 if (!SWIG_IsOK(res1)) {
23636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
23637 }
23638 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23639 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
23640 if (!SWIG_IsOK(res2)) {
23641 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
23642 }
23643 arg2 = reinterpret_cast< wxWindow * >(argp2);
23644 {
23645 PyThreadState* __tstate = wxPyBeginAllowThreads();
23646 (arg1)->SetWindow(arg2);
23647 wxPyEndAllowThreads(__tstate);
23648 if (PyErr_Occurred()) SWIG_fail;
23649 }
23650 resultobj = SWIG_Py_Void();
23651 return resultobj;
23652 fail:
23653 return NULL;
23654 }
23655
23656
23657 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23658 PyObject *obj;
23659 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23660 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
23661 return SWIG_Py_Void();
23662 }
23663
23664 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23665 return SWIG_Python_InitShadowInstance(args);
23666 }
23667
23668 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23669 PyObject *resultobj = 0;
23670 wxWindow *arg1 = (wxWindow *) NULL ;
23671 wxChildFocusEvent *result = 0 ;
23672 void *argp1 = 0 ;
23673 int res1 = 0 ;
23674 PyObject * obj0 = 0 ;
23675 char * kwnames[] = {
23676 (char *) "win", NULL
23677 };
23678
23679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
23680 if (obj0) {
23681 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
23682 if (!SWIG_IsOK(res1)) {
23683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
23684 }
23685 arg1 = reinterpret_cast< wxWindow * >(argp1);
23686 }
23687 {
23688 PyThreadState* __tstate = wxPyBeginAllowThreads();
23689 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
23690 wxPyEndAllowThreads(__tstate);
23691 if (PyErr_Occurred()) SWIG_fail;
23692 }
23693 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
23694 return resultobj;
23695 fail:
23696 return NULL;
23697 }
23698
23699
23700 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23701 PyObject *resultobj = 0;
23702 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
23703 wxWindow *result = 0 ;
23704 void *argp1 = 0 ;
23705 int res1 = 0 ;
23706 PyObject *swig_obj[1] ;
23707
23708 if (!args) SWIG_fail;
23709 swig_obj[0] = args;
23710 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
23711 if (!SWIG_IsOK(res1)) {
23712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
23713 }
23714 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
23715 {
23716 PyThreadState* __tstate = wxPyBeginAllowThreads();
23717 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
23718 wxPyEndAllowThreads(__tstate);
23719 if (PyErr_Occurred()) SWIG_fail;
23720 }
23721 {
23722 resultobj = wxPyMake_wxObject(result, (bool)0);
23723 }
23724 return resultobj;
23725 fail:
23726 return NULL;
23727 }
23728
23729
23730 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23731 PyObject *obj;
23732 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23733 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
23734 return SWIG_Py_Void();
23735 }
23736
23737 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23738 return SWIG_Python_InitShadowInstance(args);
23739 }
23740
23741 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23742 PyObject *resultobj = 0;
23743 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23744 bool arg2 = (bool) true ;
23745 int arg3 = (int) 0 ;
23746 wxActivateEvent *result = 0 ;
23747 int val1 ;
23748 int ecode1 = 0 ;
23749 bool val2 ;
23750 int ecode2 = 0 ;
23751 int val3 ;
23752 int ecode3 = 0 ;
23753 PyObject * obj0 = 0 ;
23754 PyObject * obj1 = 0 ;
23755 PyObject * obj2 = 0 ;
23756 char * kwnames[] = {
23757 (char *) "type",(char *) "active",(char *) "Id", NULL
23758 };
23759
23760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23761 if (obj0) {
23762 ecode1 = SWIG_AsVal_int(obj0, &val1);
23763 if (!SWIG_IsOK(ecode1)) {
23764 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23765 }
23766 arg1 = static_cast< wxEventType >(val1);
23767 }
23768 if (obj1) {
23769 ecode2 = SWIG_AsVal_bool(obj1, &val2);
23770 if (!SWIG_IsOK(ecode2)) {
23771 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
23772 }
23773 arg2 = static_cast< bool >(val2);
23774 }
23775 if (obj2) {
23776 ecode3 = SWIG_AsVal_int(obj2, &val3);
23777 if (!SWIG_IsOK(ecode3)) {
23778 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
23779 }
23780 arg3 = static_cast< int >(val3);
23781 }
23782 {
23783 PyThreadState* __tstate = wxPyBeginAllowThreads();
23784 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
23785 wxPyEndAllowThreads(__tstate);
23786 if (PyErr_Occurred()) SWIG_fail;
23787 }
23788 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
23789 return resultobj;
23790 fail:
23791 return NULL;
23792 }
23793
23794
23795 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23796 PyObject *resultobj = 0;
23797 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
23798 bool result;
23799 void *argp1 = 0 ;
23800 int res1 = 0 ;
23801 PyObject *swig_obj[1] ;
23802
23803 if (!args) SWIG_fail;
23804 swig_obj[0] = args;
23805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
23806 if (!SWIG_IsOK(res1)) {
23807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
23808 }
23809 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
23810 {
23811 PyThreadState* __tstate = wxPyBeginAllowThreads();
23812 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
23813 wxPyEndAllowThreads(__tstate);
23814 if (PyErr_Occurred()) SWIG_fail;
23815 }
23816 {
23817 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23818 }
23819 return resultobj;
23820 fail:
23821 return NULL;
23822 }
23823
23824
23825 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23826 PyObject *obj;
23827 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23828 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
23829 return SWIG_Py_Void();
23830 }
23831
23832 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23833 return SWIG_Python_InitShadowInstance(args);
23834 }
23835
23836 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23837 PyObject *resultobj = 0;
23838 int arg1 = (int) 0 ;
23839 wxInitDialogEvent *result = 0 ;
23840 int val1 ;
23841 int ecode1 = 0 ;
23842 PyObject * obj0 = 0 ;
23843 char * kwnames[] = {
23844 (char *) "Id", NULL
23845 };
23846
23847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
23848 if (obj0) {
23849 ecode1 = SWIG_AsVal_int(obj0, &val1);
23850 if (!SWIG_IsOK(ecode1)) {
23851 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
23852 }
23853 arg1 = static_cast< int >(val1);
23854 }
23855 {
23856 PyThreadState* __tstate = wxPyBeginAllowThreads();
23857 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
23858 wxPyEndAllowThreads(__tstate);
23859 if (PyErr_Occurred()) SWIG_fail;
23860 }
23861 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
23862 return resultobj;
23863 fail:
23864 return NULL;
23865 }
23866
23867
23868 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23869 PyObject *obj;
23870 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23871 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
23872 return SWIG_Py_Void();
23873 }
23874
23875 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23876 return SWIG_Python_InitShadowInstance(args);
23877 }
23878
23879 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23880 PyObject *resultobj = 0;
23881 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23882 int arg2 = (int) 0 ;
23883 wxMenu *arg3 = (wxMenu *) NULL ;
23884 wxMenuEvent *result = 0 ;
23885 int val1 ;
23886 int ecode1 = 0 ;
23887 int val2 ;
23888 int ecode2 = 0 ;
23889 void *argp3 = 0 ;
23890 int res3 = 0 ;
23891 PyObject * obj0 = 0 ;
23892 PyObject * obj1 = 0 ;
23893 PyObject * obj2 = 0 ;
23894 char * kwnames[] = {
23895 (char *) "type",(char *) "winid",(char *) "menu", NULL
23896 };
23897
23898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23899 if (obj0) {
23900 ecode1 = SWIG_AsVal_int(obj0, &val1);
23901 if (!SWIG_IsOK(ecode1)) {
23902 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23903 }
23904 arg1 = static_cast< wxEventType >(val1);
23905 }
23906 if (obj1) {
23907 ecode2 = SWIG_AsVal_int(obj1, &val2);
23908 if (!SWIG_IsOK(ecode2)) {
23909 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
23910 }
23911 arg2 = static_cast< int >(val2);
23912 }
23913 if (obj2) {
23914 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
23915 if (!SWIG_IsOK(res3)) {
23916 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
23917 }
23918 arg3 = reinterpret_cast< wxMenu * >(argp3);
23919 }
23920 {
23921 PyThreadState* __tstate = wxPyBeginAllowThreads();
23922 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
23923 wxPyEndAllowThreads(__tstate);
23924 if (PyErr_Occurred()) SWIG_fail;
23925 }
23926 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
23927 return resultobj;
23928 fail:
23929 return NULL;
23930 }
23931
23932
23933 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23934 PyObject *resultobj = 0;
23935 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
23936 int result;
23937 void *argp1 = 0 ;
23938 int res1 = 0 ;
23939 PyObject *swig_obj[1] ;
23940
23941 if (!args) SWIG_fail;
23942 swig_obj[0] = args;
23943 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
23944 if (!SWIG_IsOK(res1)) {
23945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
23946 }
23947 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
23948 {
23949 PyThreadState* __tstate = wxPyBeginAllowThreads();
23950 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
23951 wxPyEndAllowThreads(__tstate);
23952 if (PyErr_Occurred()) SWIG_fail;
23953 }
23954 resultobj = SWIG_From_int(static_cast< int >(result));
23955 return resultobj;
23956 fail:
23957 return NULL;
23958 }
23959
23960
23961 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23962 PyObject *resultobj = 0;
23963 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
23964 bool result;
23965 void *argp1 = 0 ;
23966 int res1 = 0 ;
23967 PyObject *swig_obj[1] ;
23968
23969 if (!args) SWIG_fail;
23970 swig_obj[0] = args;
23971 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
23972 if (!SWIG_IsOK(res1)) {
23973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
23974 }
23975 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
23976 {
23977 PyThreadState* __tstate = wxPyBeginAllowThreads();
23978 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
23979 wxPyEndAllowThreads(__tstate);
23980 if (PyErr_Occurred()) SWIG_fail;
23981 }
23982 {
23983 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23984 }
23985 return resultobj;
23986 fail:
23987 return NULL;
23988 }
23989
23990
23991 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23992 PyObject *resultobj = 0;
23993 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
23994 wxMenu *result = 0 ;
23995 void *argp1 = 0 ;
23996 int res1 = 0 ;
23997 PyObject *swig_obj[1] ;
23998
23999 if (!args) SWIG_fail;
24000 swig_obj[0] = args;
24001 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24002 if (!SWIG_IsOK(res1)) {
24003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24004 }
24005 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24006 {
24007 PyThreadState* __tstate = wxPyBeginAllowThreads();
24008 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
24009 wxPyEndAllowThreads(__tstate);
24010 if (PyErr_Occurred()) SWIG_fail;
24011 }
24012 {
24013 resultobj = wxPyMake_wxObject(result, (bool)0);
24014 }
24015 return resultobj;
24016 fail:
24017 return NULL;
24018 }
24019
24020
24021 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24022 PyObject *obj;
24023 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24024 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
24025 return SWIG_Py_Void();
24026 }
24027
24028 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24029 return SWIG_Python_InitShadowInstance(args);
24030 }
24031
24032 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24033 PyObject *resultobj = 0;
24034 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24035 int arg2 = (int) 0 ;
24036 wxCloseEvent *result = 0 ;
24037 int val1 ;
24038 int ecode1 = 0 ;
24039 int val2 ;
24040 int ecode2 = 0 ;
24041 PyObject * obj0 = 0 ;
24042 PyObject * obj1 = 0 ;
24043 char * kwnames[] = {
24044 (char *) "type",(char *) "winid", NULL
24045 };
24046
24047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24048 if (obj0) {
24049 ecode1 = SWIG_AsVal_int(obj0, &val1);
24050 if (!SWIG_IsOK(ecode1)) {
24051 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24052 }
24053 arg1 = static_cast< wxEventType >(val1);
24054 }
24055 if (obj1) {
24056 ecode2 = SWIG_AsVal_int(obj1, &val2);
24057 if (!SWIG_IsOK(ecode2)) {
24058 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
24059 }
24060 arg2 = static_cast< int >(val2);
24061 }
24062 {
24063 PyThreadState* __tstate = wxPyBeginAllowThreads();
24064 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
24065 wxPyEndAllowThreads(__tstate);
24066 if (PyErr_Occurred()) SWIG_fail;
24067 }
24068 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
24069 return resultobj;
24070 fail:
24071 return NULL;
24072 }
24073
24074
24075 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24076 PyObject *resultobj = 0;
24077 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24078 bool arg2 ;
24079 void *argp1 = 0 ;
24080 int res1 = 0 ;
24081 bool val2 ;
24082 int ecode2 = 0 ;
24083 PyObject * obj0 = 0 ;
24084 PyObject * obj1 = 0 ;
24085 char * kwnames[] = {
24086 (char *) "self",(char *) "logOff", NULL
24087 };
24088
24089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
24090 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24091 if (!SWIG_IsOK(res1)) {
24092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24093 }
24094 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24095 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24096 if (!SWIG_IsOK(ecode2)) {
24097 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
24098 }
24099 arg2 = static_cast< bool >(val2);
24100 {
24101 PyThreadState* __tstate = wxPyBeginAllowThreads();
24102 (arg1)->SetLoggingOff(arg2);
24103 wxPyEndAllowThreads(__tstate);
24104 if (PyErr_Occurred()) SWIG_fail;
24105 }
24106 resultobj = SWIG_Py_Void();
24107 return resultobj;
24108 fail:
24109 return NULL;
24110 }
24111
24112
24113 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24114 PyObject *resultobj = 0;
24115 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24116 bool result;
24117 void *argp1 = 0 ;
24118 int res1 = 0 ;
24119 PyObject *swig_obj[1] ;
24120
24121 if (!args) SWIG_fail;
24122 swig_obj[0] = args;
24123 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24124 if (!SWIG_IsOK(res1)) {
24125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24126 }
24127 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24128 {
24129 PyThreadState* __tstate = wxPyBeginAllowThreads();
24130 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
24131 wxPyEndAllowThreads(__tstate);
24132 if (PyErr_Occurred()) SWIG_fail;
24133 }
24134 {
24135 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24136 }
24137 return resultobj;
24138 fail:
24139 return NULL;
24140 }
24141
24142
24143 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24144 PyObject *resultobj = 0;
24145 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24146 bool arg2 = (bool) true ;
24147 void *argp1 = 0 ;
24148 int res1 = 0 ;
24149 bool val2 ;
24150 int ecode2 = 0 ;
24151 PyObject * obj0 = 0 ;
24152 PyObject * obj1 = 0 ;
24153 char * kwnames[] = {
24154 (char *) "self",(char *) "veto", NULL
24155 };
24156
24157 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
24158 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24159 if (!SWIG_IsOK(res1)) {
24160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24161 }
24162 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24163 if (obj1) {
24164 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24165 if (!SWIG_IsOK(ecode2)) {
24166 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
24167 }
24168 arg2 = static_cast< bool >(val2);
24169 }
24170 {
24171 PyThreadState* __tstate = wxPyBeginAllowThreads();
24172 (arg1)->Veto(arg2);
24173 wxPyEndAllowThreads(__tstate);
24174 if (PyErr_Occurred()) SWIG_fail;
24175 }
24176 resultobj = SWIG_Py_Void();
24177 return resultobj;
24178 fail:
24179 return NULL;
24180 }
24181
24182
24183 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24184 PyObject *resultobj = 0;
24185 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24186 bool result;
24187 void *argp1 = 0 ;
24188 int res1 = 0 ;
24189 PyObject *swig_obj[1] ;
24190
24191 if (!args) SWIG_fail;
24192 swig_obj[0] = args;
24193 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24194 if (!SWIG_IsOK(res1)) {
24195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24196 }
24197 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24198 {
24199 PyThreadState* __tstate = wxPyBeginAllowThreads();
24200 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
24201 wxPyEndAllowThreads(__tstate);
24202 if (PyErr_Occurred()) SWIG_fail;
24203 }
24204 {
24205 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24206 }
24207 return resultobj;
24208 fail:
24209 return NULL;
24210 }
24211
24212
24213 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24214 PyObject *resultobj = 0;
24215 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24216 bool arg2 ;
24217 void *argp1 = 0 ;
24218 int res1 = 0 ;
24219 bool val2 ;
24220 int ecode2 = 0 ;
24221 PyObject * obj0 = 0 ;
24222 PyObject * obj1 = 0 ;
24223 char * kwnames[] = {
24224 (char *) "self",(char *) "canVeto", NULL
24225 };
24226
24227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
24228 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24229 if (!SWIG_IsOK(res1)) {
24230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24231 }
24232 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24233 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24234 if (!SWIG_IsOK(ecode2)) {
24235 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
24236 }
24237 arg2 = static_cast< bool >(val2);
24238 {
24239 PyThreadState* __tstate = wxPyBeginAllowThreads();
24240 (arg1)->SetCanVeto(arg2);
24241 wxPyEndAllowThreads(__tstate);
24242 if (PyErr_Occurred()) SWIG_fail;
24243 }
24244 resultobj = SWIG_Py_Void();
24245 return resultobj;
24246 fail:
24247 return NULL;
24248 }
24249
24250
24251 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24252 PyObject *resultobj = 0;
24253 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24254 bool result;
24255 void *argp1 = 0 ;
24256 int res1 = 0 ;
24257 PyObject *swig_obj[1] ;
24258
24259 if (!args) SWIG_fail;
24260 swig_obj[0] = args;
24261 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24262 if (!SWIG_IsOK(res1)) {
24263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24264 }
24265 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24266 {
24267 PyThreadState* __tstate = wxPyBeginAllowThreads();
24268 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
24269 wxPyEndAllowThreads(__tstate);
24270 if (PyErr_Occurred()) SWIG_fail;
24271 }
24272 {
24273 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24274 }
24275 return resultobj;
24276 fail:
24277 return NULL;
24278 }
24279
24280
24281 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24282 PyObject *obj;
24283 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24284 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
24285 return SWIG_Py_Void();
24286 }
24287
24288 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24289 return SWIG_Python_InitShadowInstance(args);
24290 }
24291
24292 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24293 PyObject *resultobj = 0;
24294 int arg1 = (int) 0 ;
24295 bool arg2 = (bool) false ;
24296 wxShowEvent *result = 0 ;
24297 int val1 ;
24298 int ecode1 = 0 ;
24299 bool val2 ;
24300 int ecode2 = 0 ;
24301 PyObject * obj0 = 0 ;
24302 PyObject * obj1 = 0 ;
24303 char * kwnames[] = {
24304 (char *) "winid",(char *) "show", NULL
24305 };
24306
24307 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24308 if (obj0) {
24309 ecode1 = SWIG_AsVal_int(obj0, &val1);
24310 if (!SWIG_IsOK(ecode1)) {
24311 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
24312 }
24313 arg1 = static_cast< int >(val1);
24314 }
24315 if (obj1) {
24316 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24317 if (!SWIG_IsOK(ecode2)) {
24318 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
24319 }
24320 arg2 = static_cast< bool >(val2);
24321 }
24322 {
24323 PyThreadState* __tstate = wxPyBeginAllowThreads();
24324 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
24325 wxPyEndAllowThreads(__tstate);
24326 if (PyErr_Occurred()) SWIG_fail;
24327 }
24328 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
24329 return resultobj;
24330 fail:
24331 return NULL;
24332 }
24333
24334
24335 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24336 PyObject *resultobj = 0;
24337 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24338 bool arg2 ;
24339 void *argp1 = 0 ;
24340 int res1 = 0 ;
24341 bool val2 ;
24342 int ecode2 = 0 ;
24343 PyObject * obj0 = 0 ;
24344 PyObject * obj1 = 0 ;
24345 char * kwnames[] = {
24346 (char *) "self",(char *) "show", NULL
24347 };
24348
24349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
24350 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24351 if (!SWIG_IsOK(res1)) {
24352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
24353 }
24354 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24355 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24356 if (!SWIG_IsOK(ecode2)) {
24357 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
24358 }
24359 arg2 = static_cast< bool >(val2);
24360 {
24361 PyThreadState* __tstate = wxPyBeginAllowThreads();
24362 (arg1)->SetShow(arg2);
24363 wxPyEndAllowThreads(__tstate);
24364 if (PyErr_Occurred()) SWIG_fail;
24365 }
24366 resultobj = SWIG_Py_Void();
24367 return resultobj;
24368 fail:
24369 return NULL;
24370 }
24371
24372
24373 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24374 PyObject *resultobj = 0;
24375 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24376 bool result;
24377 void *argp1 = 0 ;
24378 int res1 = 0 ;
24379 PyObject *swig_obj[1] ;
24380
24381 if (!args) SWIG_fail;
24382 swig_obj[0] = args;
24383 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24384 if (!SWIG_IsOK(res1)) {
24385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
24386 }
24387 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24388 {
24389 PyThreadState* __tstate = wxPyBeginAllowThreads();
24390 result = (bool)((wxShowEvent const *)arg1)->GetShow();
24391 wxPyEndAllowThreads(__tstate);
24392 if (PyErr_Occurred()) SWIG_fail;
24393 }
24394 {
24395 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24396 }
24397 return resultobj;
24398 fail:
24399 return NULL;
24400 }
24401
24402
24403 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24404 PyObject *obj;
24405 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24406 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
24407 return SWIG_Py_Void();
24408 }
24409
24410 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24411 return SWIG_Python_InitShadowInstance(args);
24412 }
24413
24414 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24415 PyObject *resultobj = 0;
24416 int arg1 = (int) 0 ;
24417 bool arg2 = (bool) true ;
24418 wxIconizeEvent *result = 0 ;
24419 int val1 ;
24420 int ecode1 = 0 ;
24421 bool val2 ;
24422 int ecode2 = 0 ;
24423 PyObject * obj0 = 0 ;
24424 PyObject * obj1 = 0 ;
24425 char * kwnames[] = {
24426 (char *) "id",(char *) "iconized", NULL
24427 };
24428
24429 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24430 if (obj0) {
24431 ecode1 = SWIG_AsVal_int(obj0, &val1);
24432 if (!SWIG_IsOK(ecode1)) {
24433 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
24434 }
24435 arg1 = static_cast< int >(val1);
24436 }
24437 if (obj1) {
24438 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24439 if (!SWIG_IsOK(ecode2)) {
24440 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
24441 }
24442 arg2 = static_cast< bool >(val2);
24443 }
24444 {
24445 PyThreadState* __tstate = wxPyBeginAllowThreads();
24446 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
24447 wxPyEndAllowThreads(__tstate);
24448 if (PyErr_Occurred()) SWIG_fail;
24449 }
24450 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
24451 return resultobj;
24452 fail:
24453 return NULL;
24454 }
24455
24456
24457 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24458 PyObject *resultobj = 0;
24459 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
24460 bool result;
24461 void *argp1 = 0 ;
24462 int res1 = 0 ;
24463 PyObject *swig_obj[1] ;
24464
24465 if (!args) SWIG_fail;
24466 swig_obj[0] = args;
24467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
24468 if (!SWIG_IsOK(res1)) {
24469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
24470 }
24471 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
24472 {
24473 PyThreadState* __tstate = wxPyBeginAllowThreads();
24474 result = (bool)(arg1)->Iconized();
24475 wxPyEndAllowThreads(__tstate);
24476 if (PyErr_Occurred()) SWIG_fail;
24477 }
24478 {
24479 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24480 }
24481 return resultobj;
24482 fail:
24483 return NULL;
24484 }
24485
24486
24487 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24488 PyObject *obj;
24489 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24490 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
24491 return SWIG_Py_Void();
24492 }
24493
24494 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24495 return SWIG_Python_InitShadowInstance(args);
24496 }
24497
24498 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24499 PyObject *resultobj = 0;
24500 int arg1 = (int) 0 ;
24501 wxMaximizeEvent *result = 0 ;
24502 int val1 ;
24503 int ecode1 = 0 ;
24504 PyObject * obj0 = 0 ;
24505 char * kwnames[] = {
24506 (char *) "id", NULL
24507 };
24508
24509 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
24510 if (obj0) {
24511 ecode1 = SWIG_AsVal_int(obj0, &val1);
24512 if (!SWIG_IsOK(ecode1)) {
24513 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
24514 }
24515 arg1 = static_cast< int >(val1);
24516 }
24517 {
24518 PyThreadState* __tstate = wxPyBeginAllowThreads();
24519 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
24520 wxPyEndAllowThreads(__tstate);
24521 if (PyErr_Occurred()) SWIG_fail;
24522 }
24523 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
24524 return resultobj;
24525 fail:
24526 return NULL;
24527 }
24528
24529
24530 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24531 PyObject *obj;
24532 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24533 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
24534 return SWIG_Py_Void();
24535 }
24536
24537 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24538 return SWIG_Python_InitShadowInstance(args);
24539 }
24540
24541 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24542 PyObject *resultobj = 0;
24543 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24544 wxPoint result;
24545 void *argp1 = 0 ;
24546 int res1 = 0 ;
24547 PyObject *swig_obj[1] ;
24548
24549 if (!args) SWIG_fail;
24550 swig_obj[0] = args;
24551 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24552 if (!SWIG_IsOK(res1)) {
24553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24554 }
24555 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24556 {
24557 PyThreadState* __tstate = wxPyBeginAllowThreads();
24558 result = (arg1)->GetPosition();
24559 wxPyEndAllowThreads(__tstate);
24560 if (PyErr_Occurred()) SWIG_fail;
24561 }
24562 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
24563 return resultobj;
24564 fail:
24565 return NULL;
24566 }
24567
24568
24569 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24570 PyObject *resultobj = 0;
24571 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24572 int result;
24573 void *argp1 = 0 ;
24574 int res1 = 0 ;
24575 PyObject *swig_obj[1] ;
24576
24577 if (!args) SWIG_fail;
24578 swig_obj[0] = args;
24579 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24580 if (!SWIG_IsOK(res1)) {
24581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24582 }
24583 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24584 {
24585 PyThreadState* __tstate = wxPyBeginAllowThreads();
24586 result = (int)(arg1)->GetNumberOfFiles();
24587 wxPyEndAllowThreads(__tstate);
24588 if (PyErr_Occurred()) SWIG_fail;
24589 }
24590 resultobj = SWIG_From_int(static_cast< int >(result));
24591 return resultobj;
24592 fail:
24593 return NULL;
24594 }
24595
24596
24597 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24598 PyObject *resultobj = 0;
24599 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24600 PyObject *result = 0 ;
24601 void *argp1 = 0 ;
24602 int res1 = 0 ;
24603 PyObject *swig_obj[1] ;
24604
24605 if (!args) SWIG_fail;
24606 swig_obj[0] = args;
24607 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24608 if (!SWIG_IsOK(res1)) {
24609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24610 }
24611 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24612 {
24613 PyThreadState* __tstate = wxPyBeginAllowThreads();
24614 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
24615 wxPyEndAllowThreads(__tstate);
24616 if (PyErr_Occurred()) SWIG_fail;
24617 }
24618 resultobj = result;
24619 return resultobj;
24620 fail:
24621 return NULL;
24622 }
24623
24624
24625 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24626 PyObject *obj;
24627 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24628 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
24629 return SWIG_Py_Void();
24630 }
24631
24632 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24633 PyObject *resultobj = 0;
24634 int arg1 = (int) 0 ;
24635 wxUpdateUIEvent *result = 0 ;
24636 int val1 ;
24637 int ecode1 = 0 ;
24638 PyObject * obj0 = 0 ;
24639 char * kwnames[] = {
24640 (char *) "commandId", NULL
24641 };
24642
24643 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
24644 if (obj0) {
24645 ecode1 = SWIG_AsVal_int(obj0, &val1);
24646 if (!SWIG_IsOK(ecode1)) {
24647 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
24648 }
24649 arg1 = static_cast< int >(val1);
24650 }
24651 {
24652 PyThreadState* __tstate = wxPyBeginAllowThreads();
24653 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
24654 wxPyEndAllowThreads(__tstate);
24655 if (PyErr_Occurred()) SWIG_fail;
24656 }
24657 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
24658 return resultobj;
24659 fail:
24660 return NULL;
24661 }
24662
24663
24664 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24665 PyObject *resultobj = 0;
24666 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24667 bool result;
24668 void *argp1 = 0 ;
24669 int res1 = 0 ;
24670 PyObject *swig_obj[1] ;
24671
24672 if (!args) SWIG_fail;
24673 swig_obj[0] = args;
24674 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24675 if (!SWIG_IsOK(res1)) {
24676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24677 }
24678 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24679 {
24680 PyThreadState* __tstate = wxPyBeginAllowThreads();
24681 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
24682 wxPyEndAllowThreads(__tstate);
24683 if (PyErr_Occurred()) SWIG_fail;
24684 }
24685 {
24686 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24687 }
24688 return resultobj;
24689 fail:
24690 return NULL;
24691 }
24692
24693
24694 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24695 PyObject *resultobj = 0;
24696 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24697 bool result;
24698 void *argp1 = 0 ;
24699 int res1 = 0 ;
24700 PyObject *swig_obj[1] ;
24701
24702 if (!args) SWIG_fail;
24703 swig_obj[0] = args;
24704 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24705 if (!SWIG_IsOK(res1)) {
24706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24707 }
24708 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24709 {
24710 PyThreadState* __tstate = wxPyBeginAllowThreads();
24711 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
24712 wxPyEndAllowThreads(__tstate);
24713 if (PyErr_Occurred()) SWIG_fail;
24714 }
24715 {
24716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24717 }
24718 return resultobj;
24719 fail:
24720 return NULL;
24721 }
24722
24723
24724 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24725 PyObject *resultobj = 0;
24726 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24727 bool result;
24728 void *argp1 = 0 ;
24729 int res1 = 0 ;
24730 PyObject *swig_obj[1] ;
24731
24732 if (!args) SWIG_fail;
24733 swig_obj[0] = args;
24734 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24735 if (!SWIG_IsOK(res1)) {
24736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24737 }
24738 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24739 {
24740 PyThreadState* __tstate = wxPyBeginAllowThreads();
24741 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
24742 wxPyEndAllowThreads(__tstate);
24743 if (PyErr_Occurred()) SWIG_fail;
24744 }
24745 {
24746 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24747 }
24748 return resultobj;
24749 fail:
24750 return NULL;
24751 }
24752
24753
24754 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24755 PyObject *resultobj = 0;
24756 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24757 wxString result;
24758 void *argp1 = 0 ;
24759 int res1 = 0 ;
24760 PyObject *swig_obj[1] ;
24761
24762 if (!args) SWIG_fail;
24763 swig_obj[0] = args;
24764 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24765 if (!SWIG_IsOK(res1)) {
24766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24767 }
24768 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24769 {
24770 PyThreadState* __tstate = wxPyBeginAllowThreads();
24771 result = ((wxUpdateUIEvent const *)arg1)->GetText();
24772 wxPyEndAllowThreads(__tstate);
24773 if (PyErr_Occurred()) SWIG_fail;
24774 }
24775 {
24776 #if wxUSE_UNICODE
24777 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24778 #else
24779 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24780 #endif
24781 }
24782 return resultobj;
24783 fail:
24784 return NULL;
24785 }
24786
24787
24788 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24789 PyObject *resultobj = 0;
24790 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24791 bool result;
24792 void *argp1 = 0 ;
24793 int res1 = 0 ;
24794 PyObject *swig_obj[1] ;
24795
24796 if (!args) SWIG_fail;
24797 swig_obj[0] = args;
24798 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24799 if (!SWIG_IsOK(res1)) {
24800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24801 }
24802 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24803 {
24804 PyThreadState* __tstate = wxPyBeginAllowThreads();
24805 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
24806 wxPyEndAllowThreads(__tstate);
24807 if (PyErr_Occurred()) SWIG_fail;
24808 }
24809 {
24810 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24811 }
24812 return resultobj;
24813 fail:
24814 return NULL;
24815 }
24816
24817
24818 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24819 PyObject *resultobj = 0;
24820 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24821 bool result;
24822 void *argp1 = 0 ;
24823 int res1 = 0 ;
24824 PyObject *swig_obj[1] ;
24825
24826 if (!args) SWIG_fail;
24827 swig_obj[0] = args;
24828 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24829 if (!SWIG_IsOK(res1)) {
24830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24831 }
24832 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24833 {
24834 PyThreadState* __tstate = wxPyBeginAllowThreads();
24835 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
24836 wxPyEndAllowThreads(__tstate);
24837 if (PyErr_Occurred()) SWIG_fail;
24838 }
24839 {
24840 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24841 }
24842 return resultobj;
24843 fail:
24844 return NULL;
24845 }
24846
24847
24848 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24849 PyObject *resultobj = 0;
24850 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24851 bool result;
24852 void *argp1 = 0 ;
24853 int res1 = 0 ;
24854 PyObject *swig_obj[1] ;
24855
24856 if (!args) SWIG_fail;
24857 swig_obj[0] = args;
24858 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24859 if (!SWIG_IsOK(res1)) {
24860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24861 }
24862 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24863 {
24864 PyThreadState* __tstate = wxPyBeginAllowThreads();
24865 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
24866 wxPyEndAllowThreads(__tstate);
24867 if (PyErr_Occurred()) SWIG_fail;
24868 }
24869 {
24870 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24871 }
24872 return resultobj;
24873 fail:
24874 return NULL;
24875 }
24876
24877
24878 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24879 PyObject *resultobj = 0;
24880 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24881 bool result;
24882 void *argp1 = 0 ;
24883 int res1 = 0 ;
24884 PyObject *swig_obj[1] ;
24885
24886 if (!args) SWIG_fail;
24887 swig_obj[0] = args;
24888 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24889 if (!SWIG_IsOK(res1)) {
24890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24891 }
24892 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24893 {
24894 PyThreadState* __tstate = wxPyBeginAllowThreads();
24895 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
24896 wxPyEndAllowThreads(__tstate);
24897 if (PyErr_Occurred()) SWIG_fail;
24898 }
24899 {
24900 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24901 }
24902 return resultobj;
24903 fail:
24904 return NULL;
24905 }
24906
24907
24908 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24909 PyObject *resultobj = 0;
24910 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24911 bool arg2 ;
24912 void *argp1 = 0 ;
24913 int res1 = 0 ;
24914 bool val2 ;
24915 int ecode2 = 0 ;
24916 PyObject * obj0 = 0 ;
24917 PyObject * obj1 = 0 ;
24918 char * kwnames[] = {
24919 (char *) "self",(char *) "check", NULL
24920 };
24921
24922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
24923 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24924 if (!SWIG_IsOK(res1)) {
24925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
24926 }
24927 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24928 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24929 if (!SWIG_IsOK(ecode2)) {
24930 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
24931 }
24932 arg2 = static_cast< bool >(val2);
24933 {
24934 PyThreadState* __tstate = wxPyBeginAllowThreads();
24935 (arg1)->Check(arg2);
24936 wxPyEndAllowThreads(__tstate);
24937 if (PyErr_Occurred()) SWIG_fail;
24938 }
24939 resultobj = SWIG_Py_Void();
24940 return resultobj;
24941 fail:
24942 return NULL;
24943 }
24944
24945
24946 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24947 PyObject *resultobj = 0;
24948 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24949 bool arg2 ;
24950 void *argp1 = 0 ;
24951 int res1 = 0 ;
24952 bool val2 ;
24953 int ecode2 = 0 ;
24954 PyObject * obj0 = 0 ;
24955 PyObject * obj1 = 0 ;
24956 char * kwnames[] = {
24957 (char *) "self",(char *) "enable", NULL
24958 };
24959
24960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
24961 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24962 if (!SWIG_IsOK(res1)) {
24963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
24964 }
24965 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24966 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24967 if (!SWIG_IsOK(ecode2)) {
24968 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
24969 }
24970 arg2 = static_cast< bool >(val2);
24971 {
24972 PyThreadState* __tstate = wxPyBeginAllowThreads();
24973 (arg1)->Enable(arg2);
24974 wxPyEndAllowThreads(__tstate);
24975 if (PyErr_Occurred()) SWIG_fail;
24976 }
24977 resultobj = SWIG_Py_Void();
24978 return resultobj;
24979 fail:
24980 return NULL;
24981 }
24982
24983
24984 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24985 PyObject *resultobj = 0;
24986 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24987 bool arg2 ;
24988 void *argp1 = 0 ;
24989 int res1 = 0 ;
24990 bool val2 ;
24991 int ecode2 = 0 ;
24992 PyObject * obj0 = 0 ;
24993 PyObject * obj1 = 0 ;
24994 char * kwnames[] = {
24995 (char *) "self",(char *) "show", NULL
24996 };
24997
24998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
24999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25000 if (!SWIG_IsOK(res1)) {
25001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25002 }
25003 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25004 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25005 if (!SWIG_IsOK(ecode2)) {
25006 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
25007 }
25008 arg2 = static_cast< bool >(val2);
25009 {
25010 PyThreadState* __tstate = wxPyBeginAllowThreads();
25011 (arg1)->Show(arg2);
25012 wxPyEndAllowThreads(__tstate);
25013 if (PyErr_Occurred()) SWIG_fail;
25014 }
25015 resultobj = SWIG_Py_Void();
25016 return resultobj;
25017 fail:
25018 return NULL;
25019 }
25020
25021
25022 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25023 PyObject *resultobj = 0;
25024 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25025 wxString *arg2 = 0 ;
25026 void *argp1 = 0 ;
25027 int res1 = 0 ;
25028 bool temp2 = false ;
25029 PyObject * obj0 = 0 ;
25030 PyObject * obj1 = 0 ;
25031 char * kwnames[] = {
25032 (char *) "self",(char *) "text", NULL
25033 };
25034
25035 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
25036 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25037 if (!SWIG_IsOK(res1)) {
25038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25039 }
25040 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25041 {
25042 arg2 = wxString_in_helper(obj1);
25043 if (arg2 == NULL) SWIG_fail;
25044 temp2 = true;
25045 }
25046 {
25047 PyThreadState* __tstate = wxPyBeginAllowThreads();
25048 (arg1)->SetText((wxString const &)*arg2);
25049 wxPyEndAllowThreads(__tstate);
25050 if (PyErr_Occurred()) SWIG_fail;
25051 }
25052 resultobj = SWIG_Py_Void();
25053 {
25054 if (temp2)
25055 delete arg2;
25056 }
25057 return resultobj;
25058 fail:
25059 {
25060 if (temp2)
25061 delete arg2;
25062 }
25063 return NULL;
25064 }
25065
25066
25067 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25068 PyObject *resultobj = 0;
25069 long arg1 ;
25070 long val1 ;
25071 int ecode1 = 0 ;
25072 PyObject * obj0 = 0 ;
25073 char * kwnames[] = {
25074 (char *) "updateInterval", NULL
25075 };
25076
25077 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
25078 ecode1 = SWIG_AsVal_long(obj0, &val1);
25079 if (!SWIG_IsOK(ecode1)) {
25080 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
25081 }
25082 arg1 = static_cast< long >(val1);
25083 {
25084 PyThreadState* __tstate = wxPyBeginAllowThreads();
25085 wxUpdateUIEvent::SetUpdateInterval(arg1);
25086 wxPyEndAllowThreads(__tstate);
25087 if (PyErr_Occurred()) SWIG_fail;
25088 }
25089 resultobj = SWIG_Py_Void();
25090 return resultobj;
25091 fail:
25092 return NULL;
25093 }
25094
25095
25096 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25097 PyObject *resultobj = 0;
25098 long result;
25099
25100 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
25101 {
25102 PyThreadState* __tstate = wxPyBeginAllowThreads();
25103 result = (long)wxUpdateUIEvent::GetUpdateInterval();
25104 wxPyEndAllowThreads(__tstate);
25105 if (PyErr_Occurred()) SWIG_fail;
25106 }
25107 resultobj = SWIG_From_long(static_cast< long >(result));
25108 return resultobj;
25109 fail:
25110 return NULL;
25111 }
25112
25113
25114 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25115 PyObject *resultobj = 0;
25116 wxWindow *arg1 = (wxWindow *) 0 ;
25117 bool result;
25118 void *argp1 = 0 ;
25119 int res1 = 0 ;
25120 PyObject * obj0 = 0 ;
25121 char * kwnames[] = {
25122 (char *) "win", NULL
25123 };
25124
25125 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
25126 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25127 if (!SWIG_IsOK(res1)) {
25128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
25129 }
25130 arg1 = reinterpret_cast< wxWindow * >(argp1);
25131 {
25132 PyThreadState* __tstate = wxPyBeginAllowThreads();
25133 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
25134 wxPyEndAllowThreads(__tstate);
25135 if (PyErr_Occurred()) SWIG_fail;
25136 }
25137 {
25138 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25139 }
25140 return resultobj;
25141 fail:
25142 return NULL;
25143 }
25144
25145
25146 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25147 PyObject *resultobj = 0;
25148
25149 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
25150 {
25151 PyThreadState* __tstate = wxPyBeginAllowThreads();
25152 wxUpdateUIEvent::ResetUpdateTime();
25153 wxPyEndAllowThreads(__tstate);
25154 if (PyErr_Occurred()) SWIG_fail;
25155 }
25156 resultobj = SWIG_Py_Void();
25157 return resultobj;
25158 fail:
25159 return NULL;
25160 }
25161
25162
25163 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25164 PyObject *resultobj = 0;
25165 wxUpdateUIMode arg1 ;
25166 int val1 ;
25167 int ecode1 = 0 ;
25168 PyObject * obj0 = 0 ;
25169 char * kwnames[] = {
25170 (char *) "mode", NULL
25171 };
25172
25173 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
25174 ecode1 = SWIG_AsVal_int(obj0, &val1);
25175 if (!SWIG_IsOK(ecode1)) {
25176 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
25177 }
25178 arg1 = static_cast< wxUpdateUIMode >(val1);
25179 {
25180 PyThreadState* __tstate = wxPyBeginAllowThreads();
25181 wxUpdateUIEvent::SetMode(arg1);
25182 wxPyEndAllowThreads(__tstate);
25183 if (PyErr_Occurred()) SWIG_fail;
25184 }
25185 resultobj = SWIG_Py_Void();
25186 return resultobj;
25187 fail:
25188 return NULL;
25189 }
25190
25191
25192 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25193 PyObject *resultobj = 0;
25194 wxUpdateUIMode result;
25195
25196 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
25197 {
25198 PyThreadState* __tstate = wxPyBeginAllowThreads();
25199 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
25200 wxPyEndAllowThreads(__tstate);
25201 if (PyErr_Occurred()) SWIG_fail;
25202 }
25203 resultobj = SWIG_From_int(static_cast< int >(result));
25204 return resultobj;
25205 fail:
25206 return NULL;
25207 }
25208
25209
25210 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25211 PyObject *obj;
25212 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25213 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
25214 return SWIG_Py_Void();
25215 }
25216
25217 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25218 return SWIG_Python_InitShadowInstance(args);
25219 }
25220
25221 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25222 PyObject *resultobj = 0;
25223 wxSysColourChangedEvent *result = 0 ;
25224
25225 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
25226 {
25227 PyThreadState* __tstate = wxPyBeginAllowThreads();
25228 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
25229 wxPyEndAllowThreads(__tstate);
25230 if (PyErr_Occurred()) SWIG_fail;
25231 }
25232 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
25233 return resultobj;
25234 fail:
25235 return NULL;
25236 }
25237
25238
25239 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25240 PyObject *obj;
25241 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25242 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
25243 return SWIG_Py_Void();
25244 }
25245
25246 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25247 return SWIG_Python_InitShadowInstance(args);
25248 }
25249
25250 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25251 PyObject *resultobj = 0;
25252 int arg1 = (int) 0 ;
25253 wxWindow *arg2 = (wxWindow *) NULL ;
25254 wxMouseCaptureChangedEvent *result = 0 ;
25255 int val1 ;
25256 int ecode1 = 0 ;
25257 void *argp2 = 0 ;
25258 int res2 = 0 ;
25259 PyObject * obj0 = 0 ;
25260 PyObject * obj1 = 0 ;
25261 char * kwnames[] = {
25262 (char *) "winid",(char *) "gainedCapture", NULL
25263 };
25264
25265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25266 if (obj0) {
25267 ecode1 = SWIG_AsVal_int(obj0, &val1);
25268 if (!SWIG_IsOK(ecode1)) {
25269 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
25270 }
25271 arg1 = static_cast< int >(val1);
25272 }
25273 if (obj1) {
25274 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25275 if (!SWIG_IsOK(res2)) {
25276 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
25277 }
25278 arg2 = reinterpret_cast< wxWindow * >(argp2);
25279 }
25280 {
25281 PyThreadState* __tstate = wxPyBeginAllowThreads();
25282 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
25283 wxPyEndAllowThreads(__tstate);
25284 if (PyErr_Occurred()) SWIG_fail;
25285 }
25286 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
25287 return resultobj;
25288 fail:
25289 return NULL;
25290 }
25291
25292
25293 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25294 PyObject *resultobj = 0;
25295 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
25296 wxWindow *result = 0 ;
25297 void *argp1 = 0 ;
25298 int res1 = 0 ;
25299 PyObject *swig_obj[1] ;
25300
25301 if (!args) SWIG_fail;
25302 swig_obj[0] = args;
25303 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
25304 if (!SWIG_IsOK(res1)) {
25305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
25306 }
25307 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
25308 {
25309 PyThreadState* __tstate = wxPyBeginAllowThreads();
25310 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
25311 wxPyEndAllowThreads(__tstate);
25312 if (PyErr_Occurred()) SWIG_fail;
25313 }
25314 {
25315 resultobj = wxPyMake_wxObject(result, (bool)0);
25316 }
25317 return resultobj;
25318 fail:
25319 return NULL;
25320 }
25321
25322
25323 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25324 PyObject *obj;
25325 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25326 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
25327 return SWIG_Py_Void();
25328 }
25329
25330 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25331 return SWIG_Python_InitShadowInstance(args);
25332 }
25333
25334 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25335 PyObject *resultobj = 0;
25336 wxDisplayChangedEvent *result = 0 ;
25337
25338 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
25339 {
25340 PyThreadState* __tstate = wxPyBeginAllowThreads();
25341 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
25342 wxPyEndAllowThreads(__tstate);
25343 if (PyErr_Occurred()) SWIG_fail;
25344 }
25345 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
25346 return resultobj;
25347 fail:
25348 return NULL;
25349 }
25350
25351
25352 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25353 PyObject *obj;
25354 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25355 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
25356 return SWIG_Py_Void();
25357 }
25358
25359 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25360 return SWIG_Python_InitShadowInstance(args);
25361 }
25362
25363 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25364 PyObject *resultobj = 0;
25365 int arg1 = (int) 0 ;
25366 wxPaletteChangedEvent *result = 0 ;
25367 int val1 ;
25368 int ecode1 = 0 ;
25369 PyObject * obj0 = 0 ;
25370 char * kwnames[] = {
25371 (char *) "id", NULL
25372 };
25373
25374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
25375 if (obj0) {
25376 ecode1 = SWIG_AsVal_int(obj0, &val1);
25377 if (!SWIG_IsOK(ecode1)) {
25378 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
25379 }
25380 arg1 = static_cast< int >(val1);
25381 }
25382 {
25383 PyThreadState* __tstate = wxPyBeginAllowThreads();
25384 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
25385 wxPyEndAllowThreads(__tstate);
25386 if (PyErr_Occurred()) SWIG_fail;
25387 }
25388 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
25389 return resultobj;
25390 fail:
25391 return NULL;
25392 }
25393
25394
25395 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25396 PyObject *resultobj = 0;
25397 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25398 wxWindow *arg2 = (wxWindow *) 0 ;
25399 void *argp1 = 0 ;
25400 int res1 = 0 ;
25401 void *argp2 = 0 ;
25402 int res2 = 0 ;
25403 PyObject * obj0 = 0 ;
25404 PyObject * obj1 = 0 ;
25405 char * kwnames[] = {
25406 (char *) "self",(char *) "win", NULL
25407 };
25408
25409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
25410 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25411 if (!SWIG_IsOK(res1)) {
25412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25413 }
25414 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25415 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25416 if (!SWIG_IsOK(res2)) {
25417 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
25418 }
25419 arg2 = reinterpret_cast< wxWindow * >(argp2);
25420 {
25421 PyThreadState* __tstate = wxPyBeginAllowThreads();
25422 (arg1)->SetChangedWindow(arg2);
25423 wxPyEndAllowThreads(__tstate);
25424 if (PyErr_Occurred()) SWIG_fail;
25425 }
25426 resultobj = SWIG_Py_Void();
25427 return resultobj;
25428 fail:
25429 return NULL;
25430 }
25431
25432
25433 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25434 PyObject *resultobj = 0;
25435 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25436 wxWindow *result = 0 ;
25437 void *argp1 = 0 ;
25438 int res1 = 0 ;
25439 PyObject *swig_obj[1] ;
25440
25441 if (!args) SWIG_fail;
25442 swig_obj[0] = args;
25443 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25444 if (!SWIG_IsOK(res1)) {
25445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25446 }
25447 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25448 {
25449 PyThreadState* __tstate = wxPyBeginAllowThreads();
25450 result = (wxWindow *)(arg1)->GetChangedWindow();
25451 wxPyEndAllowThreads(__tstate);
25452 if (PyErr_Occurred()) SWIG_fail;
25453 }
25454 {
25455 resultobj = wxPyMake_wxObject(result, (bool)0);
25456 }
25457 return resultobj;
25458 fail:
25459 return NULL;
25460 }
25461
25462
25463 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25464 PyObject *obj;
25465 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25466 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
25467 return SWIG_Py_Void();
25468 }
25469
25470 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25471 return SWIG_Python_InitShadowInstance(args);
25472 }
25473
25474 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25475 PyObject *resultobj = 0;
25476 int arg1 = (int) 0 ;
25477 wxQueryNewPaletteEvent *result = 0 ;
25478 int val1 ;
25479 int ecode1 = 0 ;
25480 PyObject * obj0 = 0 ;
25481 char * kwnames[] = {
25482 (char *) "winid", NULL
25483 };
25484
25485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
25486 if (obj0) {
25487 ecode1 = SWIG_AsVal_int(obj0, &val1);
25488 if (!SWIG_IsOK(ecode1)) {
25489 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
25490 }
25491 arg1 = static_cast< int >(val1);
25492 }
25493 {
25494 PyThreadState* __tstate = wxPyBeginAllowThreads();
25495 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
25496 wxPyEndAllowThreads(__tstate);
25497 if (PyErr_Occurred()) SWIG_fail;
25498 }
25499 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
25500 return resultobj;
25501 fail:
25502 return NULL;
25503 }
25504
25505
25506 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25507 PyObject *resultobj = 0;
25508 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25509 bool arg2 ;
25510 void *argp1 = 0 ;
25511 int res1 = 0 ;
25512 bool val2 ;
25513 int ecode2 = 0 ;
25514 PyObject * obj0 = 0 ;
25515 PyObject * obj1 = 0 ;
25516 char * kwnames[] = {
25517 (char *) "self",(char *) "realized", NULL
25518 };
25519
25520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
25521 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25522 if (!SWIG_IsOK(res1)) {
25523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
25524 }
25525 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25526 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25527 if (!SWIG_IsOK(ecode2)) {
25528 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
25529 }
25530 arg2 = static_cast< bool >(val2);
25531 {
25532 PyThreadState* __tstate = wxPyBeginAllowThreads();
25533 (arg1)->SetPaletteRealized(arg2);
25534 wxPyEndAllowThreads(__tstate);
25535 if (PyErr_Occurred()) SWIG_fail;
25536 }
25537 resultobj = SWIG_Py_Void();
25538 return resultobj;
25539 fail:
25540 return NULL;
25541 }
25542
25543
25544 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25545 PyObject *resultobj = 0;
25546 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25547 bool result;
25548 void *argp1 = 0 ;
25549 int res1 = 0 ;
25550 PyObject *swig_obj[1] ;
25551
25552 if (!args) SWIG_fail;
25553 swig_obj[0] = args;
25554 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25555 if (!SWIG_IsOK(res1)) {
25556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
25557 }
25558 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25559 {
25560 PyThreadState* __tstate = wxPyBeginAllowThreads();
25561 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
25562 wxPyEndAllowThreads(__tstate);
25563 if (PyErr_Occurred()) SWIG_fail;
25564 }
25565 {
25566 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25567 }
25568 return resultobj;
25569 fail:
25570 return NULL;
25571 }
25572
25573
25574 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25575 PyObject *obj;
25576 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25577 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
25578 return SWIG_Py_Void();
25579 }
25580
25581 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25582 return SWIG_Python_InitShadowInstance(args);
25583 }
25584
25585 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25586 PyObject *resultobj = 0;
25587 wxNavigationKeyEvent *result = 0 ;
25588
25589 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
25590 {
25591 PyThreadState* __tstate = wxPyBeginAllowThreads();
25592 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
25593 wxPyEndAllowThreads(__tstate);
25594 if (PyErr_Occurred()) SWIG_fail;
25595 }
25596 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
25597 return resultobj;
25598 fail:
25599 return NULL;
25600 }
25601
25602
25603 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25604 PyObject *resultobj = 0;
25605 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25606 bool result;
25607 void *argp1 = 0 ;
25608 int res1 = 0 ;
25609 PyObject *swig_obj[1] ;
25610
25611 if (!args) SWIG_fail;
25612 swig_obj[0] = args;
25613 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25614 if (!SWIG_IsOK(res1)) {
25615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25616 }
25617 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25618 {
25619 PyThreadState* __tstate = wxPyBeginAllowThreads();
25620 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
25621 wxPyEndAllowThreads(__tstate);
25622 if (PyErr_Occurred()) SWIG_fail;
25623 }
25624 {
25625 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25626 }
25627 return resultobj;
25628 fail:
25629 return NULL;
25630 }
25631
25632
25633 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25634 PyObject *resultobj = 0;
25635 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25636 bool arg2 ;
25637 void *argp1 = 0 ;
25638 int res1 = 0 ;
25639 bool val2 ;
25640 int ecode2 = 0 ;
25641 PyObject * obj0 = 0 ;
25642 PyObject * obj1 = 0 ;
25643 char * kwnames[] = {
25644 (char *) "self",(char *) "forward", NULL
25645 };
25646
25647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
25648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25649 if (!SWIG_IsOK(res1)) {
25650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25651 }
25652 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25653 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25654 if (!SWIG_IsOK(ecode2)) {
25655 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
25656 }
25657 arg2 = static_cast< bool >(val2);
25658 {
25659 PyThreadState* __tstate = wxPyBeginAllowThreads();
25660 (arg1)->SetDirection(arg2);
25661 wxPyEndAllowThreads(__tstate);
25662 if (PyErr_Occurred()) SWIG_fail;
25663 }
25664 resultobj = SWIG_Py_Void();
25665 return resultobj;
25666 fail:
25667 return NULL;
25668 }
25669
25670
25671 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25672 PyObject *resultobj = 0;
25673 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25674 bool result;
25675 void *argp1 = 0 ;
25676 int res1 = 0 ;
25677 PyObject *swig_obj[1] ;
25678
25679 if (!args) SWIG_fail;
25680 swig_obj[0] = args;
25681 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25682 if (!SWIG_IsOK(res1)) {
25683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25684 }
25685 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25686 {
25687 PyThreadState* __tstate = wxPyBeginAllowThreads();
25688 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
25689 wxPyEndAllowThreads(__tstate);
25690 if (PyErr_Occurred()) SWIG_fail;
25691 }
25692 {
25693 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25694 }
25695 return resultobj;
25696 fail:
25697 return NULL;
25698 }
25699
25700
25701 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25702 PyObject *resultobj = 0;
25703 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25704 bool arg2 ;
25705 void *argp1 = 0 ;
25706 int res1 = 0 ;
25707 bool val2 ;
25708 int ecode2 = 0 ;
25709 PyObject * obj0 = 0 ;
25710 PyObject * obj1 = 0 ;
25711 char * kwnames[] = {
25712 (char *) "self",(char *) "ischange", NULL
25713 };
25714
25715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
25716 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25717 if (!SWIG_IsOK(res1)) {
25718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25719 }
25720 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25721 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25722 if (!SWIG_IsOK(ecode2)) {
25723 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
25724 }
25725 arg2 = static_cast< bool >(val2);
25726 {
25727 PyThreadState* __tstate = wxPyBeginAllowThreads();
25728 (arg1)->SetWindowChange(arg2);
25729 wxPyEndAllowThreads(__tstate);
25730 if (PyErr_Occurred()) SWIG_fail;
25731 }
25732 resultobj = SWIG_Py_Void();
25733 return resultobj;
25734 fail:
25735 return NULL;
25736 }
25737
25738
25739 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25740 PyObject *resultobj = 0;
25741 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25742 bool result;
25743 void *argp1 = 0 ;
25744 int res1 = 0 ;
25745 PyObject *swig_obj[1] ;
25746
25747 if (!args) SWIG_fail;
25748 swig_obj[0] = args;
25749 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25750 if (!SWIG_IsOK(res1)) {
25751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25752 }
25753 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25754 {
25755 PyThreadState* __tstate = wxPyBeginAllowThreads();
25756 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
25757 wxPyEndAllowThreads(__tstate);
25758 if (PyErr_Occurred()) SWIG_fail;
25759 }
25760 {
25761 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25762 }
25763 return resultobj;
25764 fail:
25765 return NULL;
25766 }
25767
25768
25769 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25770 PyObject *resultobj = 0;
25771 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25772 bool arg2 ;
25773 void *argp1 = 0 ;
25774 int res1 = 0 ;
25775 bool val2 ;
25776 int ecode2 = 0 ;
25777 PyObject * obj0 = 0 ;
25778 PyObject * obj1 = 0 ;
25779 char * kwnames[] = {
25780 (char *) "self",(char *) "bIs", NULL
25781 };
25782
25783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
25784 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25785 if (!SWIG_IsOK(res1)) {
25786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25787 }
25788 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25789 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25790 if (!SWIG_IsOK(ecode2)) {
25791 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
25792 }
25793 arg2 = static_cast< bool >(val2);
25794 {
25795 PyThreadState* __tstate = wxPyBeginAllowThreads();
25796 (arg1)->SetFromTab(arg2);
25797 wxPyEndAllowThreads(__tstate);
25798 if (PyErr_Occurred()) SWIG_fail;
25799 }
25800 resultobj = SWIG_Py_Void();
25801 return resultobj;
25802 fail:
25803 return NULL;
25804 }
25805
25806
25807 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25808 PyObject *resultobj = 0;
25809 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25810 long arg2 ;
25811 void *argp1 = 0 ;
25812 int res1 = 0 ;
25813 long val2 ;
25814 int ecode2 = 0 ;
25815 PyObject * obj0 = 0 ;
25816 PyObject * obj1 = 0 ;
25817 char * kwnames[] = {
25818 (char *) "self",(char *) "flags", NULL
25819 };
25820
25821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
25822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25823 if (!SWIG_IsOK(res1)) {
25824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25825 }
25826 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25827 ecode2 = SWIG_AsVal_long(obj1, &val2);
25828 if (!SWIG_IsOK(ecode2)) {
25829 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
25830 }
25831 arg2 = static_cast< long >(val2);
25832 {
25833 PyThreadState* __tstate = wxPyBeginAllowThreads();
25834 (arg1)->SetFlags(arg2);
25835 wxPyEndAllowThreads(__tstate);
25836 if (PyErr_Occurred()) SWIG_fail;
25837 }
25838 resultobj = SWIG_Py_Void();
25839 return resultobj;
25840 fail:
25841 return NULL;
25842 }
25843
25844
25845 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25846 PyObject *resultobj = 0;
25847 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25848 wxWindow *result = 0 ;
25849 void *argp1 = 0 ;
25850 int res1 = 0 ;
25851 PyObject *swig_obj[1] ;
25852
25853 if (!args) SWIG_fail;
25854 swig_obj[0] = args;
25855 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25856 if (!SWIG_IsOK(res1)) {
25857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25858 }
25859 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25860 {
25861 PyThreadState* __tstate = wxPyBeginAllowThreads();
25862 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
25863 wxPyEndAllowThreads(__tstate);
25864 if (PyErr_Occurred()) SWIG_fail;
25865 }
25866 {
25867 resultobj = wxPyMake_wxObject(result, (bool)0);
25868 }
25869 return resultobj;
25870 fail:
25871 return NULL;
25872 }
25873
25874
25875 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25876 PyObject *resultobj = 0;
25877 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25878 wxWindow *arg2 = (wxWindow *) 0 ;
25879 void *argp1 = 0 ;
25880 int res1 = 0 ;
25881 void *argp2 = 0 ;
25882 int res2 = 0 ;
25883 PyObject * obj0 = 0 ;
25884 PyObject * obj1 = 0 ;
25885 char * kwnames[] = {
25886 (char *) "self",(char *) "win", NULL
25887 };
25888
25889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
25890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25891 if (!SWIG_IsOK(res1)) {
25892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25893 }
25894 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25895 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25896 if (!SWIG_IsOK(res2)) {
25897 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
25898 }
25899 arg2 = reinterpret_cast< wxWindow * >(argp2);
25900 {
25901 PyThreadState* __tstate = wxPyBeginAllowThreads();
25902 (arg1)->SetCurrentFocus(arg2);
25903 wxPyEndAllowThreads(__tstate);
25904 if (PyErr_Occurred()) SWIG_fail;
25905 }
25906 resultobj = SWIG_Py_Void();
25907 return resultobj;
25908 fail:
25909 return NULL;
25910 }
25911
25912
25913 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25914 PyObject *obj;
25915 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25916 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
25917 return SWIG_Py_Void();
25918 }
25919
25920 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25921 return SWIG_Python_InitShadowInstance(args);
25922 }
25923
25924 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25925 PyObject *resultobj = 0;
25926 wxWindow *arg1 = (wxWindow *) NULL ;
25927 wxWindowCreateEvent *result = 0 ;
25928 void *argp1 = 0 ;
25929 int res1 = 0 ;
25930 PyObject * obj0 = 0 ;
25931 char * kwnames[] = {
25932 (char *) "win", NULL
25933 };
25934
25935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
25936 if (obj0) {
25937 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25938 if (!SWIG_IsOK(res1)) {
25939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
25940 }
25941 arg1 = reinterpret_cast< wxWindow * >(argp1);
25942 }
25943 {
25944 PyThreadState* __tstate = wxPyBeginAllowThreads();
25945 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
25946 wxPyEndAllowThreads(__tstate);
25947 if (PyErr_Occurred()) SWIG_fail;
25948 }
25949 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
25950 return resultobj;
25951 fail:
25952 return NULL;
25953 }
25954
25955
25956 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25957 PyObject *resultobj = 0;
25958 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
25959 wxWindow *result = 0 ;
25960 void *argp1 = 0 ;
25961 int res1 = 0 ;
25962 PyObject *swig_obj[1] ;
25963
25964 if (!args) SWIG_fail;
25965 swig_obj[0] = args;
25966 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
25967 if (!SWIG_IsOK(res1)) {
25968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
25969 }
25970 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
25971 {
25972 PyThreadState* __tstate = wxPyBeginAllowThreads();
25973 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
25974 wxPyEndAllowThreads(__tstate);
25975 if (PyErr_Occurred()) SWIG_fail;
25976 }
25977 {
25978 resultobj = wxPyMake_wxObject(result, (bool)0);
25979 }
25980 return resultobj;
25981 fail:
25982 return NULL;
25983 }
25984
25985
25986 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25987 PyObject *obj;
25988 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25989 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
25990 return SWIG_Py_Void();
25991 }
25992
25993 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25994 return SWIG_Python_InitShadowInstance(args);
25995 }
25996
25997 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25998 PyObject *resultobj = 0;
25999 wxWindow *arg1 = (wxWindow *) NULL ;
26000 wxWindowDestroyEvent *result = 0 ;
26001 void *argp1 = 0 ;
26002 int res1 = 0 ;
26003 PyObject * obj0 = 0 ;
26004 char * kwnames[] = {
26005 (char *) "win", NULL
26006 };
26007
26008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
26009 if (obj0) {
26010 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26011 if (!SWIG_IsOK(res1)) {
26012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26013 }
26014 arg1 = reinterpret_cast< wxWindow * >(argp1);
26015 }
26016 {
26017 PyThreadState* __tstate = wxPyBeginAllowThreads();
26018 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
26019 wxPyEndAllowThreads(__tstate);
26020 if (PyErr_Occurred()) SWIG_fail;
26021 }
26022 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
26023 return resultobj;
26024 fail:
26025 return NULL;
26026 }
26027
26028
26029 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26030 PyObject *resultobj = 0;
26031 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
26032 wxWindow *result = 0 ;
26033 void *argp1 = 0 ;
26034 int res1 = 0 ;
26035 PyObject *swig_obj[1] ;
26036
26037 if (!args) SWIG_fail;
26038 swig_obj[0] = args;
26039 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
26040 if (!SWIG_IsOK(res1)) {
26041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
26042 }
26043 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
26044 {
26045 PyThreadState* __tstate = wxPyBeginAllowThreads();
26046 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
26047 wxPyEndAllowThreads(__tstate);
26048 if (PyErr_Occurred()) SWIG_fail;
26049 }
26050 {
26051 resultobj = wxPyMake_wxObject(result, (bool)0);
26052 }
26053 return resultobj;
26054 fail:
26055 return NULL;
26056 }
26057
26058
26059 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26060 PyObject *obj;
26061 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26062 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
26063 return SWIG_Py_Void();
26064 }
26065
26066 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26067 return SWIG_Python_InitShadowInstance(args);
26068 }
26069
26070 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26071 PyObject *resultobj = 0;
26072 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26073 int arg2 = (int) 0 ;
26074 wxPoint const &arg3_defvalue = wxDefaultPosition ;
26075 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
26076 wxContextMenuEvent *result = 0 ;
26077 int val1 ;
26078 int ecode1 = 0 ;
26079 int val2 ;
26080 int ecode2 = 0 ;
26081 wxPoint temp3 ;
26082 PyObject * obj0 = 0 ;
26083 PyObject * obj1 = 0 ;
26084 PyObject * obj2 = 0 ;
26085 char * kwnames[] = {
26086 (char *) "type",(char *) "winid",(char *) "pt", NULL
26087 };
26088
26089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26090 if (obj0) {
26091 ecode1 = SWIG_AsVal_int(obj0, &val1);
26092 if (!SWIG_IsOK(ecode1)) {
26093 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26094 }
26095 arg1 = static_cast< wxEventType >(val1);
26096 }
26097 if (obj1) {
26098 ecode2 = SWIG_AsVal_int(obj1, &val2);
26099 if (!SWIG_IsOK(ecode2)) {
26100 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
26101 }
26102 arg2 = static_cast< int >(val2);
26103 }
26104 if (obj2) {
26105 {
26106 arg3 = &temp3;
26107 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
26108 }
26109 }
26110 {
26111 PyThreadState* __tstate = wxPyBeginAllowThreads();
26112 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
26113 wxPyEndAllowThreads(__tstate);
26114 if (PyErr_Occurred()) SWIG_fail;
26115 }
26116 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
26117 return resultobj;
26118 fail:
26119 return NULL;
26120 }
26121
26122
26123 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26124 PyObject *resultobj = 0;
26125 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26126 wxPoint *result = 0 ;
26127 void *argp1 = 0 ;
26128 int res1 = 0 ;
26129 PyObject *swig_obj[1] ;
26130
26131 if (!args) SWIG_fail;
26132 swig_obj[0] = args;
26133 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26134 if (!SWIG_IsOK(res1)) {
26135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
26136 }
26137 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26138 {
26139 PyThreadState* __tstate = wxPyBeginAllowThreads();
26140 {
26141 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
26142 result = (wxPoint *) &_result_ref;
26143 }
26144 wxPyEndAllowThreads(__tstate);
26145 if (PyErr_Occurred()) SWIG_fail;
26146 }
26147 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
26148 return resultobj;
26149 fail:
26150 return NULL;
26151 }
26152
26153
26154 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26155 PyObject *resultobj = 0;
26156 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26157 wxPoint *arg2 = 0 ;
26158 void *argp1 = 0 ;
26159 int res1 = 0 ;
26160 wxPoint temp2 ;
26161 PyObject * obj0 = 0 ;
26162 PyObject * obj1 = 0 ;
26163 char * kwnames[] = {
26164 (char *) "self",(char *) "pos", NULL
26165 };
26166
26167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26168 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26169 if (!SWIG_IsOK(res1)) {
26170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
26171 }
26172 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26173 {
26174 arg2 = &temp2;
26175 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26176 }
26177 {
26178 PyThreadState* __tstate = wxPyBeginAllowThreads();
26179 (arg1)->SetPosition((wxPoint const &)*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 *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26191 PyObject *obj;
26192 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26193 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
26194 return SWIG_Py_Void();
26195 }
26196
26197 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26198 return SWIG_Python_InitShadowInstance(args);
26199 }
26200
26201 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26202 PyObject *resultobj = 0;
26203 wxIdleEvent *result = 0 ;
26204
26205 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
26206 {
26207 PyThreadState* __tstate = wxPyBeginAllowThreads();
26208 result = (wxIdleEvent *)new wxIdleEvent();
26209 wxPyEndAllowThreads(__tstate);
26210 if (PyErr_Occurred()) SWIG_fail;
26211 }
26212 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
26213 return resultobj;
26214 fail:
26215 return NULL;
26216 }
26217
26218
26219 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26220 PyObject *resultobj = 0;
26221 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26222 bool arg2 = (bool) true ;
26223 void *argp1 = 0 ;
26224 int res1 = 0 ;
26225 bool val2 ;
26226 int ecode2 = 0 ;
26227 PyObject * obj0 = 0 ;
26228 PyObject * obj1 = 0 ;
26229 char * kwnames[] = {
26230 (char *) "self",(char *) "needMore", NULL
26231 };
26232
26233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
26234 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26235 if (!SWIG_IsOK(res1)) {
26236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
26237 }
26238 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26239 if (obj1) {
26240 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26241 if (!SWIG_IsOK(ecode2)) {
26242 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
26243 }
26244 arg2 = static_cast< bool >(val2);
26245 }
26246 {
26247 PyThreadState* __tstate = wxPyBeginAllowThreads();
26248 (arg1)->RequestMore(arg2);
26249 wxPyEndAllowThreads(__tstate);
26250 if (PyErr_Occurred()) SWIG_fail;
26251 }
26252 resultobj = SWIG_Py_Void();
26253 return resultobj;
26254 fail:
26255 return NULL;
26256 }
26257
26258
26259 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26260 PyObject *resultobj = 0;
26261 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26262 bool result;
26263 void *argp1 = 0 ;
26264 int res1 = 0 ;
26265 PyObject *swig_obj[1] ;
26266
26267 if (!args) SWIG_fail;
26268 swig_obj[0] = args;
26269 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26270 if (!SWIG_IsOK(res1)) {
26271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
26272 }
26273 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26274 {
26275 PyThreadState* __tstate = wxPyBeginAllowThreads();
26276 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
26277 wxPyEndAllowThreads(__tstate);
26278 if (PyErr_Occurred()) SWIG_fail;
26279 }
26280 {
26281 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26282 }
26283 return resultobj;
26284 fail:
26285 return NULL;
26286 }
26287
26288
26289 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26290 PyObject *resultobj = 0;
26291 wxIdleMode arg1 ;
26292 int val1 ;
26293 int ecode1 = 0 ;
26294 PyObject * obj0 = 0 ;
26295 char * kwnames[] = {
26296 (char *) "mode", NULL
26297 };
26298
26299 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
26300 ecode1 = SWIG_AsVal_int(obj0, &val1);
26301 if (!SWIG_IsOK(ecode1)) {
26302 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
26303 }
26304 arg1 = static_cast< wxIdleMode >(val1);
26305 {
26306 PyThreadState* __tstate = wxPyBeginAllowThreads();
26307 wxIdleEvent::SetMode(arg1);
26308 wxPyEndAllowThreads(__tstate);
26309 if (PyErr_Occurred()) SWIG_fail;
26310 }
26311 resultobj = SWIG_Py_Void();
26312 return resultobj;
26313 fail:
26314 return NULL;
26315 }
26316
26317
26318 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26319 PyObject *resultobj = 0;
26320 wxIdleMode result;
26321
26322 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
26323 {
26324 PyThreadState* __tstate = wxPyBeginAllowThreads();
26325 result = (wxIdleMode)wxIdleEvent::GetMode();
26326 wxPyEndAllowThreads(__tstate);
26327 if (PyErr_Occurred()) SWIG_fail;
26328 }
26329 resultobj = SWIG_From_int(static_cast< int >(result));
26330 return resultobj;
26331 fail:
26332 return NULL;
26333 }
26334
26335
26336 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26337 PyObject *resultobj = 0;
26338 wxWindow *arg1 = (wxWindow *) 0 ;
26339 bool result;
26340 void *argp1 = 0 ;
26341 int res1 = 0 ;
26342 PyObject * obj0 = 0 ;
26343 char * kwnames[] = {
26344 (char *) "win", NULL
26345 };
26346
26347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
26348 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26349 if (!SWIG_IsOK(res1)) {
26350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
26351 }
26352 arg1 = reinterpret_cast< wxWindow * >(argp1);
26353 {
26354 PyThreadState* __tstate = wxPyBeginAllowThreads();
26355 result = (bool)wxIdleEvent::CanSend(arg1);
26356 wxPyEndAllowThreads(__tstate);
26357 if (PyErr_Occurred()) SWIG_fail;
26358 }
26359 {
26360 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26361 }
26362 return resultobj;
26363 fail:
26364 return NULL;
26365 }
26366
26367
26368 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26369 PyObject *obj;
26370 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26371 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
26372 return SWIG_Py_Void();
26373 }
26374
26375 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26376 return SWIG_Python_InitShadowInstance(args);
26377 }
26378
26379 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26380 PyObject *resultobj = 0;
26381 int arg1 = (int) 0 ;
26382 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
26383 wxPyEvent *result = 0 ;
26384 int val1 ;
26385 int ecode1 = 0 ;
26386 int val2 ;
26387 int ecode2 = 0 ;
26388 PyObject * obj0 = 0 ;
26389 PyObject * obj1 = 0 ;
26390 char * kwnames[] = {
26391 (char *) "winid",(char *) "eventType", NULL
26392 };
26393
26394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26395 if (obj0) {
26396 ecode1 = SWIG_AsVal_int(obj0, &val1);
26397 if (!SWIG_IsOK(ecode1)) {
26398 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
26399 }
26400 arg1 = static_cast< int >(val1);
26401 }
26402 if (obj1) {
26403 ecode2 = SWIG_AsVal_int(obj1, &val2);
26404 if (!SWIG_IsOK(ecode2)) {
26405 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
26406 }
26407 arg2 = static_cast< wxEventType >(val2);
26408 }
26409 {
26410 PyThreadState* __tstate = wxPyBeginAllowThreads();
26411 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
26412 wxPyEndAllowThreads(__tstate);
26413 if (PyErr_Occurred()) SWIG_fail;
26414 }
26415 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
26416 return resultobj;
26417 fail:
26418 return NULL;
26419 }
26420
26421
26422 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26423 PyObject *resultobj = 0;
26424 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26425 void *argp1 = 0 ;
26426 int res1 = 0 ;
26427 PyObject *swig_obj[1] ;
26428
26429 if (!args) SWIG_fail;
26430 swig_obj[0] = args;
26431 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
26432 if (!SWIG_IsOK(res1)) {
26433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26434 }
26435 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26436 {
26437 PyThreadState* __tstate = wxPyBeginAllowThreads();
26438 delete arg1;
26439
26440 wxPyEndAllowThreads(__tstate);
26441 if (PyErr_Occurred()) SWIG_fail;
26442 }
26443 resultobj = SWIG_Py_Void();
26444 return resultobj;
26445 fail:
26446 return NULL;
26447 }
26448
26449
26450 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26451 PyObject *resultobj = 0;
26452 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26453 PyObject *arg2 = (PyObject *) 0 ;
26454 void *argp1 = 0 ;
26455 int res1 = 0 ;
26456 PyObject * obj0 = 0 ;
26457 PyObject * obj1 = 0 ;
26458 char * kwnames[] = {
26459 (char *) "self",(char *) "self", NULL
26460 };
26461
26462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26463 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26464 if (!SWIG_IsOK(res1)) {
26465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26466 }
26467 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26468 arg2 = obj1;
26469 {
26470 PyThreadState* __tstate = wxPyBeginAllowThreads();
26471 (arg1)->SetSelf(arg2);
26472 wxPyEndAllowThreads(__tstate);
26473 if (PyErr_Occurred()) SWIG_fail;
26474 }
26475 resultobj = SWIG_Py_Void();
26476 return resultobj;
26477 fail:
26478 return NULL;
26479 }
26480
26481
26482 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26483 PyObject *resultobj = 0;
26484 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26485 PyObject *result = 0 ;
26486 void *argp1 = 0 ;
26487 int res1 = 0 ;
26488 PyObject *swig_obj[1] ;
26489
26490 if (!args) SWIG_fail;
26491 swig_obj[0] = args;
26492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26493 if (!SWIG_IsOK(res1)) {
26494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26495 }
26496 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26497 {
26498 PyThreadState* __tstate = wxPyBeginAllowThreads();
26499 result = (PyObject *)(arg1)->GetSelf();
26500 wxPyEndAllowThreads(__tstate);
26501 if (PyErr_Occurred()) SWIG_fail;
26502 }
26503 resultobj = result;
26504 return resultobj;
26505 fail:
26506 return NULL;
26507 }
26508
26509
26510 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26511 PyObject *obj;
26512 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26513 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
26514 return SWIG_Py_Void();
26515 }
26516
26517 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26518 return SWIG_Python_InitShadowInstance(args);
26519 }
26520
26521 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26522 PyObject *resultobj = 0;
26523 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26524 int arg2 = (int) 0 ;
26525 wxPyCommandEvent *result = 0 ;
26526 int val1 ;
26527 int ecode1 = 0 ;
26528 int val2 ;
26529 int ecode2 = 0 ;
26530 PyObject * obj0 = 0 ;
26531 PyObject * obj1 = 0 ;
26532 char * kwnames[] = {
26533 (char *) "eventType",(char *) "id", NULL
26534 };
26535
26536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26537 if (obj0) {
26538 ecode1 = SWIG_AsVal_int(obj0, &val1);
26539 if (!SWIG_IsOK(ecode1)) {
26540 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26541 }
26542 arg1 = static_cast< wxEventType >(val1);
26543 }
26544 if (obj1) {
26545 ecode2 = SWIG_AsVal_int(obj1, &val2);
26546 if (!SWIG_IsOK(ecode2)) {
26547 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
26548 }
26549 arg2 = static_cast< int >(val2);
26550 }
26551 {
26552 PyThreadState* __tstate = wxPyBeginAllowThreads();
26553 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
26554 wxPyEndAllowThreads(__tstate);
26555 if (PyErr_Occurred()) SWIG_fail;
26556 }
26557 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
26558 return resultobj;
26559 fail:
26560 return NULL;
26561 }
26562
26563
26564 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26565 PyObject *resultobj = 0;
26566 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26567 void *argp1 = 0 ;
26568 int res1 = 0 ;
26569 PyObject *swig_obj[1] ;
26570
26571 if (!args) SWIG_fail;
26572 swig_obj[0] = args;
26573 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
26574 if (!SWIG_IsOK(res1)) {
26575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26576 }
26577 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26578 {
26579 PyThreadState* __tstate = wxPyBeginAllowThreads();
26580 delete arg1;
26581
26582 wxPyEndAllowThreads(__tstate);
26583 if (PyErr_Occurred()) SWIG_fail;
26584 }
26585 resultobj = SWIG_Py_Void();
26586 return resultobj;
26587 fail:
26588 return NULL;
26589 }
26590
26591
26592 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26593 PyObject *resultobj = 0;
26594 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26595 PyObject *arg2 = (PyObject *) 0 ;
26596 void *argp1 = 0 ;
26597 int res1 = 0 ;
26598 PyObject * obj0 = 0 ;
26599 PyObject * obj1 = 0 ;
26600 char * kwnames[] = {
26601 (char *) "self",(char *) "self", NULL
26602 };
26603
26604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26605 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26606 if (!SWIG_IsOK(res1)) {
26607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26608 }
26609 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26610 arg2 = obj1;
26611 {
26612 PyThreadState* __tstate = wxPyBeginAllowThreads();
26613 (arg1)->SetSelf(arg2);
26614 wxPyEndAllowThreads(__tstate);
26615 if (PyErr_Occurred()) SWIG_fail;
26616 }
26617 resultobj = SWIG_Py_Void();
26618 return resultobj;
26619 fail:
26620 return NULL;
26621 }
26622
26623
26624 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26625 PyObject *resultobj = 0;
26626 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26627 PyObject *result = 0 ;
26628 void *argp1 = 0 ;
26629 int res1 = 0 ;
26630 PyObject *swig_obj[1] ;
26631
26632 if (!args) SWIG_fail;
26633 swig_obj[0] = args;
26634 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26635 if (!SWIG_IsOK(res1)) {
26636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26637 }
26638 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26639 {
26640 PyThreadState* __tstate = wxPyBeginAllowThreads();
26641 result = (PyObject *)(arg1)->GetSelf();
26642 wxPyEndAllowThreads(__tstate);
26643 if (PyErr_Occurred()) SWIG_fail;
26644 }
26645 resultobj = result;
26646 return resultobj;
26647 fail:
26648 return NULL;
26649 }
26650
26651
26652 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26653 PyObject *obj;
26654 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26655 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
26656 return SWIG_Py_Void();
26657 }
26658
26659 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26660 return SWIG_Python_InitShadowInstance(args);
26661 }
26662
26663 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26664 PyObject *resultobj = 0;
26665 wxWindow *arg1 = (wxWindow *) 0 ;
26666 wxDateTime *arg2 = 0 ;
26667 wxEventType arg3 ;
26668 wxDateEvent *result = 0 ;
26669 void *argp1 = 0 ;
26670 int res1 = 0 ;
26671 void *argp2 = 0 ;
26672 int res2 = 0 ;
26673 int val3 ;
26674 int ecode3 = 0 ;
26675 PyObject * obj0 = 0 ;
26676 PyObject * obj1 = 0 ;
26677 PyObject * obj2 = 0 ;
26678 char * kwnames[] = {
26679 (char *) "win",(char *) "dt",(char *) "type", NULL
26680 };
26681
26682 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26683 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26684 if (!SWIG_IsOK(res1)) {
26685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26686 }
26687 arg1 = reinterpret_cast< wxWindow * >(argp1);
26688 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26689 if (!SWIG_IsOK(res2)) {
26690 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26691 }
26692 if (!argp2) {
26693 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26694 }
26695 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26696 ecode3 = SWIG_AsVal_int(obj2, &val3);
26697 if (!SWIG_IsOK(ecode3)) {
26698 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
26699 }
26700 arg3 = static_cast< wxEventType >(val3);
26701 {
26702 PyThreadState* __tstate = wxPyBeginAllowThreads();
26703 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
26704 wxPyEndAllowThreads(__tstate);
26705 if (PyErr_Occurred()) SWIG_fail;
26706 }
26707 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
26708 return resultobj;
26709 fail:
26710 return NULL;
26711 }
26712
26713
26714 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26715 PyObject *resultobj = 0;
26716 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
26717 wxDateTime *result = 0 ;
26718 void *argp1 = 0 ;
26719 int res1 = 0 ;
26720 PyObject *swig_obj[1] ;
26721
26722 if (!args) SWIG_fail;
26723 swig_obj[0] = args;
26724 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
26725 if (!SWIG_IsOK(res1)) {
26726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
26727 }
26728 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
26729 {
26730 PyThreadState* __tstate = wxPyBeginAllowThreads();
26731 {
26732 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
26733 result = (wxDateTime *) &_result_ref;
26734 }
26735 wxPyEndAllowThreads(__tstate);
26736 if (PyErr_Occurred()) SWIG_fail;
26737 }
26738 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26739 return resultobj;
26740 fail:
26741 return NULL;
26742 }
26743
26744
26745 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26746 PyObject *resultobj = 0;
26747 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
26748 wxDateTime *arg2 = 0 ;
26749 void *argp1 = 0 ;
26750 int res1 = 0 ;
26751 void *argp2 = 0 ;
26752 int res2 = 0 ;
26753 PyObject * obj0 = 0 ;
26754 PyObject * obj1 = 0 ;
26755 char * kwnames[] = {
26756 (char *) "self",(char *) "date", NULL
26757 };
26758
26759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
26760 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
26761 if (!SWIG_IsOK(res1)) {
26762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
26763 }
26764 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
26765 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26766 if (!SWIG_IsOK(res2)) {
26767 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26768 }
26769 if (!argp2) {
26770 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26771 }
26772 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26773 {
26774 PyThreadState* __tstate = wxPyBeginAllowThreads();
26775 (arg1)->SetDate((wxDateTime const &)*arg2);
26776 wxPyEndAllowThreads(__tstate);
26777 if (PyErr_Occurred()) SWIG_fail;
26778 }
26779 resultobj = SWIG_Py_Void();
26780 return resultobj;
26781 fail:
26782 return NULL;
26783 }
26784
26785
26786 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26787 PyObject *obj;
26788 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26789 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
26790 return SWIG_Py_Void();
26791 }
26792
26793 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26794 return SWIG_Python_InitShadowInstance(args);
26795 }
26796
26797 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26798 PyObject *resultobj = 0;
26799 wxPyApp *result = 0 ;
26800
26801 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
26802 {
26803 PyThreadState* __tstate = wxPyBeginAllowThreads();
26804 result = (wxPyApp *)new_wxPyApp();
26805 wxPyEndAllowThreads(__tstate);
26806 if (PyErr_Occurred()) SWIG_fail;
26807 }
26808 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
26809 return resultobj;
26810 fail:
26811 return NULL;
26812 }
26813
26814
26815 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26816 PyObject *resultobj = 0;
26817 wxPyApp *arg1 = (wxPyApp *) 0 ;
26818 void *argp1 = 0 ;
26819 int res1 = 0 ;
26820 PyObject *swig_obj[1] ;
26821
26822 if (!args) SWIG_fail;
26823 swig_obj[0] = args;
26824 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
26825 if (!SWIG_IsOK(res1)) {
26826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
26827 }
26828 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26829 {
26830 PyThreadState* __tstate = wxPyBeginAllowThreads();
26831 delete arg1;
26832
26833 wxPyEndAllowThreads(__tstate);
26834 if (PyErr_Occurred()) SWIG_fail;
26835 }
26836 resultobj = SWIG_Py_Void();
26837 return resultobj;
26838 fail:
26839 return NULL;
26840 }
26841
26842
26843 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26844 PyObject *resultobj = 0;
26845 wxPyApp *arg1 = (wxPyApp *) 0 ;
26846 PyObject *arg2 = (PyObject *) 0 ;
26847 PyObject *arg3 = (PyObject *) 0 ;
26848 bool arg4 ;
26849 void *argp1 = 0 ;
26850 int res1 = 0 ;
26851 bool val4 ;
26852 int ecode4 = 0 ;
26853 PyObject * obj0 = 0 ;
26854 PyObject * obj1 = 0 ;
26855 PyObject * obj2 = 0 ;
26856 PyObject * obj3 = 0 ;
26857 char * kwnames[] = {
26858 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
26859 };
26860
26861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
26862 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26863 if (!SWIG_IsOK(res1)) {
26864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
26865 }
26866 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26867 arg2 = obj1;
26868 arg3 = obj2;
26869 ecode4 = SWIG_AsVal_bool(obj3, &val4);
26870 if (!SWIG_IsOK(ecode4)) {
26871 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
26872 }
26873 arg4 = static_cast< bool >(val4);
26874 {
26875 PyThreadState* __tstate = wxPyBeginAllowThreads();
26876 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
26877 wxPyEndAllowThreads(__tstate);
26878 if (PyErr_Occurred()) SWIG_fail;
26879 }
26880 resultobj = SWIG_Py_Void();
26881 return resultobj;
26882 fail:
26883 return NULL;
26884 }
26885
26886
26887 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26888 PyObject *resultobj = 0;
26889 wxPyApp *arg1 = (wxPyApp *) 0 ;
26890 wxString result;
26891 void *argp1 = 0 ;
26892 int res1 = 0 ;
26893 PyObject *swig_obj[1] ;
26894
26895 if (!args) SWIG_fail;
26896 swig_obj[0] = args;
26897 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26898 if (!SWIG_IsOK(res1)) {
26899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
26900 }
26901 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26902 {
26903 PyThreadState* __tstate = wxPyBeginAllowThreads();
26904 result = ((wxPyApp const *)arg1)->GetAppName();
26905 wxPyEndAllowThreads(__tstate);
26906 if (PyErr_Occurred()) SWIG_fail;
26907 }
26908 {
26909 #if wxUSE_UNICODE
26910 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26911 #else
26912 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26913 #endif
26914 }
26915 return resultobj;
26916 fail:
26917 return NULL;
26918 }
26919
26920
26921 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26922 PyObject *resultobj = 0;
26923 wxPyApp *arg1 = (wxPyApp *) 0 ;
26924 wxString *arg2 = 0 ;
26925 void *argp1 = 0 ;
26926 int res1 = 0 ;
26927 bool temp2 = false ;
26928 PyObject * obj0 = 0 ;
26929 PyObject * obj1 = 0 ;
26930 char * kwnames[] = {
26931 (char *) "self",(char *) "name", NULL
26932 };
26933
26934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
26935 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26936 if (!SWIG_IsOK(res1)) {
26937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
26938 }
26939 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26940 {
26941 arg2 = wxString_in_helper(obj1);
26942 if (arg2 == NULL) SWIG_fail;
26943 temp2 = true;
26944 }
26945 {
26946 PyThreadState* __tstate = wxPyBeginAllowThreads();
26947 (arg1)->SetAppName((wxString const &)*arg2);
26948 wxPyEndAllowThreads(__tstate);
26949 if (PyErr_Occurred()) SWIG_fail;
26950 }
26951 resultobj = SWIG_Py_Void();
26952 {
26953 if (temp2)
26954 delete arg2;
26955 }
26956 return resultobj;
26957 fail:
26958 {
26959 if (temp2)
26960 delete arg2;
26961 }
26962 return NULL;
26963 }
26964
26965
26966 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26967 PyObject *resultobj = 0;
26968 wxPyApp *arg1 = (wxPyApp *) 0 ;
26969 wxString result;
26970 void *argp1 = 0 ;
26971 int res1 = 0 ;
26972 PyObject *swig_obj[1] ;
26973
26974 if (!args) SWIG_fail;
26975 swig_obj[0] = args;
26976 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26977 if (!SWIG_IsOK(res1)) {
26978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
26979 }
26980 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26981 {
26982 PyThreadState* __tstate = wxPyBeginAllowThreads();
26983 result = ((wxPyApp const *)arg1)->GetClassName();
26984 wxPyEndAllowThreads(__tstate);
26985 if (PyErr_Occurred()) SWIG_fail;
26986 }
26987 {
26988 #if wxUSE_UNICODE
26989 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26990 #else
26991 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26992 #endif
26993 }
26994 return resultobj;
26995 fail:
26996 return NULL;
26997 }
26998
26999
27000 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27001 PyObject *resultobj = 0;
27002 wxPyApp *arg1 = (wxPyApp *) 0 ;
27003 wxString *arg2 = 0 ;
27004 void *argp1 = 0 ;
27005 int res1 = 0 ;
27006 bool temp2 = false ;
27007 PyObject * obj0 = 0 ;
27008 PyObject * obj1 = 0 ;
27009 char * kwnames[] = {
27010 (char *) "self",(char *) "name", NULL
27011 };
27012
27013 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
27014 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27015 if (!SWIG_IsOK(res1)) {
27016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27017 }
27018 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27019 {
27020 arg2 = wxString_in_helper(obj1);
27021 if (arg2 == NULL) SWIG_fail;
27022 temp2 = true;
27023 }
27024 {
27025 PyThreadState* __tstate = wxPyBeginAllowThreads();
27026 (arg1)->SetClassName((wxString const &)*arg2);
27027 wxPyEndAllowThreads(__tstate);
27028 if (PyErr_Occurred()) SWIG_fail;
27029 }
27030 resultobj = SWIG_Py_Void();
27031 {
27032 if (temp2)
27033 delete arg2;
27034 }
27035 return resultobj;
27036 fail:
27037 {
27038 if (temp2)
27039 delete arg2;
27040 }
27041 return NULL;
27042 }
27043
27044
27045 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27046 PyObject *resultobj = 0;
27047 wxPyApp *arg1 = (wxPyApp *) 0 ;
27048 wxString *result = 0 ;
27049 void *argp1 = 0 ;
27050 int res1 = 0 ;
27051 PyObject *swig_obj[1] ;
27052
27053 if (!args) SWIG_fail;
27054 swig_obj[0] = args;
27055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27056 if (!SWIG_IsOK(res1)) {
27057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27058 }
27059 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27060 {
27061 PyThreadState* __tstate = wxPyBeginAllowThreads();
27062 {
27063 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
27064 result = (wxString *) &_result_ref;
27065 }
27066 wxPyEndAllowThreads(__tstate);
27067 if (PyErr_Occurred()) SWIG_fail;
27068 }
27069 {
27070 #if wxUSE_UNICODE
27071 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
27072 #else
27073 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
27074 #endif
27075 }
27076 return resultobj;
27077 fail:
27078 return NULL;
27079 }
27080
27081
27082 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27083 PyObject *resultobj = 0;
27084 wxPyApp *arg1 = (wxPyApp *) 0 ;
27085 wxString *arg2 = 0 ;
27086 void *argp1 = 0 ;
27087 int res1 = 0 ;
27088 bool temp2 = false ;
27089 PyObject * obj0 = 0 ;
27090 PyObject * obj1 = 0 ;
27091 char * kwnames[] = {
27092 (char *) "self",(char *) "name", NULL
27093 };
27094
27095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
27096 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27097 if (!SWIG_IsOK(res1)) {
27098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27099 }
27100 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27101 {
27102 arg2 = wxString_in_helper(obj1);
27103 if (arg2 == NULL) SWIG_fail;
27104 temp2 = true;
27105 }
27106 {
27107 PyThreadState* __tstate = wxPyBeginAllowThreads();
27108 (arg1)->SetVendorName((wxString const &)*arg2);
27109 wxPyEndAllowThreads(__tstate);
27110 if (PyErr_Occurred()) SWIG_fail;
27111 }
27112 resultobj = SWIG_Py_Void();
27113 {
27114 if (temp2)
27115 delete arg2;
27116 }
27117 return resultobj;
27118 fail:
27119 {
27120 if (temp2)
27121 delete arg2;
27122 }
27123 return NULL;
27124 }
27125
27126
27127 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27128 PyObject *resultobj = 0;
27129 wxPyApp *arg1 = (wxPyApp *) 0 ;
27130 wxAppTraits *result = 0 ;
27131 void *argp1 = 0 ;
27132 int res1 = 0 ;
27133 PyObject *swig_obj[1] ;
27134
27135 if (!args) SWIG_fail;
27136 swig_obj[0] = args;
27137 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27138 if (!SWIG_IsOK(res1)) {
27139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
27140 }
27141 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27142 {
27143 PyThreadState* __tstate = wxPyBeginAllowThreads();
27144 result = (wxAppTraits *)(arg1)->GetTraits();
27145 wxPyEndAllowThreads(__tstate);
27146 if (PyErr_Occurred()) SWIG_fail;
27147 }
27148 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
27149 return resultobj;
27150 fail:
27151 return NULL;
27152 }
27153
27154
27155 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27156 PyObject *resultobj = 0;
27157 wxPyApp *arg1 = (wxPyApp *) 0 ;
27158 void *argp1 = 0 ;
27159 int res1 = 0 ;
27160 PyObject *swig_obj[1] ;
27161
27162 if (!args) SWIG_fail;
27163 swig_obj[0] = args;
27164 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27165 if (!SWIG_IsOK(res1)) {
27166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27167 }
27168 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27169 {
27170 PyThreadState* __tstate = wxPyBeginAllowThreads();
27171 (arg1)->ProcessPendingEvents();
27172 wxPyEndAllowThreads(__tstate);
27173 if (PyErr_Occurred()) SWIG_fail;
27174 }
27175 resultobj = SWIG_Py_Void();
27176 return resultobj;
27177 fail:
27178 return NULL;
27179 }
27180
27181
27182 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27183 PyObject *resultobj = 0;
27184 wxPyApp *arg1 = (wxPyApp *) 0 ;
27185 bool arg2 = (bool) false ;
27186 bool result;
27187 void *argp1 = 0 ;
27188 int res1 = 0 ;
27189 bool val2 ;
27190 int ecode2 = 0 ;
27191 PyObject * obj0 = 0 ;
27192 PyObject * obj1 = 0 ;
27193 char * kwnames[] = {
27194 (char *) "self",(char *) "onlyIfNeeded", NULL
27195 };
27196
27197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
27198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27199 if (!SWIG_IsOK(res1)) {
27200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
27201 }
27202 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27203 if (obj1) {
27204 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27205 if (!SWIG_IsOK(ecode2)) {
27206 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
27207 }
27208 arg2 = static_cast< bool >(val2);
27209 }
27210 {
27211 PyThreadState* __tstate = wxPyBeginAllowThreads();
27212 result = (bool)(arg1)->Yield(arg2);
27213 wxPyEndAllowThreads(__tstate);
27214 if (PyErr_Occurred()) SWIG_fail;
27215 }
27216 {
27217 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27218 }
27219 return resultobj;
27220 fail:
27221 return NULL;
27222 }
27223
27224
27225 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27226 PyObject *resultobj = 0;
27227 wxPyApp *arg1 = (wxPyApp *) 0 ;
27228 void *argp1 = 0 ;
27229 int res1 = 0 ;
27230 PyObject *swig_obj[1] ;
27231
27232 if (!args) SWIG_fail;
27233 swig_obj[0] = args;
27234 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27235 if (!SWIG_IsOK(res1)) {
27236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27237 }
27238 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27239 {
27240 PyThreadState* __tstate = wxPyBeginAllowThreads();
27241 (arg1)->WakeUpIdle();
27242 wxPyEndAllowThreads(__tstate);
27243 if (PyErr_Occurred()) SWIG_fail;
27244 }
27245 resultobj = SWIG_Py_Void();
27246 return resultobj;
27247 fail:
27248 return NULL;
27249 }
27250
27251
27252 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27253 PyObject *resultobj = 0;
27254 bool result;
27255
27256 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
27257 {
27258 PyThreadState* __tstate = wxPyBeginAllowThreads();
27259 result = (bool)wxPyApp::IsMainLoopRunning();
27260 wxPyEndAllowThreads(__tstate);
27261 if (PyErr_Occurred()) SWIG_fail;
27262 }
27263 {
27264 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27265 }
27266 return resultobj;
27267 fail:
27268 return NULL;
27269 }
27270
27271
27272 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27273 PyObject *resultobj = 0;
27274 wxPyApp *arg1 = (wxPyApp *) 0 ;
27275 int result;
27276 void *argp1 = 0 ;
27277 int res1 = 0 ;
27278 PyObject *swig_obj[1] ;
27279
27280 if (!args) SWIG_fail;
27281 swig_obj[0] = args;
27282 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27283 if (!SWIG_IsOK(res1)) {
27284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27285 }
27286 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27287 {
27288 PyThreadState* __tstate = wxPyBeginAllowThreads();
27289 result = (int)(arg1)->MainLoop();
27290 wxPyEndAllowThreads(__tstate);
27291 if (PyErr_Occurred()) SWIG_fail;
27292 }
27293 resultobj = SWIG_From_int(static_cast< int >(result));
27294 return resultobj;
27295 fail:
27296 return NULL;
27297 }
27298
27299
27300 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27301 PyObject *resultobj = 0;
27302 wxPyApp *arg1 = (wxPyApp *) 0 ;
27303 void *argp1 = 0 ;
27304 int res1 = 0 ;
27305 PyObject *swig_obj[1] ;
27306
27307 if (!args) SWIG_fail;
27308 swig_obj[0] = args;
27309 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27310 if (!SWIG_IsOK(res1)) {
27311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
27312 }
27313 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27314 {
27315 PyThreadState* __tstate = wxPyBeginAllowThreads();
27316 (arg1)->Exit();
27317 wxPyEndAllowThreads(__tstate);
27318 if (PyErr_Occurred()) SWIG_fail;
27319 }
27320 resultobj = SWIG_Py_Void();
27321 return resultobj;
27322 fail:
27323 return NULL;
27324 }
27325
27326
27327 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27328 PyObject *resultobj = 0;
27329 wxPyApp *arg1 = (wxPyApp *) 0 ;
27330 void *argp1 = 0 ;
27331 int res1 = 0 ;
27332 PyObject *swig_obj[1] ;
27333
27334 if (!args) SWIG_fail;
27335 swig_obj[0] = args;
27336 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27337 if (!SWIG_IsOK(res1)) {
27338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27339 }
27340 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27341 {
27342 PyThreadState* __tstate = wxPyBeginAllowThreads();
27343 (arg1)->ExitMainLoop();
27344 wxPyEndAllowThreads(__tstate);
27345 if (PyErr_Occurred()) SWIG_fail;
27346 }
27347 resultobj = SWIG_Py_Void();
27348 return resultobj;
27349 fail:
27350 return NULL;
27351 }
27352
27353
27354 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27355 PyObject *resultobj = 0;
27356 wxPyApp *arg1 = (wxPyApp *) 0 ;
27357 bool result;
27358 void *argp1 = 0 ;
27359 int res1 = 0 ;
27360 PyObject *swig_obj[1] ;
27361
27362 if (!args) SWIG_fail;
27363 swig_obj[0] = args;
27364 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27365 if (!SWIG_IsOK(res1)) {
27366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
27367 }
27368 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27369 {
27370 PyThreadState* __tstate = wxPyBeginAllowThreads();
27371 result = (bool)(arg1)->Pending();
27372 wxPyEndAllowThreads(__tstate);
27373 if (PyErr_Occurred()) SWIG_fail;
27374 }
27375 {
27376 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27377 }
27378 return resultobj;
27379 fail:
27380 return NULL;
27381 }
27382
27383
27384 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27385 PyObject *resultobj = 0;
27386 wxPyApp *arg1 = (wxPyApp *) 0 ;
27387 bool result;
27388 void *argp1 = 0 ;
27389 int res1 = 0 ;
27390 PyObject *swig_obj[1] ;
27391
27392 if (!args) SWIG_fail;
27393 swig_obj[0] = args;
27394 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27395 if (!SWIG_IsOK(res1)) {
27396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
27397 }
27398 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27399 {
27400 PyThreadState* __tstate = wxPyBeginAllowThreads();
27401 result = (bool)(arg1)->Dispatch();
27402 wxPyEndAllowThreads(__tstate);
27403 if (PyErr_Occurred()) SWIG_fail;
27404 }
27405 {
27406 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27407 }
27408 return resultobj;
27409 fail:
27410 return NULL;
27411 }
27412
27413
27414 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27415 PyObject *resultobj = 0;
27416 wxPyApp *arg1 = (wxPyApp *) 0 ;
27417 bool result;
27418 void *argp1 = 0 ;
27419 int res1 = 0 ;
27420 PyObject *swig_obj[1] ;
27421
27422 if (!args) SWIG_fail;
27423 swig_obj[0] = args;
27424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27425 if (!SWIG_IsOK(res1)) {
27426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27427 }
27428 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27429 {
27430 PyThreadState* __tstate = wxPyBeginAllowThreads();
27431 result = (bool)(arg1)->ProcessIdle();
27432 wxPyEndAllowThreads(__tstate);
27433 if (PyErr_Occurred()) SWIG_fail;
27434 }
27435 {
27436 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27437 }
27438 return resultobj;
27439 fail:
27440 return NULL;
27441 }
27442
27443
27444 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27445 PyObject *resultobj = 0;
27446 wxPyApp *arg1 = (wxPyApp *) 0 ;
27447 wxWindow *arg2 = (wxWindow *) 0 ;
27448 wxIdleEvent *arg3 = 0 ;
27449 bool result;
27450 void *argp1 = 0 ;
27451 int res1 = 0 ;
27452 void *argp2 = 0 ;
27453 int res2 = 0 ;
27454 void *argp3 = 0 ;
27455 int res3 = 0 ;
27456 PyObject * obj0 = 0 ;
27457 PyObject * obj1 = 0 ;
27458 PyObject * obj2 = 0 ;
27459 char * kwnames[] = {
27460 (char *) "self",(char *) "win",(char *) "event", NULL
27461 };
27462
27463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27464 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27465 if (!SWIG_IsOK(res1)) {
27466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27467 }
27468 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27469 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27470 if (!SWIG_IsOK(res2)) {
27471 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
27472 }
27473 arg2 = reinterpret_cast< wxWindow * >(argp2);
27474 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
27475 if (!SWIG_IsOK(res3)) {
27476 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27477 }
27478 if (!argp3) {
27479 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27480 }
27481 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
27482 {
27483 PyThreadState* __tstate = wxPyBeginAllowThreads();
27484 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
27485 wxPyEndAllowThreads(__tstate);
27486 if (PyErr_Occurred()) SWIG_fail;
27487 }
27488 {
27489 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27490 }
27491 return resultobj;
27492 fail:
27493 return NULL;
27494 }
27495
27496
27497 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27498 PyObject *resultobj = 0;
27499 wxPyApp *arg1 = (wxPyApp *) 0 ;
27500 bool result;
27501 void *argp1 = 0 ;
27502 int res1 = 0 ;
27503 PyObject *swig_obj[1] ;
27504
27505 if (!args) SWIG_fail;
27506 swig_obj[0] = args;
27507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27508 if (!SWIG_IsOK(res1)) {
27509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27510 }
27511 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27512 {
27513 PyThreadState* __tstate = wxPyBeginAllowThreads();
27514 result = (bool)((wxPyApp const *)arg1)->IsActive();
27515 wxPyEndAllowThreads(__tstate);
27516 if (PyErr_Occurred()) SWIG_fail;
27517 }
27518 {
27519 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27520 }
27521 return resultobj;
27522 fail:
27523 return NULL;
27524 }
27525
27526
27527 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27528 PyObject *resultobj = 0;
27529 wxPyApp *arg1 = (wxPyApp *) 0 ;
27530 wxWindow *arg2 = (wxWindow *) 0 ;
27531 void *argp1 = 0 ;
27532 int res1 = 0 ;
27533 void *argp2 = 0 ;
27534 int res2 = 0 ;
27535 PyObject * obj0 = 0 ;
27536 PyObject * obj1 = 0 ;
27537 char * kwnames[] = {
27538 (char *) "self",(char *) "win", NULL
27539 };
27540
27541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
27542 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27543 if (!SWIG_IsOK(res1)) {
27544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
27545 }
27546 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27547 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27548 if (!SWIG_IsOK(res2)) {
27549 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
27550 }
27551 arg2 = reinterpret_cast< wxWindow * >(argp2);
27552 {
27553 PyThreadState* __tstate = wxPyBeginAllowThreads();
27554 (arg1)->SetTopWindow(arg2);
27555 wxPyEndAllowThreads(__tstate);
27556 if (PyErr_Occurred()) SWIG_fail;
27557 }
27558 resultobj = SWIG_Py_Void();
27559 return resultobj;
27560 fail:
27561 return NULL;
27562 }
27563
27564
27565 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27566 PyObject *resultobj = 0;
27567 wxPyApp *arg1 = (wxPyApp *) 0 ;
27568 wxWindow *result = 0 ;
27569 void *argp1 = 0 ;
27570 int res1 = 0 ;
27571 PyObject *swig_obj[1] ;
27572
27573 if (!args) SWIG_fail;
27574 swig_obj[0] = args;
27575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27576 if (!SWIG_IsOK(res1)) {
27577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27578 }
27579 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27580 {
27581 PyThreadState* __tstate = wxPyBeginAllowThreads();
27582 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
27583 wxPyEndAllowThreads(__tstate);
27584 if (PyErr_Occurred()) SWIG_fail;
27585 }
27586 {
27587 resultobj = wxPyMake_wxObject(result, (bool)0);
27588 }
27589 return resultobj;
27590 fail:
27591 return NULL;
27592 }
27593
27594
27595 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27596 PyObject *resultobj = 0;
27597 wxPyApp *arg1 = (wxPyApp *) 0 ;
27598 bool arg2 ;
27599 void *argp1 = 0 ;
27600 int res1 = 0 ;
27601 bool val2 ;
27602 int ecode2 = 0 ;
27603 PyObject * obj0 = 0 ;
27604 PyObject * obj1 = 0 ;
27605 char * kwnames[] = {
27606 (char *) "self",(char *) "flag", NULL
27607 };
27608
27609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
27610 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27611 if (!SWIG_IsOK(res1)) {
27612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
27613 }
27614 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27615 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27616 if (!SWIG_IsOK(ecode2)) {
27617 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
27618 }
27619 arg2 = static_cast< bool >(val2);
27620 {
27621 PyThreadState* __tstate = wxPyBeginAllowThreads();
27622 (arg1)->SetExitOnFrameDelete(arg2);
27623 wxPyEndAllowThreads(__tstate);
27624 if (PyErr_Occurred()) SWIG_fail;
27625 }
27626 resultobj = SWIG_Py_Void();
27627 return resultobj;
27628 fail:
27629 return NULL;
27630 }
27631
27632
27633 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27634 PyObject *resultobj = 0;
27635 wxPyApp *arg1 = (wxPyApp *) 0 ;
27636 bool result;
27637 void *argp1 = 0 ;
27638 int res1 = 0 ;
27639 PyObject *swig_obj[1] ;
27640
27641 if (!args) SWIG_fail;
27642 swig_obj[0] = args;
27643 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27644 if (!SWIG_IsOK(res1)) {
27645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27646 }
27647 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27648 {
27649 PyThreadState* __tstate = wxPyBeginAllowThreads();
27650 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
27651 wxPyEndAllowThreads(__tstate);
27652 if (PyErr_Occurred()) SWIG_fail;
27653 }
27654 {
27655 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27656 }
27657 return resultobj;
27658 fail:
27659 return NULL;
27660 }
27661
27662
27663 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27664 PyObject *resultobj = 0;
27665 wxPyApp *arg1 = (wxPyApp *) 0 ;
27666 bool arg2 ;
27667 void *argp1 = 0 ;
27668 int res1 = 0 ;
27669 bool val2 ;
27670 int ecode2 = 0 ;
27671 PyObject * obj0 = 0 ;
27672 PyObject * obj1 = 0 ;
27673 char * kwnames[] = {
27674 (char *) "self",(char *) "flag", NULL
27675 };
27676
27677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) SWIG_fail;
27678 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27679 if (!SWIG_IsOK(res1)) {
27680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
27681 }
27682 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27683 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27684 if (!SWIG_IsOK(ecode2)) {
27685 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
27686 }
27687 arg2 = static_cast< bool >(val2);
27688 {
27689 PyThreadState* __tstate = wxPyBeginAllowThreads();
27690 (arg1)->SetUseBestVisual(arg2);
27691 wxPyEndAllowThreads(__tstate);
27692 if (PyErr_Occurred()) SWIG_fail;
27693 }
27694 resultobj = SWIG_Py_Void();
27695 return resultobj;
27696 fail:
27697 return NULL;
27698 }
27699
27700
27701 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27702 PyObject *resultobj = 0;
27703 wxPyApp *arg1 = (wxPyApp *) 0 ;
27704 bool result;
27705 void *argp1 = 0 ;
27706 int res1 = 0 ;
27707 PyObject *swig_obj[1] ;
27708
27709 if (!args) SWIG_fail;
27710 swig_obj[0] = args;
27711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27712 if (!SWIG_IsOK(res1)) {
27713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27714 }
27715 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27716 {
27717 PyThreadState* __tstate = wxPyBeginAllowThreads();
27718 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
27719 wxPyEndAllowThreads(__tstate);
27720 if (PyErr_Occurred()) SWIG_fail;
27721 }
27722 {
27723 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27724 }
27725 return resultobj;
27726 fail:
27727 return NULL;
27728 }
27729
27730
27731 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27732 PyObject *resultobj = 0;
27733 wxPyApp *arg1 = (wxPyApp *) 0 ;
27734 int arg2 ;
27735 void *argp1 = 0 ;
27736 int res1 = 0 ;
27737 int val2 ;
27738 int ecode2 = 0 ;
27739 PyObject * obj0 = 0 ;
27740 PyObject * obj1 = 0 ;
27741 char * kwnames[] = {
27742 (char *) "self",(char *) "mode", NULL
27743 };
27744
27745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
27746 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27747 if (!SWIG_IsOK(res1)) {
27748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27749 }
27750 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27751 ecode2 = SWIG_AsVal_int(obj1, &val2);
27752 if (!SWIG_IsOK(ecode2)) {
27753 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
27754 }
27755 arg2 = static_cast< int >(val2);
27756 {
27757 PyThreadState* __tstate = wxPyBeginAllowThreads();
27758 (arg1)->SetPrintMode(arg2);
27759 wxPyEndAllowThreads(__tstate);
27760 if (PyErr_Occurred()) SWIG_fail;
27761 }
27762 resultobj = SWIG_Py_Void();
27763 return resultobj;
27764 fail:
27765 return NULL;
27766 }
27767
27768
27769 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27770 PyObject *resultobj = 0;
27771 wxPyApp *arg1 = (wxPyApp *) 0 ;
27772 int result;
27773 void *argp1 = 0 ;
27774 int res1 = 0 ;
27775 PyObject *swig_obj[1] ;
27776
27777 if (!args) SWIG_fail;
27778 swig_obj[0] = args;
27779 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27780 if (!SWIG_IsOK(res1)) {
27781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27782 }
27783 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27784 {
27785 PyThreadState* __tstate = wxPyBeginAllowThreads();
27786 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
27787 wxPyEndAllowThreads(__tstate);
27788 if (PyErr_Occurred()) SWIG_fail;
27789 }
27790 resultobj = SWIG_From_int(static_cast< int >(result));
27791 return resultobj;
27792 fail:
27793 return NULL;
27794 }
27795
27796
27797 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27798 PyObject *resultobj = 0;
27799 wxPyApp *arg1 = (wxPyApp *) 0 ;
27800 int arg2 ;
27801 void *argp1 = 0 ;
27802 int res1 = 0 ;
27803 int val2 ;
27804 int ecode2 = 0 ;
27805 PyObject * obj0 = 0 ;
27806 PyObject * obj1 = 0 ;
27807 char * kwnames[] = {
27808 (char *) "self",(char *) "mode", NULL
27809 };
27810
27811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
27812 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27813 if (!SWIG_IsOK(res1)) {
27814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27815 }
27816 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27817 ecode2 = SWIG_AsVal_int(obj1, &val2);
27818 if (!SWIG_IsOK(ecode2)) {
27819 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
27820 }
27821 arg2 = static_cast< int >(val2);
27822 {
27823 PyThreadState* __tstate = wxPyBeginAllowThreads();
27824 (arg1)->SetAssertMode(arg2);
27825 wxPyEndAllowThreads(__tstate);
27826 if (PyErr_Occurred()) SWIG_fail;
27827 }
27828 resultobj = SWIG_Py_Void();
27829 return resultobj;
27830 fail:
27831 return NULL;
27832 }
27833
27834
27835 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27836 PyObject *resultobj = 0;
27837 wxPyApp *arg1 = (wxPyApp *) 0 ;
27838 int result;
27839 void *argp1 = 0 ;
27840 int res1 = 0 ;
27841 PyObject *swig_obj[1] ;
27842
27843 if (!args) SWIG_fail;
27844 swig_obj[0] = args;
27845 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27846 if (!SWIG_IsOK(res1)) {
27847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27848 }
27849 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27850 {
27851 PyThreadState* __tstate = wxPyBeginAllowThreads();
27852 result = (int)(arg1)->GetAssertMode();
27853 wxPyEndAllowThreads(__tstate);
27854 if (PyErr_Occurred()) SWIG_fail;
27855 }
27856 resultobj = SWIG_From_int(static_cast< int >(result));
27857 return resultobj;
27858 fail:
27859 return NULL;
27860 }
27861
27862
27863 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27864 PyObject *resultobj = 0;
27865 bool result;
27866
27867 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
27868 {
27869 PyThreadState* __tstate = wxPyBeginAllowThreads();
27870 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
27871 wxPyEndAllowThreads(__tstate);
27872 if (PyErr_Occurred()) SWIG_fail;
27873 }
27874 {
27875 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27876 }
27877 return resultobj;
27878 fail:
27879 return NULL;
27880 }
27881
27882
27883 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27884 PyObject *resultobj = 0;
27885 long result;
27886
27887 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
27888 {
27889 PyThreadState* __tstate = wxPyBeginAllowThreads();
27890 result = (long)wxPyApp::GetMacAboutMenuItemId();
27891 wxPyEndAllowThreads(__tstate);
27892 if (PyErr_Occurred()) SWIG_fail;
27893 }
27894 resultobj = SWIG_From_long(static_cast< long >(result));
27895 return resultobj;
27896 fail:
27897 return NULL;
27898 }
27899
27900
27901 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27902 PyObject *resultobj = 0;
27903 long result;
27904
27905 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
27906 {
27907 PyThreadState* __tstate = wxPyBeginAllowThreads();
27908 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
27909 wxPyEndAllowThreads(__tstate);
27910 if (PyErr_Occurred()) SWIG_fail;
27911 }
27912 resultobj = SWIG_From_long(static_cast< long >(result));
27913 return resultobj;
27914 fail:
27915 return NULL;
27916 }
27917
27918
27919 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27920 PyObject *resultobj = 0;
27921 long result;
27922
27923 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
27924 {
27925 PyThreadState* __tstate = wxPyBeginAllowThreads();
27926 result = (long)wxPyApp::GetMacExitMenuItemId();
27927 wxPyEndAllowThreads(__tstate);
27928 if (PyErr_Occurred()) SWIG_fail;
27929 }
27930 resultobj = SWIG_From_long(static_cast< long >(result));
27931 return resultobj;
27932 fail:
27933 return NULL;
27934 }
27935
27936
27937 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27938 PyObject *resultobj = 0;
27939 wxString result;
27940
27941 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
27942 {
27943 PyThreadState* __tstate = wxPyBeginAllowThreads();
27944 result = wxPyApp::GetMacHelpMenuTitleName();
27945 wxPyEndAllowThreads(__tstate);
27946 if (PyErr_Occurred()) SWIG_fail;
27947 }
27948 {
27949 #if wxUSE_UNICODE
27950 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27951 #else
27952 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27953 #endif
27954 }
27955 return resultobj;
27956 fail:
27957 return NULL;
27958 }
27959
27960
27961 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27962 PyObject *resultobj = 0;
27963 bool arg1 ;
27964 bool val1 ;
27965 int ecode1 = 0 ;
27966 PyObject * obj0 = 0 ;
27967 char * kwnames[] = {
27968 (char *) "val", NULL
27969 };
27970
27971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
27972 ecode1 = SWIG_AsVal_bool(obj0, &val1);
27973 if (!SWIG_IsOK(ecode1)) {
27974 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
27975 }
27976 arg1 = static_cast< bool >(val1);
27977 {
27978 PyThreadState* __tstate = wxPyBeginAllowThreads();
27979 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
27980 wxPyEndAllowThreads(__tstate);
27981 if (PyErr_Occurred()) SWIG_fail;
27982 }
27983 resultobj = SWIG_Py_Void();
27984 return resultobj;
27985 fail:
27986 return NULL;
27987 }
27988
27989
27990 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27991 PyObject *resultobj = 0;
27992 long arg1 ;
27993 long val1 ;
27994 int ecode1 = 0 ;
27995 PyObject * obj0 = 0 ;
27996 char * kwnames[] = {
27997 (char *) "val", NULL
27998 };
27999
28000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
28001 ecode1 = SWIG_AsVal_long(obj0, &val1);
28002 if (!SWIG_IsOK(ecode1)) {
28003 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
28004 }
28005 arg1 = static_cast< long >(val1);
28006 {
28007 PyThreadState* __tstate = wxPyBeginAllowThreads();
28008 wxPyApp::SetMacAboutMenuItemId(arg1);
28009 wxPyEndAllowThreads(__tstate);
28010 if (PyErr_Occurred()) SWIG_fail;
28011 }
28012 resultobj = SWIG_Py_Void();
28013 return resultobj;
28014 fail:
28015 return NULL;
28016 }
28017
28018
28019 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28020 PyObject *resultobj = 0;
28021 long arg1 ;
28022 long val1 ;
28023 int ecode1 = 0 ;
28024 PyObject * obj0 = 0 ;
28025 char * kwnames[] = {
28026 (char *) "val", NULL
28027 };
28028
28029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
28030 ecode1 = SWIG_AsVal_long(obj0, &val1);
28031 if (!SWIG_IsOK(ecode1)) {
28032 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
28033 }
28034 arg1 = static_cast< long >(val1);
28035 {
28036 PyThreadState* __tstate = wxPyBeginAllowThreads();
28037 wxPyApp::SetMacPreferencesMenuItemId(arg1);
28038 wxPyEndAllowThreads(__tstate);
28039 if (PyErr_Occurred()) SWIG_fail;
28040 }
28041 resultobj = SWIG_Py_Void();
28042 return resultobj;
28043 fail:
28044 return NULL;
28045 }
28046
28047
28048 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28049 PyObject *resultobj = 0;
28050 long arg1 ;
28051 long val1 ;
28052 int ecode1 = 0 ;
28053 PyObject * obj0 = 0 ;
28054 char * kwnames[] = {
28055 (char *) "val", NULL
28056 };
28057
28058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
28059 ecode1 = SWIG_AsVal_long(obj0, &val1);
28060 if (!SWIG_IsOK(ecode1)) {
28061 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
28062 }
28063 arg1 = static_cast< long >(val1);
28064 {
28065 PyThreadState* __tstate = wxPyBeginAllowThreads();
28066 wxPyApp::SetMacExitMenuItemId(arg1);
28067 wxPyEndAllowThreads(__tstate);
28068 if (PyErr_Occurred()) SWIG_fail;
28069 }
28070 resultobj = SWIG_Py_Void();
28071 return resultobj;
28072 fail:
28073 return NULL;
28074 }
28075
28076
28077 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28078 PyObject *resultobj = 0;
28079 wxString *arg1 = 0 ;
28080 bool temp1 = false ;
28081 PyObject * obj0 = 0 ;
28082 char * kwnames[] = {
28083 (char *) "val", NULL
28084 };
28085
28086 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
28087 {
28088 arg1 = wxString_in_helper(obj0);
28089 if (arg1 == NULL) SWIG_fail;
28090 temp1 = true;
28091 }
28092 {
28093 PyThreadState* __tstate = wxPyBeginAllowThreads();
28094 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
28095 wxPyEndAllowThreads(__tstate);
28096 if (PyErr_Occurred()) SWIG_fail;
28097 }
28098 resultobj = SWIG_Py_Void();
28099 {
28100 if (temp1)
28101 delete arg1;
28102 }
28103 return resultobj;
28104 fail:
28105 {
28106 if (temp1)
28107 delete arg1;
28108 }
28109 return NULL;
28110 }
28111
28112
28113 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28114 PyObject *resultobj = 0;
28115 wxPyApp *arg1 = (wxPyApp *) 0 ;
28116 void *argp1 = 0 ;
28117 int res1 = 0 ;
28118 PyObject *swig_obj[1] ;
28119
28120 if (!args) SWIG_fail;
28121 swig_obj[0] = args;
28122 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28123 if (!SWIG_IsOK(res1)) {
28124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
28125 }
28126 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28127 {
28128 PyThreadState* __tstate = wxPyBeginAllowThreads();
28129 (arg1)->_BootstrapApp();
28130 wxPyEndAllowThreads(__tstate);
28131 if (PyErr_Occurred()) SWIG_fail;
28132 }
28133 resultobj = SWIG_Py_Void();
28134 return resultobj;
28135 fail:
28136 return NULL;
28137 }
28138
28139
28140 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28141 PyObject *resultobj = 0;
28142 int result;
28143
28144 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
28145 {
28146 PyThreadState* __tstate = wxPyBeginAllowThreads();
28147 result = (int)wxPyApp_GetComCtl32Version();
28148 wxPyEndAllowThreads(__tstate);
28149 if (PyErr_Occurred()) SWIG_fail;
28150 }
28151 resultobj = SWIG_From_int(static_cast< int >(result));
28152 return resultobj;
28153 fail:
28154 return NULL;
28155 }
28156
28157
28158 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28159 PyObject *obj;
28160 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28161 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
28162 return SWIG_Py_Void();
28163 }
28164
28165 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28166 return SWIG_Python_InitShadowInstance(args);
28167 }
28168
28169 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28170 PyObject *resultobj = 0;
28171
28172 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
28173 {
28174 PyThreadState* __tstate = wxPyBeginAllowThreads();
28175 wxExit();
28176 wxPyEndAllowThreads(__tstate);
28177 if (PyErr_Occurred()) SWIG_fail;
28178 }
28179 resultobj = SWIG_Py_Void();
28180 return resultobj;
28181 fail:
28182 return NULL;
28183 }
28184
28185
28186 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28187 PyObject *resultobj = 0;
28188 bool result;
28189
28190 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
28191 {
28192 PyThreadState* __tstate = wxPyBeginAllowThreads();
28193 result = (bool)wxYield();
28194 wxPyEndAllowThreads(__tstate);
28195 if (PyErr_Occurred()) SWIG_fail;
28196 }
28197 {
28198 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28199 }
28200 return resultobj;
28201 fail:
28202 return NULL;
28203 }
28204
28205
28206 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28207 PyObject *resultobj = 0;
28208 bool result;
28209
28210 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
28211 {
28212 PyThreadState* __tstate = wxPyBeginAllowThreads();
28213 result = (bool)wxYieldIfNeeded();
28214 wxPyEndAllowThreads(__tstate);
28215 if (PyErr_Occurred()) SWIG_fail;
28216 }
28217 {
28218 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28219 }
28220 return resultobj;
28221 fail:
28222 return NULL;
28223 }
28224
28225
28226 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28227 PyObject *resultobj = 0;
28228 wxWindow *arg1 = (wxWindow *) NULL ;
28229 bool arg2 = (bool) false ;
28230 bool result;
28231 void *argp1 = 0 ;
28232 int res1 = 0 ;
28233 bool val2 ;
28234 int ecode2 = 0 ;
28235 PyObject * obj0 = 0 ;
28236 PyObject * obj1 = 0 ;
28237 char * kwnames[] = {
28238 (char *) "win",(char *) "onlyIfNeeded", NULL
28239 };
28240
28241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
28242 if (obj0) {
28243 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28244 if (!SWIG_IsOK(res1)) {
28245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
28246 }
28247 arg1 = reinterpret_cast< wxWindow * >(argp1);
28248 }
28249 if (obj1) {
28250 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28251 if (!SWIG_IsOK(ecode2)) {
28252 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
28253 }
28254 arg2 = static_cast< bool >(val2);
28255 }
28256 {
28257 PyThreadState* __tstate = wxPyBeginAllowThreads();
28258 result = (bool)wxSafeYield(arg1,arg2);
28259 wxPyEndAllowThreads(__tstate);
28260 if (PyErr_Occurred()) SWIG_fail;
28261 }
28262 {
28263 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28264 }
28265 return resultobj;
28266 fail:
28267 return NULL;
28268 }
28269
28270
28271 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28272 PyObject *resultobj = 0;
28273
28274 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
28275 {
28276 PyThreadState* __tstate = wxPyBeginAllowThreads();
28277 wxWakeUpIdle();
28278 wxPyEndAllowThreads(__tstate);
28279 if (PyErr_Occurred()) SWIG_fail;
28280 }
28281 resultobj = SWIG_Py_Void();
28282 return resultobj;
28283 fail:
28284 return NULL;
28285 }
28286
28287
28288 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28289 PyObject *resultobj = 0;
28290 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
28291 wxEvent *arg2 = 0 ;
28292 void *argp1 = 0 ;
28293 int res1 = 0 ;
28294 void *argp2 = 0 ;
28295 int res2 = 0 ;
28296 PyObject * obj0 = 0 ;
28297 PyObject * obj1 = 0 ;
28298 char * kwnames[] = {
28299 (char *) "dest",(char *) "event", NULL
28300 };
28301
28302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28303 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
28304 if (!SWIG_IsOK(res1)) {
28305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
28306 }
28307 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
28308 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
28309 if (!SWIG_IsOK(res2)) {
28310 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28311 }
28312 if (!argp2) {
28313 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28314 }
28315 arg2 = reinterpret_cast< wxEvent * >(argp2);
28316 {
28317 PyThreadState* __tstate = wxPyBeginAllowThreads();
28318 wxPostEvent(arg1,*arg2);
28319 wxPyEndAllowThreads(__tstate);
28320 if (PyErr_Occurred()) SWIG_fail;
28321 }
28322 resultobj = SWIG_Py_Void();
28323 return resultobj;
28324 fail:
28325 return NULL;
28326 }
28327
28328
28329 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28330 PyObject *resultobj = 0;
28331
28332 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
28333 {
28334 PyThreadState* __tstate = wxPyBeginAllowThreads();
28335 wxApp_CleanUp();
28336 wxPyEndAllowThreads(__tstate);
28337 if (PyErr_Occurred()) SWIG_fail;
28338 }
28339 resultobj = SWIG_Py_Void();
28340 return resultobj;
28341 fail:
28342 return NULL;
28343 }
28344
28345
28346 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28347 PyObject *resultobj = 0;
28348 wxPyApp *result = 0 ;
28349
28350 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
28351 {
28352 PyThreadState* __tstate = wxPyBeginAllowThreads();
28353 result = (wxPyApp *)wxPyGetApp();
28354 wxPyEndAllowThreads(__tstate);
28355 if (PyErr_Occurred()) SWIG_fail;
28356 }
28357 {
28358 resultobj = wxPyMake_wxObject(result, 0);
28359 }
28360 return resultobj;
28361 fail:
28362 return NULL;
28363 }
28364
28365
28366 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28367 PyObject *resultobj = 0;
28368 char *arg1 = (char *) 0 ;
28369 int res1 ;
28370 char *buf1 = 0 ;
28371 int alloc1 = 0 ;
28372 PyObject * obj0 = 0 ;
28373 char * kwnames[] = {
28374 (char *) "encoding", NULL
28375 };
28376
28377 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
28378 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
28379 if (!SWIG_IsOK(res1)) {
28380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
28381 }
28382 arg1 = buf1;
28383 {
28384 PyThreadState* __tstate = wxPyBeginAllowThreads();
28385 wxSetDefaultPyEncoding((char const *)arg1);
28386 wxPyEndAllowThreads(__tstate);
28387 if (PyErr_Occurred()) SWIG_fail;
28388 }
28389 resultobj = SWIG_Py_Void();
28390 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28391 return resultobj;
28392 fail:
28393 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28394 return NULL;
28395 }
28396
28397
28398 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28399 PyObject *resultobj = 0;
28400 char *result = 0 ;
28401
28402 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
28403 {
28404 PyThreadState* __tstate = wxPyBeginAllowThreads();
28405 result = (char *)wxGetDefaultPyEncoding();
28406 wxPyEndAllowThreads(__tstate);
28407 if (PyErr_Occurred()) SWIG_fail;
28408 }
28409 resultobj = SWIG_FromCharPtr(result);
28410 return resultobj;
28411 fail:
28412 return NULL;
28413 }
28414
28415
28416 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28417 PyObject *resultobj = 0;
28418 wxEventLoop *result = 0 ;
28419
28420 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
28421 {
28422 PyThreadState* __tstate = wxPyBeginAllowThreads();
28423 result = (wxEventLoop *)new wxEventLoop();
28424 wxPyEndAllowThreads(__tstate);
28425 if (PyErr_Occurred()) SWIG_fail;
28426 }
28427 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
28428 return resultobj;
28429 fail:
28430 return NULL;
28431 }
28432
28433
28434 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28435 PyObject *resultobj = 0;
28436 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28437 void *argp1 = 0 ;
28438 int res1 = 0 ;
28439 PyObject *swig_obj[1] ;
28440
28441 if (!args) SWIG_fail;
28442 swig_obj[0] = args;
28443 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
28444 if (!SWIG_IsOK(res1)) {
28445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28446 }
28447 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28448 {
28449 PyThreadState* __tstate = wxPyBeginAllowThreads();
28450 delete arg1;
28451
28452 wxPyEndAllowThreads(__tstate);
28453 if (PyErr_Occurred()) SWIG_fail;
28454 }
28455 resultobj = SWIG_Py_Void();
28456 return resultobj;
28457 fail:
28458 return NULL;
28459 }
28460
28461
28462 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28463 PyObject *resultobj = 0;
28464 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28465 int result;
28466 void *argp1 = 0 ;
28467 int res1 = 0 ;
28468 PyObject *swig_obj[1] ;
28469
28470 if (!args) SWIG_fail;
28471 swig_obj[0] = args;
28472 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28473 if (!SWIG_IsOK(res1)) {
28474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28475 }
28476 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28477 {
28478 PyThreadState* __tstate = wxPyBeginAllowThreads();
28479 result = (int)(arg1)->Run();
28480 wxPyEndAllowThreads(__tstate);
28481 if (PyErr_Occurred()) SWIG_fail;
28482 }
28483 resultobj = SWIG_From_int(static_cast< int >(result));
28484 return resultobj;
28485 fail:
28486 return NULL;
28487 }
28488
28489
28490 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28491 PyObject *resultobj = 0;
28492 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28493 int arg2 = (int) 0 ;
28494 void *argp1 = 0 ;
28495 int res1 = 0 ;
28496 int val2 ;
28497 int ecode2 = 0 ;
28498 PyObject * obj0 = 0 ;
28499 PyObject * obj1 = 0 ;
28500 char * kwnames[] = {
28501 (char *) "self",(char *) "rc", NULL
28502 };
28503
28504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
28505 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28506 if (!SWIG_IsOK(res1)) {
28507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28508 }
28509 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28510 if (obj1) {
28511 ecode2 = SWIG_AsVal_int(obj1, &val2);
28512 if (!SWIG_IsOK(ecode2)) {
28513 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
28514 }
28515 arg2 = static_cast< int >(val2);
28516 }
28517 {
28518 PyThreadState* __tstate = wxPyBeginAllowThreads();
28519 (arg1)->Exit(arg2);
28520 wxPyEndAllowThreads(__tstate);
28521 if (PyErr_Occurred()) SWIG_fail;
28522 }
28523 resultobj = SWIG_Py_Void();
28524 return resultobj;
28525 fail:
28526 return NULL;
28527 }
28528
28529
28530 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28531 PyObject *resultobj = 0;
28532 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28533 bool result;
28534 void *argp1 = 0 ;
28535 int res1 = 0 ;
28536 PyObject *swig_obj[1] ;
28537
28538 if (!args) SWIG_fail;
28539 swig_obj[0] = args;
28540 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28541 if (!SWIG_IsOK(res1)) {
28542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28543 }
28544 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28545 {
28546 PyThreadState* __tstate = wxPyBeginAllowThreads();
28547 result = (bool)((wxEventLoop const *)arg1)->Pending();
28548 wxPyEndAllowThreads(__tstate);
28549 if (PyErr_Occurred()) SWIG_fail;
28550 }
28551 {
28552 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28553 }
28554 return resultobj;
28555 fail:
28556 return NULL;
28557 }
28558
28559
28560 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28561 PyObject *resultobj = 0;
28562 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28563 bool result;
28564 void *argp1 = 0 ;
28565 int res1 = 0 ;
28566 PyObject *swig_obj[1] ;
28567
28568 if (!args) SWIG_fail;
28569 swig_obj[0] = args;
28570 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28571 if (!SWIG_IsOK(res1)) {
28572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28573 }
28574 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28575 {
28576 PyThreadState* __tstate = wxPyBeginAllowThreads();
28577 result = (bool)(arg1)->Dispatch();
28578 wxPyEndAllowThreads(__tstate);
28579 if (PyErr_Occurred()) SWIG_fail;
28580 }
28581 {
28582 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28583 }
28584 return resultobj;
28585 fail:
28586 return NULL;
28587 }
28588
28589
28590 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28591 PyObject *resultobj = 0;
28592 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28593 bool result;
28594 void *argp1 = 0 ;
28595 int res1 = 0 ;
28596 PyObject *swig_obj[1] ;
28597
28598 if (!args) SWIG_fail;
28599 swig_obj[0] = args;
28600 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28601 if (!SWIG_IsOK(res1)) {
28602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28603 }
28604 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28605 {
28606 PyThreadState* __tstate = wxPyBeginAllowThreads();
28607 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
28608 wxPyEndAllowThreads(__tstate);
28609 if (PyErr_Occurred()) SWIG_fail;
28610 }
28611 {
28612 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28613 }
28614 return resultobj;
28615 fail:
28616 return NULL;
28617 }
28618
28619
28620 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28621 PyObject *resultobj = 0;
28622 wxEventLoop *result = 0 ;
28623
28624 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
28625 {
28626 PyThreadState* __tstate = wxPyBeginAllowThreads();
28627 result = (wxEventLoop *)wxEventLoop::GetActive();
28628 wxPyEndAllowThreads(__tstate);
28629 if (PyErr_Occurred()) SWIG_fail;
28630 }
28631 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
28632 return resultobj;
28633 fail:
28634 return NULL;
28635 }
28636
28637
28638 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28639 PyObject *resultobj = 0;
28640 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28641 void *argp1 = 0 ;
28642 int res1 = 0 ;
28643 PyObject * obj0 = 0 ;
28644 char * kwnames[] = {
28645 (char *) "loop", NULL
28646 };
28647
28648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
28649 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28650 if (!SWIG_IsOK(res1)) {
28651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28652 }
28653 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28654 {
28655 PyThreadState* __tstate = wxPyBeginAllowThreads();
28656 wxEventLoop::SetActive(arg1);
28657 wxPyEndAllowThreads(__tstate);
28658 if (PyErr_Occurred()) SWIG_fail;
28659 }
28660 resultobj = SWIG_Py_Void();
28661 return resultobj;
28662 fail:
28663 return NULL;
28664 }
28665
28666
28667 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28668 PyObject *obj;
28669 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28670 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
28671 return SWIG_Py_Void();
28672 }
28673
28674 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28675 return SWIG_Python_InitShadowInstance(args);
28676 }
28677
28678 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28679 PyObject *resultobj = 0;
28680 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28681 wxEventLoopActivator *result = 0 ;
28682 void *argp1 = 0 ;
28683 int res1 = 0 ;
28684 PyObject * obj0 = 0 ;
28685 char * kwnames[] = {
28686 (char *) "evtLoop", NULL
28687 };
28688
28689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
28690 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28691 if (!SWIG_IsOK(res1)) {
28692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28693 }
28694 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28695 {
28696 PyThreadState* __tstate = wxPyBeginAllowThreads();
28697 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
28698 wxPyEndAllowThreads(__tstate);
28699 if (PyErr_Occurred()) SWIG_fail;
28700 }
28701 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
28702 return resultobj;
28703 fail:
28704 return NULL;
28705 }
28706
28707
28708 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28709 PyObject *resultobj = 0;
28710 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
28711 void *argp1 = 0 ;
28712 int res1 = 0 ;
28713 PyObject *swig_obj[1] ;
28714
28715 if (!args) SWIG_fail;
28716 swig_obj[0] = args;
28717 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
28718 if (!SWIG_IsOK(res1)) {
28719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
28720 }
28721 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
28722 {
28723 PyThreadState* __tstate = wxPyBeginAllowThreads();
28724 delete arg1;
28725
28726 wxPyEndAllowThreads(__tstate);
28727 if (PyErr_Occurred()) SWIG_fail;
28728 }
28729 resultobj = SWIG_Py_Void();
28730 return resultobj;
28731 fail:
28732 return NULL;
28733 }
28734
28735
28736 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28737 PyObject *obj;
28738 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28739 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
28740 return SWIG_Py_Void();
28741 }
28742
28743 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28744 return SWIG_Python_InitShadowInstance(args);
28745 }
28746
28747 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28748 PyObject *resultobj = 0;
28749 int arg1 = (int) 0 ;
28750 int arg2 = (int) 0 ;
28751 int arg3 = (int) 0 ;
28752 wxAcceleratorEntry *result = 0 ;
28753 int val1 ;
28754 int ecode1 = 0 ;
28755 int val2 ;
28756 int ecode2 = 0 ;
28757 int val3 ;
28758 int ecode3 = 0 ;
28759 PyObject * obj0 = 0 ;
28760 PyObject * obj1 = 0 ;
28761 PyObject * obj2 = 0 ;
28762 char * kwnames[] = {
28763 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
28764 };
28765
28766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28767 if (obj0) {
28768 ecode1 = SWIG_AsVal_int(obj0, &val1);
28769 if (!SWIG_IsOK(ecode1)) {
28770 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
28771 }
28772 arg1 = static_cast< int >(val1);
28773 }
28774 if (obj1) {
28775 ecode2 = SWIG_AsVal_int(obj1, &val2);
28776 if (!SWIG_IsOK(ecode2)) {
28777 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
28778 }
28779 arg2 = static_cast< int >(val2);
28780 }
28781 if (obj2) {
28782 ecode3 = SWIG_AsVal_int(obj2, &val3);
28783 if (!SWIG_IsOK(ecode3)) {
28784 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
28785 }
28786 arg3 = static_cast< int >(val3);
28787 }
28788 {
28789 PyThreadState* __tstate = wxPyBeginAllowThreads();
28790 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
28791 wxPyEndAllowThreads(__tstate);
28792 if (PyErr_Occurred()) SWIG_fail;
28793 }
28794 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
28795 return resultobj;
28796 fail:
28797 return NULL;
28798 }
28799
28800
28801 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28802 PyObject *resultobj = 0;
28803 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28804 void *argp1 = 0 ;
28805 int res1 = 0 ;
28806 PyObject *swig_obj[1] ;
28807
28808 if (!args) SWIG_fail;
28809 swig_obj[0] = args;
28810 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
28811 if (!SWIG_IsOK(res1)) {
28812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28813 }
28814 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28815 {
28816 PyThreadState* __tstate = wxPyBeginAllowThreads();
28817 delete arg1;
28818
28819 wxPyEndAllowThreads(__tstate);
28820 if (PyErr_Occurred()) SWIG_fail;
28821 }
28822 resultobj = SWIG_Py_Void();
28823 return resultobj;
28824 fail:
28825 return NULL;
28826 }
28827
28828
28829 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28830 PyObject *resultobj = 0;
28831 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28832 int arg2 ;
28833 int arg3 ;
28834 int arg4 ;
28835 void *argp1 = 0 ;
28836 int res1 = 0 ;
28837 int val2 ;
28838 int ecode2 = 0 ;
28839 int val3 ;
28840 int ecode3 = 0 ;
28841 int val4 ;
28842 int ecode4 = 0 ;
28843 PyObject * obj0 = 0 ;
28844 PyObject * obj1 = 0 ;
28845 PyObject * obj2 = 0 ;
28846 PyObject * obj3 = 0 ;
28847 char * kwnames[] = {
28848 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
28849 };
28850
28851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28852 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28853 if (!SWIG_IsOK(res1)) {
28854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28855 }
28856 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28857 ecode2 = SWIG_AsVal_int(obj1, &val2);
28858 if (!SWIG_IsOK(ecode2)) {
28859 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
28860 }
28861 arg2 = static_cast< int >(val2);
28862 ecode3 = SWIG_AsVal_int(obj2, &val3);
28863 if (!SWIG_IsOK(ecode3)) {
28864 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
28865 }
28866 arg3 = static_cast< int >(val3);
28867 ecode4 = SWIG_AsVal_int(obj3, &val4);
28868 if (!SWIG_IsOK(ecode4)) {
28869 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
28870 }
28871 arg4 = static_cast< int >(val4);
28872 {
28873 PyThreadState* __tstate = wxPyBeginAllowThreads();
28874 (arg1)->Set(arg2,arg3,arg4);
28875 wxPyEndAllowThreads(__tstate);
28876 if (PyErr_Occurred()) SWIG_fail;
28877 }
28878 resultobj = SWIG_Py_Void();
28879 return resultobj;
28880 fail:
28881 return NULL;
28882 }
28883
28884
28885 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28886 PyObject *resultobj = 0;
28887 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28888 int result;
28889 void *argp1 = 0 ;
28890 int res1 = 0 ;
28891 PyObject *swig_obj[1] ;
28892
28893 if (!args) SWIG_fail;
28894 swig_obj[0] = args;
28895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28896 if (!SWIG_IsOK(res1)) {
28897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28898 }
28899 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28900 {
28901 PyThreadState* __tstate = wxPyBeginAllowThreads();
28902 result = (int)(arg1)->GetFlags();
28903 wxPyEndAllowThreads(__tstate);
28904 if (PyErr_Occurred()) SWIG_fail;
28905 }
28906 resultobj = SWIG_From_int(static_cast< int >(result));
28907 return resultobj;
28908 fail:
28909 return NULL;
28910 }
28911
28912
28913 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28914 PyObject *resultobj = 0;
28915 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28916 int result;
28917 void *argp1 = 0 ;
28918 int res1 = 0 ;
28919 PyObject *swig_obj[1] ;
28920
28921 if (!args) SWIG_fail;
28922 swig_obj[0] = args;
28923 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28924 if (!SWIG_IsOK(res1)) {
28925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28926 }
28927 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28928 {
28929 PyThreadState* __tstate = wxPyBeginAllowThreads();
28930 result = (int)(arg1)->GetKeyCode();
28931 wxPyEndAllowThreads(__tstate);
28932 if (PyErr_Occurred()) SWIG_fail;
28933 }
28934 resultobj = SWIG_From_int(static_cast< int >(result));
28935 return resultobj;
28936 fail:
28937 return NULL;
28938 }
28939
28940
28941 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28942 PyObject *resultobj = 0;
28943 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28944 int result;
28945 void *argp1 = 0 ;
28946 int res1 = 0 ;
28947 PyObject *swig_obj[1] ;
28948
28949 if (!args) SWIG_fail;
28950 swig_obj[0] = args;
28951 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28952 if (!SWIG_IsOK(res1)) {
28953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28954 }
28955 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28956 {
28957 PyThreadState* __tstate = wxPyBeginAllowThreads();
28958 result = (int)(arg1)->GetCommand();
28959 wxPyEndAllowThreads(__tstate);
28960 if (PyErr_Occurred()) SWIG_fail;
28961 }
28962 resultobj = SWIG_From_int(static_cast< int >(result));
28963 return resultobj;
28964 fail:
28965 return NULL;
28966 }
28967
28968
28969 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28970 PyObject *obj;
28971 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28972 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
28973 return SWIG_Py_Void();
28974 }
28975
28976 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28977 return SWIG_Python_InitShadowInstance(args);
28978 }
28979
28980 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28981 PyObject *resultobj = 0;
28982 int arg1 ;
28983 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
28984 wxAcceleratorTable *result = 0 ;
28985 PyObject * obj0 = 0 ;
28986 char * kwnames[] = {
28987 (char *) "n", NULL
28988 };
28989
28990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
28991 {
28992 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
28993 if (arg2) arg1 = PyList_Size(obj0);
28994 else arg1 = 0;
28995 }
28996 {
28997 PyThreadState* __tstate = wxPyBeginAllowThreads();
28998 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
28999 wxPyEndAllowThreads(__tstate);
29000 if (PyErr_Occurred()) SWIG_fail;
29001 }
29002 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
29003 return resultobj;
29004 fail:
29005 return NULL;
29006 }
29007
29008
29009 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29010 PyObject *resultobj = 0;
29011 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29012 void *argp1 = 0 ;
29013 int res1 = 0 ;
29014 PyObject *swig_obj[1] ;
29015
29016 if (!args) SWIG_fail;
29017 swig_obj[0] = args;
29018 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
29019 if (!SWIG_IsOK(res1)) {
29020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
29021 }
29022 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29023 {
29024 PyThreadState* __tstate = wxPyBeginAllowThreads();
29025 delete arg1;
29026
29027 wxPyEndAllowThreads(__tstate);
29028 if (PyErr_Occurred()) SWIG_fail;
29029 }
29030 resultobj = SWIG_Py_Void();
29031 return resultobj;
29032 fail:
29033 return NULL;
29034 }
29035
29036
29037 SWIGINTERN PyObject *_wrap_AcceleratorTable_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29038 PyObject *resultobj = 0;
29039 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29040 bool result;
29041 void *argp1 = 0 ;
29042 int res1 = 0 ;
29043 PyObject *swig_obj[1] ;
29044
29045 if (!args) SWIG_fail;
29046 swig_obj[0] = args;
29047 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
29048 if (!SWIG_IsOK(res1)) {
29049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_Ok" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
29050 }
29051 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29052 {
29053 PyThreadState* __tstate = wxPyBeginAllowThreads();
29054 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
29055 wxPyEndAllowThreads(__tstate);
29056 if (PyErr_Occurred()) SWIG_fail;
29057 }
29058 {
29059 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29060 }
29061 return resultobj;
29062 fail:
29063 return NULL;
29064 }
29065
29066
29067 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29068 PyObject *obj;
29069 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29070 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
29071 return SWIG_Py_Void();
29072 }
29073
29074 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29075 return SWIG_Python_InitShadowInstance(args);
29076 }
29077
29078 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
29079 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
29080 return 1;
29081 }
29082
29083
29084 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
29085 PyObject *pyobj = 0;
29086
29087 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
29088 return pyobj;
29089 }
29090
29091
29092 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29093 PyObject *resultobj = 0;
29094 wxString *arg1 = 0 ;
29095 wxAcceleratorEntry *result = 0 ;
29096 bool temp1 = false ;
29097 PyObject * obj0 = 0 ;
29098 char * kwnames[] = {
29099 (char *) "label", NULL
29100 };
29101
29102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
29103 {
29104 arg1 = wxString_in_helper(obj0);
29105 if (arg1 == NULL) SWIG_fail;
29106 temp1 = true;
29107 }
29108 {
29109 PyThreadState* __tstate = wxPyBeginAllowThreads();
29110 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
29111 wxPyEndAllowThreads(__tstate);
29112 if (PyErr_Occurred()) SWIG_fail;
29113 }
29114 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29115 {
29116 if (temp1)
29117 delete arg1;
29118 }
29119 return resultobj;
29120 fail:
29121 {
29122 if (temp1)
29123 delete arg1;
29124 }
29125 return NULL;
29126 }
29127
29128
29129 SWIGINTERN int PanelNameStr_set(PyObject *) {
29130 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
29131 return 1;
29132 }
29133
29134
29135 SWIGINTERN PyObject *PanelNameStr_get(void) {
29136 PyObject *pyobj = 0;
29137
29138 {
29139 #if wxUSE_UNICODE
29140 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29141 #else
29142 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29143 #endif
29144 }
29145 return pyobj;
29146 }
29147
29148
29149 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29150 PyObject *resultobj = 0;
29151 wxVisualAttributes *result = 0 ;
29152
29153 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
29154 {
29155 PyThreadState* __tstate = wxPyBeginAllowThreads();
29156 result = (wxVisualAttributes *)new_wxVisualAttributes();
29157 wxPyEndAllowThreads(__tstate);
29158 if (PyErr_Occurred()) SWIG_fail;
29159 }
29160 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
29161 return resultobj;
29162 fail:
29163 return NULL;
29164 }
29165
29166
29167 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29168 PyObject *resultobj = 0;
29169 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29170 void *argp1 = 0 ;
29171 int res1 = 0 ;
29172 PyObject *swig_obj[1] ;
29173
29174 if (!args) SWIG_fail;
29175 swig_obj[0] = args;
29176 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
29177 if (!SWIG_IsOK(res1)) {
29178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29179 }
29180 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29181 {
29182 PyThreadState* __tstate = wxPyBeginAllowThreads();
29183 delete_wxVisualAttributes(arg1);
29184
29185 wxPyEndAllowThreads(__tstate);
29186 if (PyErr_Occurred()) SWIG_fail;
29187 }
29188 resultobj = SWIG_Py_Void();
29189 return resultobj;
29190 fail:
29191 return NULL;
29192 }
29193
29194
29195 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29196 PyObject *resultobj = 0;
29197 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29198 wxFont *arg2 = (wxFont *) 0 ;
29199 void *argp1 = 0 ;
29200 int res1 = 0 ;
29201 void *argp2 = 0 ;
29202 int res2 = 0 ;
29203 PyObject *swig_obj[2] ;
29204
29205 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
29206 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29207 if (!SWIG_IsOK(res1)) {
29208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29209 }
29210 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29211 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
29212 if (!SWIG_IsOK(res2)) {
29213 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
29214 }
29215 arg2 = reinterpret_cast< wxFont * >(argp2);
29216 if (arg1) (arg1)->font = *arg2;
29217
29218 resultobj = SWIG_Py_Void();
29219 return resultobj;
29220 fail:
29221 return NULL;
29222 }
29223
29224
29225 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29226 PyObject *resultobj = 0;
29227 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29228 wxFont *result = 0 ;
29229 void *argp1 = 0 ;
29230 int res1 = 0 ;
29231 PyObject *swig_obj[1] ;
29232
29233 if (!args) SWIG_fail;
29234 swig_obj[0] = args;
29235 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29236 if (!SWIG_IsOK(res1)) {
29237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29238 }
29239 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29240 result = (wxFont *)& ((arg1)->font);
29241 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
29242 return resultobj;
29243 fail:
29244 return NULL;
29245 }
29246
29247
29248 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29249 PyObject *resultobj = 0;
29250 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29251 wxColour *arg2 = (wxColour *) 0 ;
29252 void *argp1 = 0 ;
29253 int res1 = 0 ;
29254 void *argp2 = 0 ;
29255 int res2 = 0 ;
29256 PyObject *swig_obj[2] ;
29257
29258 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
29259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29260 if (!SWIG_IsOK(res1)) {
29261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29262 }
29263 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29264 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29265 if (!SWIG_IsOK(res2)) {
29266 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29267 }
29268 arg2 = reinterpret_cast< wxColour * >(argp2);
29269 if (arg1) (arg1)->colFg = *arg2;
29270
29271 resultobj = SWIG_Py_Void();
29272 return resultobj;
29273 fail:
29274 return NULL;
29275 }
29276
29277
29278 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29279 PyObject *resultobj = 0;
29280 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29281 wxColour *result = 0 ;
29282 void *argp1 = 0 ;
29283 int res1 = 0 ;
29284 PyObject *swig_obj[1] ;
29285
29286 if (!args) SWIG_fail;
29287 swig_obj[0] = args;
29288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29289 if (!SWIG_IsOK(res1)) {
29290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29291 }
29292 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29293 result = (wxColour *)& ((arg1)->colFg);
29294 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29295 return resultobj;
29296 fail:
29297 return NULL;
29298 }
29299
29300
29301 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29302 PyObject *resultobj = 0;
29303 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29304 wxColour *arg2 = (wxColour *) 0 ;
29305 void *argp1 = 0 ;
29306 int res1 = 0 ;
29307 void *argp2 = 0 ;
29308 int res2 = 0 ;
29309 PyObject *swig_obj[2] ;
29310
29311 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
29312 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29313 if (!SWIG_IsOK(res1)) {
29314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29315 }
29316 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29317 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29318 if (!SWIG_IsOK(res2)) {
29319 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29320 }
29321 arg2 = reinterpret_cast< wxColour * >(argp2);
29322 if (arg1) (arg1)->colBg = *arg2;
29323
29324 resultobj = SWIG_Py_Void();
29325 return resultobj;
29326 fail:
29327 return NULL;
29328 }
29329
29330
29331 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29332 PyObject *resultobj = 0;
29333 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29334 wxColour *result = 0 ;
29335 void *argp1 = 0 ;
29336 int res1 = 0 ;
29337 PyObject *swig_obj[1] ;
29338
29339 if (!args) SWIG_fail;
29340 swig_obj[0] = args;
29341 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29342 if (!SWIG_IsOK(res1)) {
29343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29344 }
29345 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29346 result = (wxColour *)& ((arg1)->colBg);
29347 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29348 return resultobj;
29349 fail:
29350 return NULL;
29351 }
29352
29353
29354 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29355 PyObject *obj;
29356 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29357 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
29358 return SWIG_Py_Void();
29359 }
29360
29361 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29362 return SWIG_Python_InitShadowInstance(args);
29363 }
29364
29365 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29366 PyObject *resultobj = 0;
29367 wxWindow *arg1 = (wxWindow *) 0 ;
29368 int arg2 = (int) (int)-1 ;
29369 wxPoint const &arg3_defvalue = wxDefaultPosition ;
29370 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
29371 wxSize const &arg4_defvalue = wxDefaultSize ;
29372 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
29373 long arg5 = (long) 0 ;
29374 wxString const &arg6_defvalue = wxPyPanelNameStr ;
29375 wxString *arg6 = (wxString *) &arg6_defvalue ;
29376 wxWindow *result = 0 ;
29377 void *argp1 = 0 ;
29378 int res1 = 0 ;
29379 int val2 ;
29380 int ecode2 = 0 ;
29381 wxPoint temp3 ;
29382 wxSize temp4 ;
29383 long val5 ;
29384 int ecode5 = 0 ;
29385 bool temp6 = false ;
29386 PyObject * obj0 = 0 ;
29387 PyObject * obj1 = 0 ;
29388 PyObject * obj2 = 0 ;
29389 PyObject * obj3 = 0 ;
29390 PyObject * obj4 = 0 ;
29391 PyObject * obj5 = 0 ;
29392 char * kwnames[] = {
29393 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29394 };
29395
29396 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
29397 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29398 if (!SWIG_IsOK(res1)) {
29399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
29400 }
29401 arg1 = reinterpret_cast< wxWindow * >(argp1);
29402 if (obj1) {
29403 ecode2 = SWIG_AsVal_int(obj1, &val2);
29404 if (!SWIG_IsOK(ecode2)) {
29405 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
29406 }
29407 arg2 = static_cast< int >(val2);
29408 }
29409 if (obj2) {
29410 {
29411 arg3 = &temp3;
29412 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29413 }
29414 }
29415 if (obj3) {
29416 {
29417 arg4 = &temp4;
29418 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
29419 }
29420 }
29421 if (obj4) {
29422 ecode5 = SWIG_AsVal_long(obj4, &val5);
29423 if (!SWIG_IsOK(ecode5)) {
29424 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
29425 }
29426 arg5 = static_cast< long >(val5);
29427 }
29428 if (obj5) {
29429 {
29430 arg6 = wxString_in_helper(obj5);
29431 if (arg6 == NULL) SWIG_fail;
29432 temp6 = true;
29433 }
29434 }
29435 {
29436 if (!wxPyCheckForApp()) SWIG_fail;
29437 PyThreadState* __tstate = wxPyBeginAllowThreads();
29438 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
29439 wxPyEndAllowThreads(__tstate);
29440 if (PyErr_Occurred()) SWIG_fail;
29441 }
29442 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
29443 {
29444 if (temp6)
29445 delete arg6;
29446 }
29447 return resultobj;
29448 fail:
29449 {
29450 if (temp6)
29451 delete arg6;
29452 }
29453 return NULL;
29454 }
29455
29456
29457 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29458 PyObject *resultobj = 0;
29459 wxWindow *result = 0 ;
29460
29461 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
29462 {
29463 if (!wxPyCheckForApp()) SWIG_fail;
29464 PyThreadState* __tstate = wxPyBeginAllowThreads();
29465 result = (wxWindow *)new wxWindow();
29466 wxPyEndAllowThreads(__tstate);
29467 if (PyErr_Occurred()) SWIG_fail;
29468 }
29469 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
29470 return resultobj;
29471 fail:
29472 return NULL;
29473 }
29474
29475
29476 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29477 PyObject *resultobj = 0;
29478 wxWindow *arg1 = (wxWindow *) 0 ;
29479 wxWindow *arg2 = (wxWindow *) 0 ;
29480 int arg3 = (int) (int)-1 ;
29481 wxPoint const &arg4_defvalue = wxDefaultPosition ;
29482 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
29483 wxSize const &arg5_defvalue = wxDefaultSize ;
29484 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
29485 long arg6 = (long) 0 ;
29486 wxString const &arg7_defvalue = wxPyPanelNameStr ;
29487 wxString *arg7 = (wxString *) &arg7_defvalue ;
29488 bool result;
29489 void *argp1 = 0 ;
29490 int res1 = 0 ;
29491 void *argp2 = 0 ;
29492 int res2 = 0 ;
29493 int val3 ;
29494 int ecode3 = 0 ;
29495 wxPoint temp4 ;
29496 wxSize temp5 ;
29497 long val6 ;
29498 int ecode6 = 0 ;
29499 bool temp7 = false ;
29500 PyObject * obj0 = 0 ;
29501 PyObject * obj1 = 0 ;
29502 PyObject * obj2 = 0 ;
29503 PyObject * obj3 = 0 ;
29504 PyObject * obj4 = 0 ;
29505 PyObject * obj5 = 0 ;
29506 PyObject * obj6 = 0 ;
29507 char * kwnames[] = {
29508 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29509 };
29510
29511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
29512 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29513 if (!SWIG_IsOK(res1)) {
29514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
29515 }
29516 arg1 = reinterpret_cast< wxWindow * >(argp1);
29517 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
29518 if (!SWIG_IsOK(res2)) {
29519 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
29520 }
29521 arg2 = reinterpret_cast< wxWindow * >(argp2);
29522 if (obj2) {
29523 ecode3 = SWIG_AsVal_int(obj2, &val3);
29524 if (!SWIG_IsOK(ecode3)) {
29525 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
29526 }
29527 arg3 = static_cast< int >(val3);
29528 }
29529 if (obj3) {
29530 {
29531 arg4 = &temp4;
29532 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
29533 }
29534 }
29535 if (obj4) {
29536 {
29537 arg5 = &temp5;
29538 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
29539 }
29540 }
29541 if (obj5) {
29542 ecode6 = SWIG_AsVal_long(obj5, &val6);
29543 if (!SWIG_IsOK(ecode6)) {
29544 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
29545 }
29546 arg6 = static_cast< long >(val6);
29547 }
29548 if (obj6) {
29549 {
29550 arg7 = wxString_in_helper(obj6);
29551 if (arg7 == NULL) SWIG_fail;
29552 temp7 = true;
29553 }
29554 }
29555 {
29556 PyThreadState* __tstate = wxPyBeginAllowThreads();
29557 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
29558 wxPyEndAllowThreads(__tstate);
29559 if (PyErr_Occurred()) SWIG_fail;
29560 }
29561 {
29562 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29563 }
29564 {
29565 if (temp7)
29566 delete arg7;
29567 }
29568 return resultobj;
29569 fail:
29570 {
29571 if (temp7)
29572 delete arg7;
29573 }
29574 return NULL;
29575 }
29576
29577
29578 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29579 PyObject *resultobj = 0;
29580 wxWindow *arg1 = (wxWindow *) 0 ;
29581 bool arg2 = (bool) false ;
29582 bool result;
29583 void *argp1 = 0 ;
29584 int res1 = 0 ;
29585 bool val2 ;
29586 int ecode2 = 0 ;
29587 PyObject * obj0 = 0 ;
29588 PyObject * obj1 = 0 ;
29589 char * kwnames[] = {
29590 (char *) "self",(char *) "force", NULL
29591 };
29592
29593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
29594 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29595 if (!SWIG_IsOK(res1)) {
29596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
29597 }
29598 arg1 = reinterpret_cast< wxWindow * >(argp1);
29599 if (obj1) {
29600 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29601 if (!SWIG_IsOK(ecode2)) {
29602 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
29603 }
29604 arg2 = static_cast< bool >(val2);
29605 }
29606 {
29607 PyThreadState* __tstate = wxPyBeginAllowThreads();
29608 result = (bool)(arg1)->Close(arg2);
29609 wxPyEndAllowThreads(__tstate);
29610 if (PyErr_Occurred()) SWIG_fail;
29611 }
29612 {
29613 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29614 }
29615 return resultobj;
29616 fail:
29617 return NULL;
29618 }
29619
29620
29621 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29622 PyObject *resultobj = 0;
29623 wxWindow *arg1 = (wxWindow *) 0 ;
29624 bool result;
29625 void *argp1 = 0 ;
29626 int res1 = 0 ;
29627 PyObject *swig_obj[1] ;
29628
29629 if (!args) SWIG_fail;
29630 swig_obj[0] = args;
29631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29632 if (!SWIG_IsOK(res1)) {
29633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
29634 }
29635 arg1 = reinterpret_cast< wxWindow * >(argp1);
29636 {
29637 PyThreadState* __tstate = wxPyBeginAllowThreads();
29638 result = (bool)(arg1)->Destroy();
29639 wxPyEndAllowThreads(__tstate);
29640 if (PyErr_Occurred()) SWIG_fail;
29641 }
29642 {
29643 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29644 }
29645 return resultobj;
29646 fail:
29647 return NULL;
29648 }
29649
29650
29651 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29652 PyObject *resultobj = 0;
29653 wxWindow *arg1 = (wxWindow *) 0 ;
29654 bool result;
29655 void *argp1 = 0 ;
29656 int res1 = 0 ;
29657 PyObject *swig_obj[1] ;
29658
29659 if (!args) SWIG_fail;
29660 swig_obj[0] = args;
29661 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29662 if (!SWIG_IsOK(res1)) {
29663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
29664 }
29665 arg1 = reinterpret_cast< wxWindow * >(argp1);
29666 {
29667 PyThreadState* __tstate = wxPyBeginAllowThreads();
29668 result = (bool)(arg1)->DestroyChildren();
29669 wxPyEndAllowThreads(__tstate);
29670 if (PyErr_Occurred()) SWIG_fail;
29671 }
29672 {
29673 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29674 }
29675 return resultobj;
29676 fail:
29677 return NULL;
29678 }
29679
29680
29681 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29682 PyObject *resultobj = 0;
29683 wxWindow *arg1 = (wxWindow *) 0 ;
29684 bool result;
29685 void *argp1 = 0 ;
29686 int res1 = 0 ;
29687 PyObject *swig_obj[1] ;
29688
29689 if (!args) SWIG_fail;
29690 swig_obj[0] = args;
29691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29692 if (!SWIG_IsOK(res1)) {
29693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
29694 }
29695 arg1 = reinterpret_cast< wxWindow * >(argp1);
29696 {
29697 PyThreadState* __tstate = wxPyBeginAllowThreads();
29698 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
29699 wxPyEndAllowThreads(__tstate);
29700 if (PyErr_Occurred()) SWIG_fail;
29701 }
29702 {
29703 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29704 }
29705 return resultobj;
29706 fail:
29707 return NULL;
29708 }
29709
29710
29711 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29712 PyObject *resultobj = 0;
29713 wxWindow *arg1 = (wxWindow *) 0 ;
29714 wxString *arg2 = 0 ;
29715 void *argp1 = 0 ;
29716 int res1 = 0 ;
29717 bool temp2 = false ;
29718 PyObject * obj0 = 0 ;
29719 PyObject * obj1 = 0 ;
29720 char * kwnames[] = {
29721 (char *) "self",(char *) "label", NULL
29722 };
29723
29724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
29725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29726 if (!SWIG_IsOK(res1)) {
29727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
29728 }
29729 arg1 = reinterpret_cast< wxWindow * >(argp1);
29730 {
29731 arg2 = wxString_in_helper(obj1);
29732 if (arg2 == NULL) SWIG_fail;
29733 temp2 = true;
29734 }
29735 {
29736 PyThreadState* __tstate = wxPyBeginAllowThreads();
29737 (arg1)->SetLabel((wxString const &)*arg2);
29738 wxPyEndAllowThreads(__tstate);
29739 if (PyErr_Occurred()) SWIG_fail;
29740 }
29741 resultobj = SWIG_Py_Void();
29742 {
29743 if (temp2)
29744 delete arg2;
29745 }
29746 return resultobj;
29747 fail:
29748 {
29749 if (temp2)
29750 delete arg2;
29751 }
29752 return NULL;
29753 }
29754
29755
29756 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29757 PyObject *resultobj = 0;
29758 wxWindow *arg1 = (wxWindow *) 0 ;
29759 wxString result;
29760 void *argp1 = 0 ;
29761 int res1 = 0 ;
29762 PyObject *swig_obj[1] ;
29763
29764 if (!args) SWIG_fail;
29765 swig_obj[0] = args;
29766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29767 if (!SWIG_IsOK(res1)) {
29768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
29769 }
29770 arg1 = reinterpret_cast< wxWindow * >(argp1);
29771 {
29772 PyThreadState* __tstate = wxPyBeginAllowThreads();
29773 result = ((wxWindow const *)arg1)->GetLabel();
29774 wxPyEndAllowThreads(__tstate);
29775 if (PyErr_Occurred()) SWIG_fail;
29776 }
29777 {
29778 #if wxUSE_UNICODE
29779 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29780 #else
29781 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29782 #endif
29783 }
29784 return resultobj;
29785 fail:
29786 return NULL;
29787 }
29788
29789
29790 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29791 PyObject *resultobj = 0;
29792 wxWindow *arg1 = (wxWindow *) 0 ;
29793 wxString *arg2 = 0 ;
29794 void *argp1 = 0 ;
29795 int res1 = 0 ;
29796 bool temp2 = false ;
29797 PyObject * obj0 = 0 ;
29798 PyObject * obj1 = 0 ;
29799 char * kwnames[] = {
29800 (char *) "self",(char *) "name", NULL
29801 };
29802
29803 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
29804 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29805 if (!SWIG_IsOK(res1)) {
29806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
29807 }
29808 arg1 = reinterpret_cast< wxWindow * >(argp1);
29809 {
29810 arg2 = wxString_in_helper(obj1);
29811 if (arg2 == NULL) SWIG_fail;
29812 temp2 = true;
29813 }
29814 {
29815 PyThreadState* __tstate = wxPyBeginAllowThreads();
29816 (arg1)->SetName((wxString const &)*arg2);
29817 wxPyEndAllowThreads(__tstate);
29818 if (PyErr_Occurred()) SWIG_fail;
29819 }
29820 resultobj = SWIG_Py_Void();
29821 {
29822 if (temp2)
29823 delete arg2;
29824 }
29825 return resultobj;
29826 fail:
29827 {
29828 if (temp2)
29829 delete arg2;
29830 }
29831 return NULL;
29832 }
29833
29834
29835 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29836 PyObject *resultobj = 0;
29837 wxWindow *arg1 = (wxWindow *) 0 ;
29838 wxString result;
29839 void *argp1 = 0 ;
29840 int res1 = 0 ;
29841 PyObject *swig_obj[1] ;
29842
29843 if (!args) SWIG_fail;
29844 swig_obj[0] = args;
29845 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29846 if (!SWIG_IsOK(res1)) {
29847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
29848 }
29849 arg1 = reinterpret_cast< wxWindow * >(argp1);
29850 {
29851 PyThreadState* __tstate = wxPyBeginAllowThreads();
29852 result = ((wxWindow const *)arg1)->GetName();
29853 wxPyEndAllowThreads(__tstate);
29854 if (PyErr_Occurred()) SWIG_fail;
29855 }
29856 {
29857 #if wxUSE_UNICODE
29858 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29859 #else
29860 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29861 #endif
29862 }
29863 return resultobj;
29864 fail:
29865 return NULL;
29866 }
29867
29868
29869 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29870 PyObject *resultobj = 0;
29871 wxWindow *arg1 = (wxWindow *) 0 ;
29872 wxWindowVariant arg2 ;
29873 void *argp1 = 0 ;
29874 int res1 = 0 ;
29875 int val2 ;
29876 int ecode2 = 0 ;
29877 PyObject * obj0 = 0 ;
29878 PyObject * obj1 = 0 ;
29879 char * kwnames[] = {
29880 (char *) "self",(char *) "variant", NULL
29881 };
29882
29883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
29884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29885 if (!SWIG_IsOK(res1)) {
29886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
29887 }
29888 arg1 = reinterpret_cast< wxWindow * >(argp1);
29889 ecode2 = SWIG_AsVal_int(obj1, &val2);
29890 if (!SWIG_IsOK(ecode2)) {
29891 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
29892 }
29893 arg2 = static_cast< wxWindowVariant >(val2);
29894 {
29895 PyThreadState* __tstate = wxPyBeginAllowThreads();
29896 (arg1)->SetWindowVariant(arg2);
29897 wxPyEndAllowThreads(__tstate);
29898 if (PyErr_Occurred()) SWIG_fail;
29899 }
29900 resultobj = SWIG_Py_Void();
29901 return resultobj;
29902 fail:
29903 return NULL;
29904 }
29905
29906
29907 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29908 PyObject *resultobj = 0;
29909 wxWindow *arg1 = (wxWindow *) 0 ;
29910 wxWindowVariant result;
29911 void *argp1 = 0 ;
29912 int res1 = 0 ;
29913 PyObject *swig_obj[1] ;
29914
29915 if (!args) SWIG_fail;
29916 swig_obj[0] = args;
29917 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29918 if (!SWIG_IsOK(res1)) {
29919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
29920 }
29921 arg1 = reinterpret_cast< wxWindow * >(argp1);
29922 {
29923 PyThreadState* __tstate = wxPyBeginAllowThreads();
29924 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
29925 wxPyEndAllowThreads(__tstate);
29926 if (PyErr_Occurred()) SWIG_fail;
29927 }
29928 resultobj = SWIG_From_int(static_cast< int >(result));
29929 return resultobj;
29930 fail:
29931 return NULL;
29932 }
29933
29934
29935 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29936 PyObject *resultobj = 0;
29937 wxWindow *arg1 = (wxWindow *) 0 ;
29938 int arg2 ;
29939 void *argp1 = 0 ;
29940 int res1 = 0 ;
29941 int val2 ;
29942 int ecode2 = 0 ;
29943 PyObject * obj0 = 0 ;
29944 PyObject * obj1 = 0 ;
29945 char * kwnames[] = {
29946 (char *) "self",(char *) "winid", NULL
29947 };
29948
29949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
29950 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29951 if (!SWIG_IsOK(res1)) {
29952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
29953 }
29954 arg1 = reinterpret_cast< wxWindow * >(argp1);
29955 ecode2 = SWIG_AsVal_int(obj1, &val2);
29956 if (!SWIG_IsOK(ecode2)) {
29957 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
29958 }
29959 arg2 = static_cast< int >(val2);
29960 {
29961 PyThreadState* __tstate = wxPyBeginAllowThreads();
29962 (arg1)->SetId(arg2);
29963 wxPyEndAllowThreads(__tstate);
29964 if (PyErr_Occurred()) SWIG_fail;
29965 }
29966 resultobj = SWIG_Py_Void();
29967 return resultobj;
29968 fail:
29969 return NULL;
29970 }
29971
29972
29973 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29974 PyObject *resultobj = 0;
29975 wxWindow *arg1 = (wxWindow *) 0 ;
29976 int result;
29977 void *argp1 = 0 ;
29978 int res1 = 0 ;
29979 PyObject *swig_obj[1] ;
29980
29981 if (!args) SWIG_fail;
29982 swig_obj[0] = args;
29983 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29984 if (!SWIG_IsOK(res1)) {
29985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
29986 }
29987 arg1 = reinterpret_cast< wxWindow * >(argp1);
29988 {
29989 PyThreadState* __tstate = wxPyBeginAllowThreads();
29990 result = (int)((wxWindow const *)arg1)->GetId();
29991 wxPyEndAllowThreads(__tstate);
29992 if (PyErr_Occurred()) SWIG_fail;
29993 }
29994 resultobj = SWIG_From_int(static_cast< int >(result));
29995 return resultobj;
29996 fail:
29997 return NULL;
29998 }
29999
30000
30001 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30002 PyObject *resultobj = 0;
30003 int result;
30004
30005 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
30006 {
30007 PyThreadState* __tstate = wxPyBeginAllowThreads();
30008 result = (int)wxWindow::NewControlId();
30009 wxPyEndAllowThreads(__tstate);
30010 if (PyErr_Occurred()) SWIG_fail;
30011 }
30012 resultobj = SWIG_From_int(static_cast< int >(result));
30013 return resultobj;
30014 fail:
30015 return NULL;
30016 }
30017
30018
30019 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30020 PyObject *resultobj = 0;
30021 int arg1 ;
30022 int result;
30023 int val1 ;
30024 int ecode1 = 0 ;
30025 PyObject * obj0 = 0 ;
30026 char * kwnames[] = {
30027 (char *) "winid", NULL
30028 };
30029
30030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
30031 ecode1 = SWIG_AsVal_int(obj0, &val1);
30032 if (!SWIG_IsOK(ecode1)) {
30033 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
30034 }
30035 arg1 = static_cast< int >(val1);
30036 {
30037 PyThreadState* __tstate = wxPyBeginAllowThreads();
30038 result = (int)wxWindow::NextControlId(arg1);
30039 wxPyEndAllowThreads(__tstate);
30040 if (PyErr_Occurred()) SWIG_fail;
30041 }
30042 resultobj = SWIG_From_int(static_cast< int >(result));
30043 return resultobj;
30044 fail:
30045 return NULL;
30046 }
30047
30048
30049 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30050 PyObject *resultobj = 0;
30051 int arg1 ;
30052 int result;
30053 int val1 ;
30054 int ecode1 = 0 ;
30055 PyObject * obj0 = 0 ;
30056 char * kwnames[] = {
30057 (char *) "winid", NULL
30058 };
30059
30060 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
30061 ecode1 = SWIG_AsVal_int(obj0, &val1);
30062 if (!SWIG_IsOK(ecode1)) {
30063 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
30064 }
30065 arg1 = static_cast< int >(val1);
30066 {
30067 PyThreadState* __tstate = wxPyBeginAllowThreads();
30068 result = (int)wxWindow::PrevControlId(arg1);
30069 wxPyEndAllowThreads(__tstate);
30070 if (PyErr_Occurred()) SWIG_fail;
30071 }
30072 resultobj = SWIG_From_int(static_cast< int >(result));
30073 return resultobj;
30074 fail:
30075 return NULL;
30076 }
30077
30078
30079 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30080 PyObject *resultobj = 0;
30081 wxWindow *arg1 = (wxWindow *) 0 ;
30082 wxSize *arg2 = 0 ;
30083 void *argp1 = 0 ;
30084 int res1 = 0 ;
30085 wxSize temp2 ;
30086 PyObject * obj0 = 0 ;
30087 PyObject * obj1 = 0 ;
30088 char * kwnames[] = {
30089 (char *) "self",(char *) "size", NULL
30090 };
30091
30092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
30093 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30094 if (!SWIG_IsOK(res1)) {
30095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30096 }
30097 arg1 = reinterpret_cast< wxWindow * >(argp1);
30098 {
30099 arg2 = &temp2;
30100 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30101 }
30102 {
30103 PyThreadState* __tstate = wxPyBeginAllowThreads();
30104 (arg1)->SetSize((wxSize const &)*arg2);
30105 wxPyEndAllowThreads(__tstate);
30106 if (PyErr_Occurred()) SWIG_fail;
30107 }
30108 resultobj = SWIG_Py_Void();
30109 return resultobj;
30110 fail:
30111 return NULL;
30112 }
30113
30114
30115 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30116 PyObject *resultobj = 0;
30117 wxWindow *arg1 = (wxWindow *) 0 ;
30118 int arg2 ;
30119 int arg3 ;
30120 int arg4 ;
30121 int arg5 ;
30122 int arg6 = (int) wxSIZE_AUTO ;
30123 void *argp1 = 0 ;
30124 int res1 = 0 ;
30125 int val2 ;
30126 int ecode2 = 0 ;
30127 int val3 ;
30128 int ecode3 = 0 ;
30129 int val4 ;
30130 int ecode4 = 0 ;
30131 int val5 ;
30132 int ecode5 = 0 ;
30133 int val6 ;
30134 int ecode6 = 0 ;
30135 PyObject * obj0 = 0 ;
30136 PyObject * obj1 = 0 ;
30137 PyObject * obj2 = 0 ;
30138 PyObject * obj3 = 0 ;
30139 PyObject * obj4 = 0 ;
30140 PyObject * obj5 = 0 ;
30141 char * kwnames[] = {
30142 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
30143 };
30144
30145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
30146 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30147 if (!SWIG_IsOK(res1)) {
30148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
30149 }
30150 arg1 = reinterpret_cast< wxWindow * >(argp1);
30151 ecode2 = SWIG_AsVal_int(obj1, &val2);
30152 if (!SWIG_IsOK(ecode2)) {
30153 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
30154 }
30155 arg2 = static_cast< int >(val2);
30156 ecode3 = SWIG_AsVal_int(obj2, &val3);
30157 if (!SWIG_IsOK(ecode3)) {
30158 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
30159 }
30160 arg3 = static_cast< int >(val3);
30161 ecode4 = SWIG_AsVal_int(obj3, &val4);
30162 if (!SWIG_IsOK(ecode4)) {
30163 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
30164 }
30165 arg4 = static_cast< int >(val4);
30166 ecode5 = SWIG_AsVal_int(obj4, &val5);
30167 if (!SWIG_IsOK(ecode5)) {
30168 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
30169 }
30170 arg5 = static_cast< int >(val5);
30171 if (obj5) {
30172 ecode6 = SWIG_AsVal_int(obj5, &val6);
30173 if (!SWIG_IsOK(ecode6)) {
30174 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
30175 }
30176 arg6 = static_cast< int >(val6);
30177 }
30178 {
30179 PyThreadState* __tstate = wxPyBeginAllowThreads();
30180 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
30181 wxPyEndAllowThreads(__tstate);
30182 if (PyErr_Occurred()) SWIG_fail;
30183 }
30184 resultobj = SWIG_Py_Void();
30185 return resultobj;
30186 fail:
30187 return NULL;
30188 }
30189
30190
30191 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30192 PyObject *resultobj = 0;
30193 wxWindow *arg1 = (wxWindow *) 0 ;
30194 wxRect *arg2 = 0 ;
30195 int arg3 = (int) wxSIZE_AUTO ;
30196 void *argp1 = 0 ;
30197 int res1 = 0 ;
30198 wxRect temp2 ;
30199 int val3 ;
30200 int ecode3 = 0 ;
30201 PyObject * obj0 = 0 ;
30202 PyObject * obj1 = 0 ;
30203 PyObject * obj2 = 0 ;
30204 char * kwnames[] = {
30205 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
30206 };
30207
30208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30209 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30210 if (!SWIG_IsOK(res1)) {
30211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30212 }
30213 arg1 = reinterpret_cast< wxWindow * >(argp1);
30214 {
30215 arg2 = &temp2;
30216 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30217 }
30218 if (obj2) {
30219 ecode3 = SWIG_AsVal_int(obj2, &val3);
30220 if (!SWIG_IsOK(ecode3)) {
30221 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
30222 }
30223 arg3 = static_cast< int >(val3);
30224 }
30225 {
30226 PyThreadState* __tstate = wxPyBeginAllowThreads();
30227 (arg1)->SetSize((wxRect const &)*arg2,arg3);
30228 wxPyEndAllowThreads(__tstate);
30229 if (PyErr_Occurred()) SWIG_fail;
30230 }
30231 resultobj = SWIG_Py_Void();
30232 return resultobj;
30233 fail:
30234 return NULL;
30235 }
30236
30237
30238 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30239 PyObject *resultobj = 0;
30240 wxWindow *arg1 = (wxWindow *) 0 ;
30241 int arg2 ;
30242 int arg3 ;
30243 void *argp1 = 0 ;
30244 int res1 = 0 ;
30245 int val2 ;
30246 int ecode2 = 0 ;
30247 int val3 ;
30248 int ecode3 = 0 ;
30249 PyObject * obj0 = 0 ;
30250 PyObject * obj1 = 0 ;
30251 PyObject * obj2 = 0 ;
30252 char * kwnames[] = {
30253 (char *) "self",(char *) "width",(char *) "height", NULL
30254 };
30255
30256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30258 if (!SWIG_IsOK(res1)) {
30259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30260 }
30261 arg1 = reinterpret_cast< wxWindow * >(argp1);
30262 ecode2 = SWIG_AsVal_int(obj1, &val2);
30263 if (!SWIG_IsOK(ecode2)) {
30264 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
30265 }
30266 arg2 = static_cast< int >(val2);
30267 ecode3 = SWIG_AsVal_int(obj2, &val3);
30268 if (!SWIG_IsOK(ecode3)) {
30269 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
30270 }
30271 arg3 = static_cast< int >(val3);
30272 {
30273 PyThreadState* __tstate = wxPyBeginAllowThreads();
30274 (arg1)->SetSize(arg2,arg3);
30275 wxPyEndAllowThreads(__tstate);
30276 if (PyErr_Occurred()) SWIG_fail;
30277 }
30278 resultobj = SWIG_Py_Void();
30279 return resultobj;
30280 fail:
30281 return NULL;
30282 }
30283
30284
30285 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30286 PyObject *resultobj = 0;
30287 wxWindow *arg1 = (wxWindow *) 0 ;
30288 wxPoint *arg2 = 0 ;
30289 int arg3 = (int) wxSIZE_USE_EXISTING ;
30290 void *argp1 = 0 ;
30291 int res1 = 0 ;
30292 wxPoint temp2 ;
30293 int val3 ;
30294 int ecode3 = 0 ;
30295 PyObject * obj0 = 0 ;
30296 PyObject * obj1 = 0 ;
30297 PyObject * obj2 = 0 ;
30298 char * kwnames[] = {
30299 (char *) "self",(char *) "pt",(char *) "flags", NULL
30300 };
30301
30302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30303 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30304 if (!SWIG_IsOK(res1)) {
30305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
30306 }
30307 arg1 = reinterpret_cast< wxWindow * >(argp1);
30308 {
30309 arg2 = &temp2;
30310 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30311 }
30312 if (obj2) {
30313 ecode3 = SWIG_AsVal_int(obj2, &val3);
30314 if (!SWIG_IsOK(ecode3)) {
30315 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
30316 }
30317 arg3 = static_cast< int >(val3);
30318 }
30319 {
30320 PyThreadState* __tstate = wxPyBeginAllowThreads();
30321 (arg1)->Move((wxPoint const &)*arg2,arg3);
30322 wxPyEndAllowThreads(__tstate);
30323 if (PyErr_Occurred()) SWIG_fail;
30324 }
30325 resultobj = SWIG_Py_Void();
30326 return resultobj;
30327 fail:
30328 return NULL;
30329 }
30330
30331
30332 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30333 PyObject *resultobj = 0;
30334 wxWindow *arg1 = (wxWindow *) 0 ;
30335 int arg2 ;
30336 int arg3 ;
30337 int arg4 = (int) wxSIZE_USE_EXISTING ;
30338 void *argp1 = 0 ;
30339 int res1 = 0 ;
30340 int val2 ;
30341 int ecode2 = 0 ;
30342 int val3 ;
30343 int ecode3 = 0 ;
30344 int val4 ;
30345 int ecode4 = 0 ;
30346 PyObject * obj0 = 0 ;
30347 PyObject * obj1 = 0 ;
30348 PyObject * obj2 = 0 ;
30349 PyObject * obj3 = 0 ;
30350 char * kwnames[] = {
30351 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
30352 };
30353
30354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30355 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30356 if (!SWIG_IsOK(res1)) {
30357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
30358 }
30359 arg1 = reinterpret_cast< wxWindow * >(argp1);
30360 ecode2 = SWIG_AsVal_int(obj1, &val2);
30361 if (!SWIG_IsOK(ecode2)) {
30362 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
30363 }
30364 arg2 = static_cast< int >(val2);
30365 ecode3 = SWIG_AsVal_int(obj2, &val3);
30366 if (!SWIG_IsOK(ecode3)) {
30367 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
30368 }
30369 arg3 = static_cast< int >(val3);
30370 if (obj3) {
30371 ecode4 = SWIG_AsVal_int(obj3, &val4);
30372 if (!SWIG_IsOK(ecode4)) {
30373 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
30374 }
30375 arg4 = static_cast< int >(val4);
30376 }
30377 {
30378 PyThreadState* __tstate = wxPyBeginAllowThreads();
30379 (arg1)->Move(arg2,arg3,arg4);
30380 wxPyEndAllowThreads(__tstate);
30381 if (PyErr_Occurred()) SWIG_fail;
30382 }
30383 resultobj = SWIG_Py_Void();
30384 return resultobj;
30385 fail:
30386 return NULL;
30387 }
30388
30389
30390 SWIGINTERN PyObject *_wrap_Window_SetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30391 PyObject *resultobj = 0;
30392 wxWindow *arg1 = (wxWindow *) 0 ;
30393 wxSize const &arg2_defvalue = wxDefaultSize ;
30394 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
30395 void *argp1 = 0 ;
30396 int res1 = 0 ;
30397 wxSize temp2 ;
30398 PyObject * obj0 = 0 ;
30399 PyObject * obj1 = 0 ;
30400 char * kwnames[] = {
30401 (char *) "self",(char *) "size", NULL
30402 };
30403
30404 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) SWIG_fail;
30405 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30406 if (!SWIG_IsOK(res1)) {
30407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30408 }
30409 arg1 = reinterpret_cast< wxWindow * >(argp1);
30410 if (obj1) {
30411 {
30412 arg2 = &temp2;
30413 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30414 }
30415 }
30416 {
30417 PyThreadState* __tstate = wxPyBeginAllowThreads();
30418 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
30419 wxPyEndAllowThreads(__tstate);
30420 if (PyErr_Occurred()) SWIG_fail;
30421 }
30422 resultobj = SWIG_Py_Void();
30423 return resultobj;
30424 fail:
30425 return NULL;
30426 }
30427
30428
30429 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30430 PyObject *resultobj = 0;
30431 wxWindow *arg1 = (wxWindow *) 0 ;
30432 void *argp1 = 0 ;
30433 int res1 = 0 ;
30434 PyObject *swig_obj[1] ;
30435
30436 if (!args) SWIG_fail;
30437 swig_obj[0] = args;
30438 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30439 if (!SWIG_IsOK(res1)) {
30440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
30441 }
30442 arg1 = reinterpret_cast< wxWindow * >(argp1);
30443 {
30444 PyThreadState* __tstate = wxPyBeginAllowThreads();
30445 (arg1)->Raise();
30446 wxPyEndAllowThreads(__tstate);
30447 if (PyErr_Occurred()) SWIG_fail;
30448 }
30449 resultobj = SWIG_Py_Void();
30450 return resultobj;
30451 fail:
30452 return NULL;
30453 }
30454
30455
30456 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30457 PyObject *resultobj = 0;
30458 wxWindow *arg1 = (wxWindow *) 0 ;
30459 void *argp1 = 0 ;
30460 int res1 = 0 ;
30461 PyObject *swig_obj[1] ;
30462
30463 if (!args) SWIG_fail;
30464 swig_obj[0] = args;
30465 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30466 if (!SWIG_IsOK(res1)) {
30467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
30468 }
30469 arg1 = reinterpret_cast< wxWindow * >(argp1);
30470 {
30471 PyThreadState* __tstate = wxPyBeginAllowThreads();
30472 (arg1)->Lower();
30473 wxPyEndAllowThreads(__tstate);
30474 if (PyErr_Occurred()) SWIG_fail;
30475 }
30476 resultobj = SWIG_Py_Void();
30477 return resultobj;
30478 fail:
30479 return NULL;
30480 }
30481
30482
30483 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30484 PyObject *resultobj = 0;
30485 wxWindow *arg1 = (wxWindow *) 0 ;
30486 wxSize *arg2 = 0 ;
30487 void *argp1 = 0 ;
30488 int res1 = 0 ;
30489 wxSize temp2 ;
30490 PyObject * obj0 = 0 ;
30491 PyObject * obj1 = 0 ;
30492 char * kwnames[] = {
30493 (char *) "self",(char *) "size", NULL
30494 };
30495
30496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
30497 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30498 if (!SWIG_IsOK(res1)) {
30499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30500 }
30501 arg1 = reinterpret_cast< wxWindow * >(argp1);
30502 {
30503 arg2 = &temp2;
30504 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30505 }
30506 {
30507 PyThreadState* __tstate = wxPyBeginAllowThreads();
30508 (arg1)->SetClientSize((wxSize const &)*arg2);
30509 wxPyEndAllowThreads(__tstate);
30510 if (PyErr_Occurred()) SWIG_fail;
30511 }
30512 resultobj = SWIG_Py_Void();
30513 return resultobj;
30514 fail:
30515 return NULL;
30516 }
30517
30518
30519 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30520 PyObject *resultobj = 0;
30521 wxWindow *arg1 = (wxWindow *) 0 ;
30522 int arg2 ;
30523 int arg3 ;
30524 void *argp1 = 0 ;
30525 int res1 = 0 ;
30526 int val2 ;
30527 int ecode2 = 0 ;
30528 int val3 ;
30529 int ecode3 = 0 ;
30530 PyObject * obj0 = 0 ;
30531 PyObject * obj1 = 0 ;
30532 PyObject * obj2 = 0 ;
30533 char * kwnames[] = {
30534 (char *) "self",(char *) "width",(char *) "height", NULL
30535 };
30536
30537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30538 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30539 if (!SWIG_IsOK(res1)) {
30540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30541 }
30542 arg1 = reinterpret_cast< wxWindow * >(argp1);
30543 ecode2 = SWIG_AsVal_int(obj1, &val2);
30544 if (!SWIG_IsOK(ecode2)) {
30545 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
30546 }
30547 arg2 = static_cast< int >(val2);
30548 ecode3 = SWIG_AsVal_int(obj2, &val3);
30549 if (!SWIG_IsOK(ecode3)) {
30550 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
30551 }
30552 arg3 = static_cast< int >(val3);
30553 {
30554 PyThreadState* __tstate = wxPyBeginAllowThreads();
30555 (arg1)->SetClientSize(arg2,arg3);
30556 wxPyEndAllowThreads(__tstate);
30557 if (PyErr_Occurred()) SWIG_fail;
30558 }
30559 resultobj = SWIG_Py_Void();
30560 return resultobj;
30561 fail:
30562 return NULL;
30563 }
30564
30565
30566 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30567 PyObject *resultobj = 0;
30568 wxWindow *arg1 = (wxWindow *) 0 ;
30569 wxRect *arg2 = 0 ;
30570 void *argp1 = 0 ;
30571 int res1 = 0 ;
30572 wxRect temp2 ;
30573 PyObject * obj0 = 0 ;
30574 PyObject * obj1 = 0 ;
30575 char * kwnames[] = {
30576 (char *) "self",(char *) "rect", NULL
30577 };
30578
30579 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
30580 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30581 if (!SWIG_IsOK(res1)) {
30582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30583 }
30584 arg1 = reinterpret_cast< wxWindow * >(argp1);
30585 {
30586 arg2 = &temp2;
30587 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30588 }
30589 {
30590 PyThreadState* __tstate = wxPyBeginAllowThreads();
30591 (arg1)->SetClientSize((wxRect const &)*arg2);
30592 wxPyEndAllowThreads(__tstate);
30593 if (PyErr_Occurred()) SWIG_fail;
30594 }
30595 resultobj = SWIG_Py_Void();
30596 return resultobj;
30597 fail:
30598 return NULL;
30599 }
30600
30601
30602 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30603 PyObject *resultobj = 0;
30604 wxWindow *arg1 = (wxWindow *) 0 ;
30605 wxPoint result;
30606 void *argp1 = 0 ;
30607 int res1 = 0 ;
30608 PyObject *swig_obj[1] ;
30609
30610 if (!args) SWIG_fail;
30611 swig_obj[0] = args;
30612 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30613 if (!SWIG_IsOK(res1)) {
30614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
30615 }
30616 arg1 = reinterpret_cast< wxWindow * >(argp1);
30617 {
30618 PyThreadState* __tstate = wxPyBeginAllowThreads();
30619 result = ((wxWindow const *)arg1)->GetPosition();
30620 wxPyEndAllowThreads(__tstate);
30621 if (PyErr_Occurred()) SWIG_fail;
30622 }
30623 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30624 return resultobj;
30625 fail:
30626 return NULL;
30627 }
30628
30629
30630 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30631 PyObject *resultobj = 0;
30632 wxWindow *arg1 = (wxWindow *) 0 ;
30633 int *arg2 = (int *) 0 ;
30634 int *arg3 = (int *) 0 ;
30635 void *argp1 = 0 ;
30636 int res1 = 0 ;
30637 int temp2 ;
30638 int res2 = SWIG_TMPOBJ ;
30639 int temp3 ;
30640 int res3 = SWIG_TMPOBJ ;
30641 PyObject *swig_obj[1] ;
30642
30643 arg2 = &temp2;
30644 arg3 = &temp3;
30645 if (!args) SWIG_fail;
30646 swig_obj[0] = args;
30647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30648 if (!SWIG_IsOK(res1)) {
30649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30650 }
30651 arg1 = reinterpret_cast< wxWindow * >(argp1);
30652 {
30653 PyThreadState* __tstate = wxPyBeginAllowThreads();
30654 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
30655 wxPyEndAllowThreads(__tstate);
30656 if (PyErr_Occurred()) SWIG_fail;
30657 }
30658 resultobj = SWIG_Py_Void();
30659 if (SWIG_IsTmpObj(res2)) {
30660 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30661 } else {
30662 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30663 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30664 }
30665 if (SWIG_IsTmpObj(res3)) {
30666 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30667 } else {
30668 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30669 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30670 }
30671 return resultobj;
30672 fail:
30673 return NULL;
30674 }
30675
30676
30677 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30678 PyObject *resultobj = 0;
30679 wxWindow *arg1 = (wxWindow *) 0 ;
30680 wxPoint 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_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
30690 }
30691 arg1 = reinterpret_cast< wxWindow * >(argp1);
30692 {
30693 PyThreadState* __tstate = wxPyBeginAllowThreads();
30694 result = ((wxWindow const *)arg1)->GetScreenPosition();
30695 wxPyEndAllowThreads(__tstate);
30696 if (PyErr_Occurred()) SWIG_fail;
30697 }
30698 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30699 return resultobj;
30700 fail:
30701 return NULL;
30702 }
30703
30704
30705 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30706 PyObject *resultobj = 0;
30707 wxWindow *arg1 = (wxWindow *) 0 ;
30708 int *arg2 = (int *) 0 ;
30709 int *arg3 = (int *) 0 ;
30710 void *argp1 = 0 ;
30711 int res1 = 0 ;
30712 int temp2 ;
30713 int res2 = SWIG_TMPOBJ ;
30714 int temp3 ;
30715 int res3 = SWIG_TMPOBJ ;
30716 PyObject *swig_obj[1] ;
30717
30718 arg2 = &temp2;
30719 arg3 = &temp3;
30720 if (!args) SWIG_fail;
30721 swig_obj[0] = args;
30722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30723 if (!SWIG_IsOK(res1)) {
30724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30725 }
30726 arg1 = reinterpret_cast< wxWindow * >(argp1);
30727 {
30728 PyThreadState* __tstate = wxPyBeginAllowThreads();
30729 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
30730 wxPyEndAllowThreads(__tstate);
30731 if (PyErr_Occurred()) SWIG_fail;
30732 }
30733 resultobj = SWIG_Py_Void();
30734 if (SWIG_IsTmpObj(res2)) {
30735 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30736 } else {
30737 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30738 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30739 }
30740 if (SWIG_IsTmpObj(res3)) {
30741 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30742 } else {
30743 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30744 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30745 }
30746 return resultobj;
30747 fail:
30748 return NULL;
30749 }
30750
30751
30752 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30753 PyObject *resultobj = 0;
30754 wxWindow *arg1 = (wxWindow *) 0 ;
30755 wxRect result;
30756 void *argp1 = 0 ;
30757 int res1 = 0 ;
30758 PyObject *swig_obj[1] ;
30759
30760 if (!args) SWIG_fail;
30761 swig_obj[0] = args;
30762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30763 if (!SWIG_IsOK(res1)) {
30764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
30765 }
30766 arg1 = reinterpret_cast< wxWindow * >(argp1);
30767 {
30768 PyThreadState* __tstate = wxPyBeginAllowThreads();
30769 result = ((wxWindow const *)arg1)->GetScreenRect();
30770 wxPyEndAllowThreads(__tstate);
30771 if (PyErr_Occurred()) SWIG_fail;
30772 }
30773 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
30774 return resultobj;
30775 fail:
30776 return NULL;
30777 }
30778
30779
30780 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30781 PyObject *resultobj = 0;
30782 wxWindow *arg1 = (wxWindow *) 0 ;
30783 wxSize result;
30784 void *argp1 = 0 ;
30785 int res1 = 0 ;
30786 PyObject *swig_obj[1] ;
30787
30788 if (!args) SWIG_fail;
30789 swig_obj[0] = args;
30790 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30791 if (!SWIG_IsOK(res1)) {
30792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
30793 }
30794 arg1 = reinterpret_cast< wxWindow * >(argp1);
30795 {
30796 PyThreadState* __tstate = wxPyBeginAllowThreads();
30797 result = ((wxWindow const *)arg1)->GetSize();
30798 wxPyEndAllowThreads(__tstate);
30799 if (PyErr_Occurred()) SWIG_fail;
30800 }
30801 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
30802 return resultobj;
30803 fail:
30804 return NULL;
30805 }
30806
30807
30808 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30809 PyObject *resultobj = 0;
30810 wxWindow *arg1 = (wxWindow *) 0 ;
30811 int *arg2 = (int *) 0 ;
30812 int *arg3 = (int *) 0 ;
30813 void *argp1 = 0 ;
30814 int res1 = 0 ;
30815 int temp2 ;
30816 int res2 = SWIG_TMPOBJ ;
30817 int temp3 ;
30818 int res3 = SWIG_TMPOBJ ;
30819 PyObject *swig_obj[1] ;
30820
30821 arg2 = &temp2;
30822 arg3 = &temp3;
30823 if (!args) SWIG_fail;
30824 swig_obj[0] = args;
30825 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30826 if (!SWIG_IsOK(res1)) {
30827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30828 }
30829 arg1 = reinterpret_cast< wxWindow * >(argp1);
30830 {
30831 PyThreadState* __tstate = wxPyBeginAllowThreads();
30832 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
30833 wxPyEndAllowThreads(__tstate);
30834 if (PyErr_Occurred()) SWIG_fail;
30835 }
30836 resultobj = SWIG_Py_Void();
30837 if (SWIG_IsTmpObj(res2)) {
30838 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30839 } else {
30840 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30841 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30842 }
30843 if (SWIG_IsTmpObj(res3)) {
30844 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30845 } else {
30846 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30847 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30848 }
30849 return resultobj;
30850 fail:
30851 return NULL;
30852 }
30853
30854
30855 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30856 PyObject *resultobj = 0;
30857 wxWindow *arg1 = (wxWindow *) 0 ;
30858 wxRect result;
30859 void *argp1 = 0 ;
30860 int res1 = 0 ;
30861 PyObject *swig_obj[1] ;
30862
30863 if (!args) SWIG_fail;
30864 swig_obj[0] = args;
30865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30866 if (!SWIG_IsOK(res1)) {
30867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
30868 }
30869 arg1 = reinterpret_cast< wxWindow * >(argp1);
30870 {
30871 PyThreadState* __tstate = wxPyBeginAllowThreads();
30872 result = ((wxWindow const *)arg1)->GetRect();
30873 wxPyEndAllowThreads(__tstate);
30874 if (PyErr_Occurred()) SWIG_fail;
30875 }
30876 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
30877 return resultobj;
30878 fail:
30879 return NULL;
30880 }
30881
30882
30883 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30884 PyObject *resultobj = 0;
30885 wxWindow *arg1 = (wxWindow *) 0 ;
30886 wxSize result;
30887 void *argp1 = 0 ;
30888 int res1 = 0 ;
30889 PyObject *swig_obj[1] ;
30890
30891 if (!args) SWIG_fail;
30892 swig_obj[0] = args;
30893 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30894 if (!SWIG_IsOK(res1)) {
30895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
30896 }
30897 arg1 = reinterpret_cast< wxWindow * >(argp1);
30898 {
30899 PyThreadState* __tstate = wxPyBeginAllowThreads();
30900 result = ((wxWindow const *)arg1)->GetClientSize();
30901 wxPyEndAllowThreads(__tstate);
30902 if (PyErr_Occurred()) SWIG_fail;
30903 }
30904 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
30905 return resultobj;
30906 fail:
30907 return NULL;
30908 }
30909
30910
30911 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30912 PyObject *resultobj = 0;
30913 wxWindow *arg1 = (wxWindow *) 0 ;
30914 int *arg2 = (int *) 0 ;
30915 int *arg3 = (int *) 0 ;
30916 void *argp1 = 0 ;
30917 int res1 = 0 ;
30918 int temp2 ;
30919 int res2 = SWIG_TMPOBJ ;
30920 int temp3 ;
30921 int res3 = SWIG_TMPOBJ ;
30922 PyObject *swig_obj[1] ;
30923
30924 arg2 = &temp2;
30925 arg3 = &temp3;
30926 if (!args) SWIG_fail;
30927 swig_obj[0] = args;
30928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30929 if (!SWIG_IsOK(res1)) {
30930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30931 }
30932 arg1 = reinterpret_cast< wxWindow * >(argp1);
30933 {
30934 PyThreadState* __tstate = wxPyBeginAllowThreads();
30935 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
30936 wxPyEndAllowThreads(__tstate);
30937 if (PyErr_Occurred()) SWIG_fail;
30938 }
30939 resultobj = SWIG_Py_Void();
30940 if (SWIG_IsTmpObj(res2)) {
30941 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30942 } else {
30943 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30944 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30945 }
30946 if (SWIG_IsTmpObj(res3)) {
30947 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30948 } else {
30949 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30950 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30951 }
30952 return resultobj;
30953 fail:
30954 return NULL;
30955 }
30956
30957
30958 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30959 PyObject *resultobj = 0;
30960 wxWindow *arg1 = (wxWindow *) 0 ;
30961 wxPoint result;
30962 void *argp1 = 0 ;
30963 int res1 = 0 ;
30964 PyObject *swig_obj[1] ;
30965
30966 if (!args) SWIG_fail;
30967 swig_obj[0] = args;
30968 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30969 if (!SWIG_IsOK(res1)) {
30970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
30971 }
30972 arg1 = reinterpret_cast< wxWindow * >(argp1);
30973 {
30974 PyThreadState* __tstate = wxPyBeginAllowThreads();
30975 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
30976 wxPyEndAllowThreads(__tstate);
30977 if (PyErr_Occurred()) SWIG_fail;
30978 }
30979 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30980 return resultobj;
30981 fail:
30982 return NULL;
30983 }
30984
30985
30986 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30987 PyObject *resultobj = 0;
30988 wxWindow *arg1 = (wxWindow *) 0 ;
30989 wxRect result;
30990 void *argp1 = 0 ;
30991 int res1 = 0 ;
30992 PyObject *swig_obj[1] ;
30993
30994 if (!args) SWIG_fail;
30995 swig_obj[0] = args;
30996 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30997 if (!SWIG_IsOK(res1)) {
30998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
30999 }
31000 arg1 = reinterpret_cast< wxWindow * >(argp1);
31001 {
31002 PyThreadState* __tstate = wxPyBeginAllowThreads();
31003 result = ((wxWindow const *)arg1)->GetClientRect();
31004 wxPyEndAllowThreads(__tstate);
31005 if (PyErr_Occurred()) SWIG_fail;
31006 }
31007 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31008 return resultobj;
31009 fail:
31010 return NULL;
31011 }
31012
31013
31014 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31015 PyObject *resultobj = 0;
31016 wxWindow *arg1 = (wxWindow *) 0 ;
31017 wxSize result;
31018 void *argp1 = 0 ;
31019 int res1 = 0 ;
31020 PyObject *swig_obj[1] ;
31021
31022 if (!args) SWIG_fail;
31023 swig_obj[0] = args;
31024 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31025 if (!SWIG_IsOK(res1)) {
31026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31027 }
31028 arg1 = reinterpret_cast< wxWindow * >(argp1);
31029 {
31030 PyThreadState* __tstate = wxPyBeginAllowThreads();
31031 result = ((wxWindow const *)arg1)->GetBestSize();
31032 wxPyEndAllowThreads(__tstate);
31033 if (PyErr_Occurred()) SWIG_fail;
31034 }
31035 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31036 return resultobj;
31037 fail:
31038 return NULL;
31039 }
31040
31041
31042 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31043 PyObject *resultobj = 0;
31044 wxWindow *arg1 = (wxWindow *) 0 ;
31045 int *arg2 = (int *) 0 ;
31046 int *arg3 = (int *) 0 ;
31047 void *argp1 = 0 ;
31048 int res1 = 0 ;
31049 int temp2 ;
31050 int res2 = SWIG_TMPOBJ ;
31051 int temp3 ;
31052 int res3 = SWIG_TMPOBJ ;
31053 PyObject *swig_obj[1] ;
31054
31055 arg2 = &temp2;
31056 arg3 = &temp3;
31057 if (!args) SWIG_fail;
31058 swig_obj[0] = args;
31059 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31060 if (!SWIG_IsOK(res1)) {
31061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31062 }
31063 arg1 = reinterpret_cast< wxWindow * >(argp1);
31064 {
31065 PyThreadState* __tstate = wxPyBeginAllowThreads();
31066 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
31067 wxPyEndAllowThreads(__tstate);
31068 if (PyErr_Occurred()) SWIG_fail;
31069 }
31070 resultobj = SWIG_Py_Void();
31071 if (SWIG_IsTmpObj(res2)) {
31072 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31073 } else {
31074 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31075 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31076 }
31077 if (SWIG_IsTmpObj(res3)) {
31078 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31079 } else {
31080 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31081 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31082 }
31083 return resultobj;
31084 fail:
31085 return NULL;
31086 }
31087
31088
31089 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31090 PyObject *resultobj = 0;
31091 wxWindow *arg1 = (wxWindow *) 0 ;
31092 void *argp1 = 0 ;
31093 int res1 = 0 ;
31094 PyObject *swig_obj[1] ;
31095
31096 if (!args) SWIG_fail;
31097 swig_obj[0] = args;
31098 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31099 if (!SWIG_IsOK(res1)) {
31100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31101 }
31102 arg1 = reinterpret_cast< wxWindow * >(argp1);
31103 {
31104 PyThreadState* __tstate = wxPyBeginAllowThreads();
31105 (arg1)->InvalidateBestSize();
31106 wxPyEndAllowThreads(__tstate);
31107 if (PyErr_Occurred()) SWIG_fail;
31108 }
31109 resultobj = SWIG_Py_Void();
31110 return resultobj;
31111 fail:
31112 return NULL;
31113 }
31114
31115
31116 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31117 PyObject *resultobj = 0;
31118 wxWindow *arg1 = (wxWindow *) 0 ;
31119 wxSize *arg2 = 0 ;
31120 void *argp1 = 0 ;
31121 int res1 = 0 ;
31122 wxSize temp2 ;
31123 PyObject * obj0 = 0 ;
31124 PyObject * obj1 = 0 ;
31125 char * kwnames[] = {
31126 (char *) "self",(char *) "size", NULL
31127 };
31128
31129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
31130 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31131 if (!SWIG_IsOK(res1)) {
31132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31133 }
31134 arg1 = reinterpret_cast< wxWindow * >(argp1);
31135 {
31136 arg2 = &temp2;
31137 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31138 }
31139 {
31140 PyThreadState* __tstate = wxPyBeginAllowThreads();
31141 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
31142 wxPyEndAllowThreads(__tstate);
31143 if (PyErr_Occurred()) SWIG_fail;
31144 }
31145 resultobj = SWIG_Py_Void();
31146 return resultobj;
31147 fail:
31148 return NULL;
31149 }
31150
31151
31152 SWIGINTERN PyObject *_wrap_Window_GetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31153 PyObject *resultobj = 0;
31154 wxWindow *arg1 = (wxWindow *) 0 ;
31155 wxSize result;
31156 void *argp1 = 0 ;
31157 int res1 = 0 ;
31158 PyObject *swig_obj[1] ;
31159
31160 if (!args) SWIG_fail;
31161 swig_obj[0] = args;
31162 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31163 if (!SWIG_IsOK(res1)) {
31164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31165 }
31166 arg1 = reinterpret_cast< wxWindow * >(argp1);
31167 {
31168 PyThreadState* __tstate = wxPyBeginAllowThreads();
31169 result = ((wxWindow const *)arg1)->GetBestFittingSize();
31170 wxPyEndAllowThreads(__tstate);
31171 if (PyErr_Occurred()) SWIG_fail;
31172 }
31173 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31174 return resultobj;
31175 fail:
31176 return NULL;
31177 }
31178
31179
31180 SWIGINTERN PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31181 PyObject *resultobj = 0;
31182 wxWindow *arg1 = (wxWindow *) 0 ;
31183 wxSize result;
31184 void *argp1 = 0 ;
31185 int res1 = 0 ;
31186 PyObject *swig_obj[1] ;
31187
31188 if (!args) SWIG_fail;
31189 swig_obj[0] = args;
31190 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31191 if (!SWIG_IsOK(res1)) {
31192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAdjustedBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31193 }
31194 arg1 = reinterpret_cast< wxWindow * >(argp1);
31195 {
31196 PyThreadState* __tstate = wxPyBeginAllowThreads();
31197 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
31198 wxPyEndAllowThreads(__tstate);
31199 if (PyErr_Occurred()) SWIG_fail;
31200 }
31201 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31202 return resultobj;
31203 fail:
31204 return NULL;
31205 }
31206
31207
31208 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31209 PyObject *resultobj = 0;
31210 wxWindow *arg1 = (wxWindow *) 0 ;
31211 int arg2 = (int) wxBOTH ;
31212 void *argp1 = 0 ;
31213 int res1 = 0 ;
31214 int val2 ;
31215 int ecode2 = 0 ;
31216 PyObject * obj0 = 0 ;
31217 PyObject * obj1 = 0 ;
31218 char * kwnames[] = {
31219 (char *) "self",(char *) "direction", NULL
31220 };
31221
31222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
31223 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31224 if (!SWIG_IsOK(res1)) {
31225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
31226 }
31227 arg1 = reinterpret_cast< wxWindow * >(argp1);
31228 if (obj1) {
31229 ecode2 = SWIG_AsVal_int(obj1, &val2);
31230 if (!SWIG_IsOK(ecode2)) {
31231 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
31232 }
31233 arg2 = static_cast< int >(val2);
31234 }
31235 {
31236 PyThreadState* __tstate = wxPyBeginAllowThreads();
31237 (arg1)->Center(arg2);
31238 wxPyEndAllowThreads(__tstate);
31239 if (PyErr_Occurred()) SWIG_fail;
31240 }
31241 resultobj = SWIG_Py_Void();
31242 return resultobj;
31243 fail:
31244 return NULL;
31245 }
31246
31247
31248 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31249 PyObject *resultobj = 0;
31250 wxWindow *arg1 = (wxWindow *) 0 ;
31251 int arg2 = (int) wxBOTH ;
31252 void *argp1 = 0 ;
31253 int res1 = 0 ;
31254 int val2 ;
31255 int ecode2 = 0 ;
31256 PyObject * obj0 = 0 ;
31257 PyObject * obj1 = 0 ;
31258 char * kwnames[] = {
31259 (char *) "self",(char *) "dir", NULL
31260 };
31261
31262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
31263 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31264 if (!SWIG_IsOK(res1)) {
31265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
31266 }
31267 arg1 = reinterpret_cast< wxWindow * >(argp1);
31268 if (obj1) {
31269 ecode2 = SWIG_AsVal_int(obj1, &val2);
31270 if (!SWIG_IsOK(ecode2)) {
31271 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
31272 }
31273 arg2 = static_cast< int >(val2);
31274 }
31275 {
31276 PyThreadState* __tstate = wxPyBeginAllowThreads();
31277 (arg1)->CenterOnParent(arg2);
31278 wxPyEndAllowThreads(__tstate);
31279 if (PyErr_Occurred()) SWIG_fail;
31280 }
31281 resultobj = SWIG_Py_Void();
31282 return resultobj;
31283 fail:
31284 return NULL;
31285 }
31286
31287
31288 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31289 PyObject *resultobj = 0;
31290 wxWindow *arg1 = (wxWindow *) 0 ;
31291 void *argp1 = 0 ;
31292 int res1 = 0 ;
31293 PyObject *swig_obj[1] ;
31294
31295 if (!args) SWIG_fail;
31296 swig_obj[0] = args;
31297 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31298 if (!SWIG_IsOK(res1)) {
31299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
31300 }
31301 arg1 = reinterpret_cast< wxWindow * >(argp1);
31302 {
31303 PyThreadState* __tstate = wxPyBeginAllowThreads();
31304 (arg1)->Fit();
31305 wxPyEndAllowThreads(__tstate);
31306 if (PyErr_Occurred()) SWIG_fail;
31307 }
31308 resultobj = SWIG_Py_Void();
31309 return resultobj;
31310 fail:
31311 return NULL;
31312 }
31313
31314
31315 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31316 PyObject *resultobj = 0;
31317 wxWindow *arg1 = (wxWindow *) 0 ;
31318 void *argp1 = 0 ;
31319 int res1 = 0 ;
31320 PyObject *swig_obj[1] ;
31321
31322 if (!args) SWIG_fail;
31323 swig_obj[0] = args;
31324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31325 if (!SWIG_IsOK(res1)) {
31326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
31327 }
31328 arg1 = reinterpret_cast< wxWindow * >(argp1);
31329 {
31330 PyThreadState* __tstate = wxPyBeginAllowThreads();
31331 (arg1)->FitInside();
31332 wxPyEndAllowThreads(__tstate);
31333 if (PyErr_Occurred()) SWIG_fail;
31334 }
31335 resultobj = SWIG_Py_Void();
31336 return resultobj;
31337 fail:
31338 return NULL;
31339 }
31340
31341
31342 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31343 PyObject *resultobj = 0;
31344 wxWindow *arg1 = (wxWindow *) 0 ;
31345 int arg2 ;
31346 int arg3 ;
31347 int arg4 = (int) -1 ;
31348 int arg5 = (int) -1 ;
31349 int arg6 = (int) -1 ;
31350 int arg7 = (int) -1 ;
31351 void *argp1 = 0 ;
31352 int res1 = 0 ;
31353 int val2 ;
31354 int ecode2 = 0 ;
31355 int val3 ;
31356 int ecode3 = 0 ;
31357 int val4 ;
31358 int ecode4 = 0 ;
31359 int val5 ;
31360 int ecode5 = 0 ;
31361 int val6 ;
31362 int ecode6 = 0 ;
31363 int val7 ;
31364 int ecode7 = 0 ;
31365 PyObject * obj0 = 0 ;
31366 PyObject * obj1 = 0 ;
31367 PyObject * obj2 = 0 ;
31368 PyObject * obj3 = 0 ;
31369 PyObject * obj4 = 0 ;
31370 PyObject * obj5 = 0 ;
31371 PyObject * obj6 = 0 ;
31372 char * kwnames[] = {
31373 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
31374 };
31375
31376 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
31377 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31378 if (!SWIG_IsOK(res1)) {
31379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31380 }
31381 arg1 = reinterpret_cast< wxWindow * >(argp1);
31382 ecode2 = SWIG_AsVal_int(obj1, &val2);
31383 if (!SWIG_IsOK(ecode2)) {
31384 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
31385 }
31386 arg2 = static_cast< int >(val2);
31387 ecode3 = SWIG_AsVal_int(obj2, &val3);
31388 if (!SWIG_IsOK(ecode3)) {
31389 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
31390 }
31391 arg3 = static_cast< int >(val3);
31392 if (obj3) {
31393 ecode4 = SWIG_AsVal_int(obj3, &val4);
31394 if (!SWIG_IsOK(ecode4)) {
31395 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
31396 }
31397 arg4 = static_cast< int >(val4);
31398 }
31399 if (obj4) {
31400 ecode5 = SWIG_AsVal_int(obj4, &val5);
31401 if (!SWIG_IsOK(ecode5)) {
31402 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
31403 }
31404 arg5 = static_cast< int >(val5);
31405 }
31406 if (obj5) {
31407 ecode6 = SWIG_AsVal_int(obj5, &val6);
31408 if (!SWIG_IsOK(ecode6)) {
31409 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
31410 }
31411 arg6 = static_cast< int >(val6);
31412 }
31413 if (obj6) {
31414 ecode7 = SWIG_AsVal_int(obj6, &val7);
31415 if (!SWIG_IsOK(ecode7)) {
31416 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
31417 }
31418 arg7 = static_cast< int >(val7);
31419 }
31420 {
31421 PyThreadState* __tstate = wxPyBeginAllowThreads();
31422 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
31423 wxPyEndAllowThreads(__tstate);
31424 if (PyErr_Occurred()) SWIG_fail;
31425 }
31426 resultobj = SWIG_Py_Void();
31427 return resultobj;
31428 fail:
31429 return NULL;
31430 }
31431
31432
31433 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31434 PyObject *resultobj = 0;
31435 wxWindow *arg1 = (wxWindow *) 0 ;
31436 wxSize *arg2 = 0 ;
31437 wxSize const &arg3_defvalue = wxDefaultSize ;
31438 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31439 wxSize const &arg4_defvalue = wxDefaultSize ;
31440 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
31441 void *argp1 = 0 ;
31442 int res1 = 0 ;
31443 wxSize temp2 ;
31444 wxSize temp3 ;
31445 wxSize temp4 ;
31446 PyObject * obj0 = 0 ;
31447 PyObject * obj1 = 0 ;
31448 PyObject * obj2 = 0 ;
31449 PyObject * obj3 = 0 ;
31450 char * kwnames[] = {
31451 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
31452 };
31453
31454 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
31455 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31456 if (!SWIG_IsOK(res1)) {
31457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31458 }
31459 arg1 = reinterpret_cast< wxWindow * >(argp1);
31460 {
31461 arg2 = &temp2;
31462 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31463 }
31464 if (obj2) {
31465 {
31466 arg3 = &temp3;
31467 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31468 }
31469 }
31470 if (obj3) {
31471 {
31472 arg4 = &temp4;
31473 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
31474 }
31475 }
31476 {
31477 PyThreadState* __tstate = wxPyBeginAllowThreads();
31478 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
31479 wxPyEndAllowThreads(__tstate);
31480 if (PyErr_Occurred()) SWIG_fail;
31481 }
31482 resultobj = SWIG_Py_Void();
31483 return resultobj;
31484 fail:
31485 return NULL;
31486 }
31487
31488
31489 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31490 PyObject *resultobj = 0;
31491 wxWindow *arg1 = (wxWindow *) 0 ;
31492 int arg2 ;
31493 int arg3 ;
31494 int arg4 = (int) -1 ;
31495 int arg5 = (int) -1 ;
31496 void *argp1 = 0 ;
31497 int res1 = 0 ;
31498 int val2 ;
31499 int ecode2 = 0 ;
31500 int val3 ;
31501 int ecode3 = 0 ;
31502 int val4 ;
31503 int ecode4 = 0 ;
31504 int val5 ;
31505 int ecode5 = 0 ;
31506 PyObject * obj0 = 0 ;
31507 PyObject * obj1 = 0 ;
31508 PyObject * obj2 = 0 ;
31509 PyObject * obj3 = 0 ;
31510 PyObject * obj4 = 0 ;
31511 char * kwnames[] = {
31512 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
31513 };
31514
31515 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
31516 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31517 if (!SWIG_IsOK(res1)) {
31518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31519 }
31520 arg1 = reinterpret_cast< wxWindow * >(argp1);
31521 ecode2 = SWIG_AsVal_int(obj1, &val2);
31522 if (!SWIG_IsOK(ecode2)) {
31523 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
31524 }
31525 arg2 = static_cast< int >(val2);
31526 ecode3 = SWIG_AsVal_int(obj2, &val3);
31527 if (!SWIG_IsOK(ecode3)) {
31528 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
31529 }
31530 arg3 = static_cast< int >(val3);
31531 if (obj3) {
31532 ecode4 = SWIG_AsVal_int(obj3, &val4);
31533 if (!SWIG_IsOK(ecode4)) {
31534 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
31535 }
31536 arg4 = static_cast< int >(val4);
31537 }
31538 if (obj4) {
31539 ecode5 = SWIG_AsVal_int(obj4, &val5);
31540 if (!SWIG_IsOK(ecode5)) {
31541 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
31542 }
31543 arg5 = static_cast< int >(val5);
31544 }
31545 {
31546 PyThreadState* __tstate = wxPyBeginAllowThreads();
31547 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
31548 wxPyEndAllowThreads(__tstate);
31549 if (PyErr_Occurred()) SWIG_fail;
31550 }
31551 resultobj = SWIG_Py_Void();
31552 return resultobj;
31553 fail:
31554 return NULL;
31555 }
31556
31557
31558 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31559 PyObject *resultobj = 0;
31560 wxWindow *arg1 = (wxWindow *) 0 ;
31561 wxSize *arg2 = 0 ;
31562 wxSize const &arg3_defvalue = wxDefaultSize ;
31563 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31564 void *argp1 = 0 ;
31565 int res1 = 0 ;
31566 wxSize temp2 ;
31567 wxSize temp3 ;
31568 PyObject * obj0 = 0 ;
31569 PyObject * obj1 = 0 ;
31570 PyObject * obj2 = 0 ;
31571 char * kwnames[] = {
31572 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
31573 };
31574
31575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31576 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31577 if (!SWIG_IsOK(res1)) {
31578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31579 }
31580 arg1 = reinterpret_cast< wxWindow * >(argp1);
31581 {
31582 arg2 = &temp2;
31583 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31584 }
31585 if (obj2) {
31586 {
31587 arg3 = &temp3;
31588 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31589 }
31590 }
31591 {
31592 PyThreadState* __tstate = wxPyBeginAllowThreads();
31593 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
31594 wxPyEndAllowThreads(__tstate);
31595 if (PyErr_Occurred()) SWIG_fail;
31596 }
31597 resultobj = SWIG_Py_Void();
31598 return resultobj;
31599 fail:
31600 return NULL;
31601 }
31602
31603
31604 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31605 PyObject *resultobj = 0;
31606 wxWindow *arg1 = (wxWindow *) 0 ;
31607 wxSize result;
31608 void *argp1 = 0 ;
31609 int res1 = 0 ;
31610 PyObject *swig_obj[1] ;
31611
31612 if (!args) SWIG_fail;
31613 swig_obj[0] = args;
31614 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31615 if (!SWIG_IsOK(res1)) {
31616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31617 }
31618 arg1 = reinterpret_cast< wxWindow * >(argp1);
31619 {
31620 PyThreadState* __tstate = wxPyBeginAllowThreads();
31621 result = ((wxWindow const *)arg1)->GetMaxSize();
31622 wxPyEndAllowThreads(__tstate);
31623 if (PyErr_Occurred()) SWIG_fail;
31624 }
31625 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31626 return resultobj;
31627 fail:
31628 return NULL;
31629 }
31630
31631
31632 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31633 PyObject *resultobj = 0;
31634 wxWindow *arg1 = (wxWindow *) 0 ;
31635 wxSize result;
31636 void *argp1 = 0 ;
31637 int res1 = 0 ;
31638 PyObject *swig_obj[1] ;
31639
31640 if (!args) SWIG_fail;
31641 swig_obj[0] = args;
31642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31643 if (!SWIG_IsOK(res1)) {
31644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31645 }
31646 arg1 = reinterpret_cast< wxWindow * >(argp1);
31647 {
31648 PyThreadState* __tstate = wxPyBeginAllowThreads();
31649 result = ((wxWindow const *)arg1)->GetMinSize();
31650 wxPyEndAllowThreads(__tstate);
31651 if (PyErr_Occurred()) SWIG_fail;
31652 }
31653 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31654 return resultobj;
31655 fail:
31656 return NULL;
31657 }
31658
31659
31660 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31661 PyObject *resultobj = 0;
31662 wxWindow *arg1 = (wxWindow *) 0 ;
31663 wxSize *arg2 = 0 ;
31664 void *argp1 = 0 ;
31665 int res1 = 0 ;
31666 wxSize temp2 ;
31667 PyObject * obj0 = 0 ;
31668 PyObject * obj1 = 0 ;
31669 char * kwnames[] = {
31670 (char *) "self",(char *) "minSize", NULL
31671 };
31672
31673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
31674 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31675 if (!SWIG_IsOK(res1)) {
31676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31677 }
31678 arg1 = reinterpret_cast< wxWindow * >(argp1);
31679 {
31680 arg2 = &temp2;
31681 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31682 }
31683 {
31684 PyThreadState* __tstate = wxPyBeginAllowThreads();
31685 (arg1)->SetMinSize((wxSize const &)*arg2);
31686 wxPyEndAllowThreads(__tstate);
31687 if (PyErr_Occurred()) SWIG_fail;
31688 }
31689 resultobj = SWIG_Py_Void();
31690 return resultobj;
31691 fail:
31692 return NULL;
31693 }
31694
31695
31696 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31697 PyObject *resultobj = 0;
31698 wxWindow *arg1 = (wxWindow *) 0 ;
31699 wxSize *arg2 = 0 ;
31700 void *argp1 = 0 ;
31701 int res1 = 0 ;
31702 wxSize temp2 ;
31703 PyObject * obj0 = 0 ;
31704 PyObject * obj1 = 0 ;
31705 char * kwnames[] = {
31706 (char *) "self",(char *) "maxSize", NULL
31707 };
31708
31709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
31710 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31711 if (!SWIG_IsOK(res1)) {
31712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31713 }
31714 arg1 = reinterpret_cast< wxWindow * >(argp1);
31715 {
31716 arg2 = &temp2;
31717 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31718 }
31719 {
31720 PyThreadState* __tstate = wxPyBeginAllowThreads();
31721 (arg1)->SetMaxSize((wxSize const &)*arg2);
31722 wxPyEndAllowThreads(__tstate);
31723 if (PyErr_Occurred()) SWIG_fail;
31724 }
31725 resultobj = SWIG_Py_Void();
31726 return resultobj;
31727 fail:
31728 return NULL;
31729 }
31730
31731
31732 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31733 PyObject *resultobj = 0;
31734 wxWindow *arg1 = (wxWindow *) 0 ;
31735 int result;
31736 void *argp1 = 0 ;
31737 int res1 = 0 ;
31738 PyObject *swig_obj[1] ;
31739
31740 if (!args) SWIG_fail;
31741 swig_obj[0] = args;
31742 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31743 if (!SWIG_IsOK(res1)) {
31744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
31745 }
31746 arg1 = reinterpret_cast< wxWindow * >(argp1);
31747 {
31748 PyThreadState* __tstate = wxPyBeginAllowThreads();
31749 result = (int)((wxWindow const *)arg1)->GetMinWidth();
31750 wxPyEndAllowThreads(__tstate);
31751 if (PyErr_Occurred()) SWIG_fail;
31752 }
31753 resultobj = SWIG_From_int(static_cast< int >(result));
31754 return resultobj;
31755 fail:
31756 return NULL;
31757 }
31758
31759
31760 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31761 PyObject *resultobj = 0;
31762 wxWindow *arg1 = (wxWindow *) 0 ;
31763 int result;
31764 void *argp1 = 0 ;
31765 int res1 = 0 ;
31766 PyObject *swig_obj[1] ;
31767
31768 if (!args) SWIG_fail;
31769 swig_obj[0] = args;
31770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31771 if (!SWIG_IsOK(res1)) {
31772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
31773 }
31774 arg1 = reinterpret_cast< wxWindow * >(argp1);
31775 {
31776 PyThreadState* __tstate = wxPyBeginAllowThreads();
31777 result = (int)((wxWindow const *)arg1)->GetMinHeight();
31778 wxPyEndAllowThreads(__tstate);
31779 if (PyErr_Occurred()) SWIG_fail;
31780 }
31781 resultobj = SWIG_From_int(static_cast< int >(result));
31782 return resultobj;
31783 fail:
31784 return NULL;
31785 }
31786
31787
31788 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31789 PyObject *resultobj = 0;
31790 wxWindow *arg1 = (wxWindow *) 0 ;
31791 int result;
31792 void *argp1 = 0 ;
31793 int res1 = 0 ;
31794 PyObject *swig_obj[1] ;
31795
31796 if (!args) SWIG_fail;
31797 swig_obj[0] = args;
31798 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31799 if (!SWIG_IsOK(res1)) {
31800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
31801 }
31802 arg1 = reinterpret_cast< wxWindow * >(argp1);
31803 {
31804 PyThreadState* __tstate = wxPyBeginAllowThreads();
31805 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
31806 wxPyEndAllowThreads(__tstate);
31807 if (PyErr_Occurred()) SWIG_fail;
31808 }
31809 resultobj = SWIG_From_int(static_cast< int >(result));
31810 return resultobj;
31811 fail:
31812 return NULL;
31813 }
31814
31815
31816 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31817 PyObject *resultobj = 0;
31818 wxWindow *arg1 = (wxWindow *) 0 ;
31819 int result;
31820 void *argp1 = 0 ;
31821 int res1 = 0 ;
31822 PyObject *swig_obj[1] ;
31823
31824 if (!args) SWIG_fail;
31825 swig_obj[0] = args;
31826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31827 if (!SWIG_IsOK(res1)) {
31828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
31829 }
31830 arg1 = reinterpret_cast< wxWindow * >(argp1);
31831 {
31832 PyThreadState* __tstate = wxPyBeginAllowThreads();
31833 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
31834 wxPyEndAllowThreads(__tstate);
31835 if (PyErr_Occurred()) SWIG_fail;
31836 }
31837 resultobj = SWIG_From_int(static_cast< int >(result));
31838 return resultobj;
31839 fail:
31840 return NULL;
31841 }
31842
31843
31844 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31845 PyObject *resultobj = 0;
31846 wxWindow *arg1 = (wxWindow *) 0 ;
31847 wxSize *arg2 = 0 ;
31848 void *argp1 = 0 ;
31849 int res1 = 0 ;
31850 wxSize temp2 ;
31851 PyObject * obj0 = 0 ;
31852 PyObject * obj1 = 0 ;
31853 char * kwnames[] = {
31854 (char *) "self",(char *) "size", NULL
31855 };
31856
31857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
31858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31859 if (!SWIG_IsOK(res1)) {
31860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31861 }
31862 arg1 = reinterpret_cast< wxWindow * >(argp1);
31863 {
31864 arg2 = &temp2;
31865 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31866 }
31867 {
31868 PyThreadState* __tstate = wxPyBeginAllowThreads();
31869 (arg1)->SetVirtualSize((wxSize const &)*arg2);
31870 wxPyEndAllowThreads(__tstate);
31871 if (PyErr_Occurred()) SWIG_fail;
31872 }
31873 resultobj = SWIG_Py_Void();
31874 return resultobj;
31875 fail:
31876 return NULL;
31877 }
31878
31879
31880 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31881 PyObject *resultobj = 0;
31882 wxWindow *arg1 = (wxWindow *) 0 ;
31883 int arg2 ;
31884 int arg3 ;
31885 void *argp1 = 0 ;
31886 int res1 = 0 ;
31887 int val2 ;
31888 int ecode2 = 0 ;
31889 int val3 ;
31890 int ecode3 = 0 ;
31891 PyObject * obj0 = 0 ;
31892 PyObject * obj1 = 0 ;
31893 PyObject * obj2 = 0 ;
31894 char * kwnames[] = {
31895 (char *) "self",(char *) "w",(char *) "h", NULL
31896 };
31897
31898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31900 if (!SWIG_IsOK(res1)) {
31901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
31902 }
31903 arg1 = reinterpret_cast< wxWindow * >(argp1);
31904 ecode2 = SWIG_AsVal_int(obj1, &val2);
31905 if (!SWIG_IsOK(ecode2)) {
31906 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
31907 }
31908 arg2 = static_cast< int >(val2);
31909 ecode3 = SWIG_AsVal_int(obj2, &val3);
31910 if (!SWIG_IsOK(ecode3)) {
31911 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
31912 }
31913 arg3 = static_cast< int >(val3);
31914 {
31915 PyThreadState* __tstate = wxPyBeginAllowThreads();
31916 (arg1)->SetVirtualSize(arg2,arg3);
31917 wxPyEndAllowThreads(__tstate);
31918 if (PyErr_Occurred()) SWIG_fail;
31919 }
31920 resultobj = SWIG_Py_Void();
31921 return resultobj;
31922 fail:
31923 return NULL;
31924 }
31925
31926
31927 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31928 PyObject *resultobj = 0;
31929 wxWindow *arg1 = (wxWindow *) 0 ;
31930 wxSize result;
31931 void *argp1 = 0 ;
31932 int res1 = 0 ;
31933 PyObject *swig_obj[1] ;
31934
31935 if (!args) SWIG_fail;
31936 swig_obj[0] = args;
31937 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31938 if (!SWIG_IsOK(res1)) {
31939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31940 }
31941 arg1 = reinterpret_cast< wxWindow * >(argp1);
31942 {
31943 PyThreadState* __tstate = wxPyBeginAllowThreads();
31944 result = ((wxWindow const *)arg1)->GetVirtualSize();
31945 wxPyEndAllowThreads(__tstate);
31946 if (PyErr_Occurred()) SWIG_fail;
31947 }
31948 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31949 return resultobj;
31950 fail:
31951 return NULL;
31952 }
31953
31954
31955 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31956 PyObject *resultobj = 0;
31957 wxWindow *arg1 = (wxWindow *) 0 ;
31958 int *arg2 = (int *) 0 ;
31959 int *arg3 = (int *) 0 ;
31960 void *argp1 = 0 ;
31961 int res1 = 0 ;
31962 int temp2 ;
31963 int res2 = SWIG_TMPOBJ ;
31964 int temp3 ;
31965 int res3 = SWIG_TMPOBJ ;
31966 PyObject *swig_obj[1] ;
31967
31968 arg2 = &temp2;
31969 arg3 = &temp3;
31970 if (!args) SWIG_fail;
31971 swig_obj[0] = args;
31972 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31973 if (!SWIG_IsOK(res1)) {
31974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31975 }
31976 arg1 = reinterpret_cast< wxWindow * >(argp1);
31977 {
31978 PyThreadState* __tstate = wxPyBeginAllowThreads();
31979 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
31980 wxPyEndAllowThreads(__tstate);
31981 if (PyErr_Occurred()) SWIG_fail;
31982 }
31983 resultobj = SWIG_Py_Void();
31984 if (SWIG_IsTmpObj(res2)) {
31985 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31986 } else {
31987 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31988 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31989 }
31990 if (SWIG_IsTmpObj(res3)) {
31991 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31992 } else {
31993 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31994 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31995 }
31996 return resultobj;
31997 fail:
31998 return NULL;
31999 }
32000
32001
32002 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32003 PyObject *resultobj = 0;
32004 wxWindow *arg1 = (wxWindow *) 0 ;
32005 wxSize result;
32006 void *argp1 = 0 ;
32007 int res1 = 0 ;
32008 PyObject *swig_obj[1] ;
32009
32010 if (!args) SWIG_fail;
32011 swig_obj[0] = args;
32012 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32013 if (!SWIG_IsOK(res1)) {
32014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32015 }
32016 arg1 = reinterpret_cast< wxWindow * >(argp1);
32017 {
32018 PyThreadState* __tstate = wxPyBeginAllowThreads();
32019 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
32020 wxPyEndAllowThreads(__tstate);
32021 if (PyErr_Occurred()) SWIG_fail;
32022 }
32023 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32024 return resultobj;
32025 fail:
32026 return NULL;
32027 }
32028
32029
32030 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32031 PyObject *resultobj = 0;
32032 wxWindow *arg1 = (wxWindow *) 0 ;
32033 bool arg2 = (bool) true ;
32034 bool result;
32035 void *argp1 = 0 ;
32036 int res1 = 0 ;
32037 bool val2 ;
32038 int ecode2 = 0 ;
32039 PyObject * obj0 = 0 ;
32040 PyObject * obj1 = 0 ;
32041 char * kwnames[] = {
32042 (char *) "self",(char *) "show", NULL
32043 };
32044
32045 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
32046 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32047 if (!SWIG_IsOK(res1)) {
32048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
32049 }
32050 arg1 = reinterpret_cast< wxWindow * >(argp1);
32051 if (obj1) {
32052 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32053 if (!SWIG_IsOK(ecode2)) {
32054 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
32055 }
32056 arg2 = static_cast< bool >(val2);
32057 }
32058 {
32059 PyThreadState* __tstate = wxPyBeginAllowThreads();
32060 result = (bool)(arg1)->Show(arg2);
32061 wxPyEndAllowThreads(__tstate);
32062 if (PyErr_Occurred()) SWIG_fail;
32063 }
32064 {
32065 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32066 }
32067 return resultobj;
32068 fail:
32069 return NULL;
32070 }
32071
32072
32073 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32074 PyObject *resultobj = 0;
32075 wxWindow *arg1 = (wxWindow *) 0 ;
32076 bool 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_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
32086 }
32087 arg1 = reinterpret_cast< wxWindow * >(argp1);
32088 {
32089 PyThreadState* __tstate = wxPyBeginAllowThreads();
32090 result = (bool)(arg1)->Hide();
32091 wxPyEndAllowThreads(__tstate);
32092 if (PyErr_Occurred()) SWIG_fail;
32093 }
32094 {
32095 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32096 }
32097 return resultobj;
32098 fail:
32099 return NULL;
32100 }
32101
32102
32103 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32104 PyObject *resultobj = 0;
32105 wxWindow *arg1 = (wxWindow *) 0 ;
32106 bool arg2 = (bool) true ;
32107 bool result;
32108 void *argp1 = 0 ;
32109 int res1 = 0 ;
32110 bool val2 ;
32111 int ecode2 = 0 ;
32112 PyObject * obj0 = 0 ;
32113 PyObject * obj1 = 0 ;
32114 char * kwnames[] = {
32115 (char *) "self",(char *) "enable", NULL
32116 };
32117
32118 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
32119 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32120 if (!SWIG_IsOK(res1)) {
32121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
32122 }
32123 arg1 = reinterpret_cast< wxWindow * >(argp1);
32124 if (obj1) {
32125 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32126 if (!SWIG_IsOK(ecode2)) {
32127 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
32128 }
32129 arg2 = static_cast< bool >(val2);
32130 }
32131 {
32132 PyThreadState* __tstate = wxPyBeginAllowThreads();
32133 result = (bool)(arg1)->Enable(arg2);
32134 wxPyEndAllowThreads(__tstate);
32135 if (PyErr_Occurred()) SWIG_fail;
32136 }
32137 {
32138 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32139 }
32140 return resultobj;
32141 fail:
32142 return NULL;
32143 }
32144
32145
32146 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32147 PyObject *resultobj = 0;
32148 wxWindow *arg1 = (wxWindow *) 0 ;
32149 bool result;
32150 void *argp1 = 0 ;
32151 int res1 = 0 ;
32152 PyObject *swig_obj[1] ;
32153
32154 if (!args) SWIG_fail;
32155 swig_obj[0] = args;
32156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32157 if (!SWIG_IsOK(res1)) {
32158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
32159 }
32160 arg1 = reinterpret_cast< wxWindow * >(argp1);
32161 {
32162 PyThreadState* __tstate = wxPyBeginAllowThreads();
32163 result = (bool)(arg1)->Disable();
32164 wxPyEndAllowThreads(__tstate);
32165 if (PyErr_Occurred()) SWIG_fail;
32166 }
32167 {
32168 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32169 }
32170 return resultobj;
32171 fail:
32172 return NULL;
32173 }
32174
32175
32176 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32177 PyObject *resultobj = 0;
32178 wxWindow *arg1 = (wxWindow *) 0 ;
32179 bool result;
32180 void *argp1 = 0 ;
32181 int res1 = 0 ;
32182 PyObject *swig_obj[1] ;
32183
32184 if (!args) SWIG_fail;
32185 swig_obj[0] = args;
32186 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32187 if (!SWIG_IsOK(res1)) {
32188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
32189 }
32190 arg1 = reinterpret_cast< wxWindow * >(argp1);
32191 {
32192 PyThreadState* __tstate = wxPyBeginAllowThreads();
32193 result = (bool)((wxWindow const *)arg1)->IsShown();
32194 wxPyEndAllowThreads(__tstate);
32195 if (PyErr_Occurred()) SWIG_fail;
32196 }
32197 {
32198 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32199 }
32200 return resultobj;
32201 fail:
32202 return NULL;
32203 }
32204
32205
32206 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32207 PyObject *resultobj = 0;
32208 wxWindow *arg1 = (wxWindow *) 0 ;
32209 bool result;
32210 void *argp1 = 0 ;
32211 int res1 = 0 ;
32212 PyObject *swig_obj[1] ;
32213
32214 if (!args) SWIG_fail;
32215 swig_obj[0] = args;
32216 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32217 if (!SWIG_IsOK(res1)) {
32218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32219 }
32220 arg1 = reinterpret_cast< wxWindow * >(argp1);
32221 {
32222 PyThreadState* __tstate = wxPyBeginAllowThreads();
32223 result = (bool)((wxWindow const *)arg1)->IsEnabled();
32224 wxPyEndAllowThreads(__tstate);
32225 if (PyErr_Occurred()) SWIG_fail;
32226 }
32227 {
32228 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32229 }
32230 return resultobj;
32231 fail:
32232 return NULL;
32233 }
32234
32235
32236 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32237 PyObject *resultobj = 0;
32238 wxWindow *arg1 = (wxWindow *) 0 ;
32239 long arg2 ;
32240 void *argp1 = 0 ;
32241 int res1 = 0 ;
32242 long val2 ;
32243 int ecode2 = 0 ;
32244 PyObject * obj0 = 0 ;
32245 PyObject * obj1 = 0 ;
32246 char * kwnames[] = {
32247 (char *) "self",(char *) "style", NULL
32248 };
32249
32250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32251 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32252 if (!SWIG_IsOK(res1)) {
32253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
32254 }
32255 arg1 = reinterpret_cast< wxWindow * >(argp1);
32256 ecode2 = SWIG_AsVal_long(obj1, &val2);
32257 if (!SWIG_IsOK(ecode2)) {
32258 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
32259 }
32260 arg2 = static_cast< long >(val2);
32261 {
32262 PyThreadState* __tstate = wxPyBeginAllowThreads();
32263 (arg1)->SetWindowStyleFlag(arg2);
32264 wxPyEndAllowThreads(__tstate);
32265 if (PyErr_Occurred()) SWIG_fail;
32266 }
32267 resultobj = SWIG_Py_Void();
32268 return resultobj;
32269 fail:
32270 return NULL;
32271 }
32272
32273
32274 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32275 PyObject *resultobj = 0;
32276 wxWindow *arg1 = (wxWindow *) 0 ;
32277 long result;
32278 void *argp1 = 0 ;
32279 int res1 = 0 ;
32280 PyObject *swig_obj[1] ;
32281
32282 if (!args) SWIG_fail;
32283 swig_obj[0] = args;
32284 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32285 if (!SWIG_IsOK(res1)) {
32286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32287 }
32288 arg1 = reinterpret_cast< wxWindow * >(argp1);
32289 {
32290 PyThreadState* __tstate = wxPyBeginAllowThreads();
32291 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
32292 wxPyEndAllowThreads(__tstate);
32293 if (PyErr_Occurred()) SWIG_fail;
32294 }
32295 resultobj = SWIG_From_long(static_cast< long >(result));
32296 return resultobj;
32297 fail:
32298 return NULL;
32299 }
32300
32301
32302 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32303 PyObject *resultobj = 0;
32304 wxWindow *arg1 = (wxWindow *) 0 ;
32305 int arg2 ;
32306 bool result;
32307 void *argp1 = 0 ;
32308 int res1 = 0 ;
32309 int val2 ;
32310 int ecode2 = 0 ;
32311 PyObject * obj0 = 0 ;
32312 PyObject * obj1 = 0 ;
32313 char * kwnames[] = {
32314 (char *) "self",(char *) "flag", NULL
32315 };
32316
32317 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32318 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32319 if (!SWIG_IsOK(res1)) {
32320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32321 }
32322 arg1 = reinterpret_cast< wxWindow * >(argp1);
32323 ecode2 = SWIG_AsVal_int(obj1, &val2);
32324 if (!SWIG_IsOK(ecode2)) {
32325 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
32326 }
32327 arg2 = static_cast< int >(val2);
32328 {
32329 PyThreadState* __tstate = wxPyBeginAllowThreads();
32330 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
32331 wxPyEndAllowThreads(__tstate);
32332 if (PyErr_Occurred()) SWIG_fail;
32333 }
32334 {
32335 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32336 }
32337 return resultobj;
32338 fail:
32339 return NULL;
32340 }
32341
32342
32343 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32344 PyObject *resultobj = 0;
32345 wxWindow *arg1 = (wxWindow *) 0 ;
32346 bool result;
32347 void *argp1 = 0 ;
32348 int res1 = 0 ;
32349 PyObject *swig_obj[1] ;
32350
32351 if (!args) SWIG_fail;
32352 swig_obj[0] = args;
32353 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32354 if (!SWIG_IsOK(res1)) {
32355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
32356 }
32357 arg1 = reinterpret_cast< wxWindow * >(argp1);
32358 {
32359 PyThreadState* __tstate = wxPyBeginAllowThreads();
32360 result = (bool)((wxWindow const *)arg1)->IsRetained();
32361 wxPyEndAllowThreads(__tstate);
32362 if (PyErr_Occurred()) SWIG_fail;
32363 }
32364 {
32365 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32366 }
32367 return resultobj;
32368 fail:
32369 return NULL;
32370 }
32371
32372
32373 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32374 PyObject *resultobj = 0;
32375 wxWindow *arg1 = (wxWindow *) 0 ;
32376 long arg2 ;
32377 void *argp1 = 0 ;
32378 int res1 = 0 ;
32379 long val2 ;
32380 int ecode2 = 0 ;
32381 PyObject * obj0 = 0 ;
32382 PyObject * obj1 = 0 ;
32383 char * kwnames[] = {
32384 (char *) "self",(char *) "exStyle", NULL
32385 };
32386
32387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
32388 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32389 if (!SWIG_IsOK(res1)) {
32390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
32391 }
32392 arg1 = reinterpret_cast< wxWindow * >(argp1);
32393 ecode2 = SWIG_AsVal_long(obj1, &val2);
32394 if (!SWIG_IsOK(ecode2)) {
32395 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
32396 }
32397 arg2 = static_cast< long >(val2);
32398 {
32399 PyThreadState* __tstate = wxPyBeginAllowThreads();
32400 (arg1)->SetExtraStyle(arg2);
32401 wxPyEndAllowThreads(__tstate);
32402 if (PyErr_Occurred()) SWIG_fail;
32403 }
32404 resultobj = SWIG_Py_Void();
32405 return resultobj;
32406 fail:
32407 return NULL;
32408 }
32409
32410
32411 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32412 PyObject *resultobj = 0;
32413 wxWindow *arg1 = (wxWindow *) 0 ;
32414 long result;
32415 void *argp1 = 0 ;
32416 int res1 = 0 ;
32417 PyObject *swig_obj[1] ;
32418
32419 if (!args) SWIG_fail;
32420 swig_obj[0] = args;
32421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32422 if (!SWIG_IsOK(res1)) {
32423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
32424 }
32425 arg1 = reinterpret_cast< wxWindow * >(argp1);
32426 {
32427 PyThreadState* __tstate = wxPyBeginAllowThreads();
32428 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
32429 wxPyEndAllowThreads(__tstate);
32430 if (PyErr_Occurred()) SWIG_fail;
32431 }
32432 resultobj = SWIG_From_long(static_cast< long >(result));
32433 return resultobj;
32434 fail:
32435 return NULL;
32436 }
32437
32438
32439 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32440 PyObject *resultobj = 0;
32441 wxWindow *arg1 = (wxWindow *) 0 ;
32442 bool arg2 = (bool) true ;
32443 void *argp1 = 0 ;
32444 int res1 = 0 ;
32445 bool val2 ;
32446 int ecode2 = 0 ;
32447 PyObject * obj0 = 0 ;
32448 PyObject * obj1 = 0 ;
32449 char * kwnames[] = {
32450 (char *) "self",(char *) "modal", NULL
32451 };
32452
32453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
32454 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32455 if (!SWIG_IsOK(res1)) {
32456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
32457 }
32458 arg1 = reinterpret_cast< wxWindow * >(argp1);
32459 if (obj1) {
32460 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32461 if (!SWIG_IsOK(ecode2)) {
32462 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
32463 }
32464 arg2 = static_cast< bool >(val2);
32465 }
32466 {
32467 PyThreadState* __tstate = wxPyBeginAllowThreads();
32468 (arg1)->MakeModal(arg2);
32469 wxPyEndAllowThreads(__tstate);
32470 if (PyErr_Occurred()) SWIG_fail;
32471 }
32472 resultobj = SWIG_Py_Void();
32473 return resultobj;
32474 fail:
32475 return NULL;
32476 }
32477
32478
32479 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32480 PyObject *resultobj = 0;
32481 wxWindow *arg1 = (wxWindow *) 0 ;
32482 bool arg2 ;
32483 void *argp1 = 0 ;
32484 int res1 = 0 ;
32485 bool val2 ;
32486 int ecode2 = 0 ;
32487 PyObject * obj0 = 0 ;
32488 PyObject * obj1 = 0 ;
32489 char * kwnames[] = {
32490 (char *) "self",(char *) "enableTheme", NULL
32491 };
32492
32493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
32494 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32495 if (!SWIG_IsOK(res1)) {
32496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
32497 }
32498 arg1 = reinterpret_cast< wxWindow * >(argp1);
32499 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32500 if (!SWIG_IsOK(ecode2)) {
32501 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
32502 }
32503 arg2 = static_cast< bool >(val2);
32504 {
32505 PyThreadState* __tstate = wxPyBeginAllowThreads();
32506 (arg1)->SetThemeEnabled(arg2);
32507 wxPyEndAllowThreads(__tstate);
32508 if (PyErr_Occurred()) SWIG_fail;
32509 }
32510 resultobj = SWIG_Py_Void();
32511 return resultobj;
32512 fail:
32513 return NULL;
32514 }
32515
32516
32517 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32518 PyObject *resultobj = 0;
32519 wxWindow *arg1 = (wxWindow *) 0 ;
32520 bool result;
32521 void *argp1 = 0 ;
32522 int res1 = 0 ;
32523 PyObject *swig_obj[1] ;
32524
32525 if (!args) SWIG_fail;
32526 swig_obj[0] = args;
32527 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32528 if (!SWIG_IsOK(res1)) {
32529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32530 }
32531 arg1 = reinterpret_cast< wxWindow * >(argp1);
32532 {
32533 PyThreadState* __tstate = wxPyBeginAllowThreads();
32534 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
32535 wxPyEndAllowThreads(__tstate);
32536 if (PyErr_Occurred()) SWIG_fail;
32537 }
32538 {
32539 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32540 }
32541 return resultobj;
32542 fail:
32543 return NULL;
32544 }
32545
32546
32547 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32548 PyObject *resultobj = 0;
32549 wxWindow *arg1 = (wxWindow *) 0 ;
32550 void *argp1 = 0 ;
32551 int res1 = 0 ;
32552 PyObject *swig_obj[1] ;
32553
32554 if (!args) SWIG_fail;
32555 swig_obj[0] = args;
32556 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32557 if (!SWIG_IsOK(res1)) {
32558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
32559 }
32560 arg1 = reinterpret_cast< wxWindow * >(argp1);
32561 {
32562 PyThreadState* __tstate = wxPyBeginAllowThreads();
32563 (arg1)->SetFocus();
32564 wxPyEndAllowThreads(__tstate);
32565 if (PyErr_Occurred()) SWIG_fail;
32566 }
32567 resultobj = SWIG_Py_Void();
32568 return resultobj;
32569 fail:
32570 return NULL;
32571 }
32572
32573
32574 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32575 PyObject *resultobj = 0;
32576 wxWindow *arg1 = (wxWindow *) 0 ;
32577 void *argp1 = 0 ;
32578 int res1 = 0 ;
32579 PyObject *swig_obj[1] ;
32580
32581 if (!args) SWIG_fail;
32582 swig_obj[0] = args;
32583 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32584 if (!SWIG_IsOK(res1)) {
32585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
32586 }
32587 arg1 = reinterpret_cast< wxWindow * >(argp1);
32588 {
32589 PyThreadState* __tstate = wxPyBeginAllowThreads();
32590 (arg1)->SetFocusFromKbd();
32591 wxPyEndAllowThreads(__tstate);
32592 if (PyErr_Occurred()) SWIG_fail;
32593 }
32594 resultobj = SWIG_Py_Void();
32595 return resultobj;
32596 fail:
32597 return NULL;
32598 }
32599
32600
32601 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32602 PyObject *resultobj = 0;
32603 wxWindow *result = 0 ;
32604
32605 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
32606 {
32607 if (!wxPyCheckForApp()) SWIG_fail;
32608 PyThreadState* __tstate = wxPyBeginAllowThreads();
32609 result = (wxWindow *)wxWindow::FindFocus();
32610 wxPyEndAllowThreads(__tstate);
32611 if (PyErr_Occurred()) SWIG_fail;
32612 }
32613 {
32614 resultobj = wxPyMake_wxObject(result, 0);
32615 }
32616 return resultobj;
32617 fail:
32618 return NULL;
32619 }
32620
32621
32622 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32623 PyObject *resultobj = 0;
32624 wxWindow *arg1 = (wxWindow *) 0 ;
32625 bool result;
32626 void *argp1 = 0 ;
32627 int res1 = 0 ;
32628 PyObject *swig_obj[1] ;
32629
32630 if (!args) SWIG_fail;
32631 swig_obj[0] = args;
32632 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32633 if (!SWIG_IsOK(res1)) {
32634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
32635 }
32636 arg1 = reinterpret_cast< wxWindow * >(argp1);
32637 {
32638 PyThreadState* __tstate = wxPyBeginAllowThreads();
32639 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
32640 wxPyEndAllowThreads(__tstate);
32641 if (PyErr_Occurred()) SWIG_fail;
32642 }
32643 {
32644 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32645 }
32646 return resultobj;
32647 fail:
32648 return NULL;
32649 }
32650
32651
32652 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32653 PyObject *resultobj = 0;
32654 wxWindow *arg1 = (wxWindow *) 0 ;
32655 bool result;
32656 void *argp1 = 0 ;
32657 int res1 = 0 ;
32658 PyObject *swig_obj[1] ;
32659
32660 if (!args) SWIG_fail;
32661 swig_obj[0] = args;
32662 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32663 if (!SWIG_IsOK(res1)) {
32664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
32665 }
32666 arg1 = reinterpret_cast< wxWindow * >(argp1);
32667 {
32668 PyThreadState* __tstate = wxPyBeginAllowThreads();
32669 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
32670 wxPyEndAllowThreads(__tstate);
32671 if (PyErr_Occurred()) SWIG_fail;
32672 }
32673 {
32674 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32675 }
32676 return resultobj;
32677 fail:
32678 return NULL;
32679 }
32680
32681
32682 SWIGINTERN PyObject *_wrap_Window_GetDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32683 PyObject *resultobj = 0;
32684 wxWindow *arg1 = (wxWindow *) 0 ;
32685 wxWindow *result = 0 ;
32686 void *argp1 = 0 ;
32687 int res1 = 0 ;
32688 PyObject *swig_obj[1] ;
32689
32690 if (!args) SWIG_fail;
32691 swig_obj[0] = args;
32692 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32693 if (!SWIG_IsOK(res1)) {
32694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultItem" "', expected argument " "1"" of type '" "wxWindow const *""'");
32695 }
32696 arg1 = reinterpret_cast< wxWindow * >(argp1);
32697 {
32698 PyThreadState* __tstate = wxPyBeginAllowThreads();
32699 result = (wxWindow *)((wxWindow const *)arg1)->GetDefaultItem();
32700 wxPyEndAllowThreads(__tstate);
32701 if (PyErr_Occurred()) SWIG_fail;
32702 }
32703 {
32704 resultobj = wxPyMake_wxObject(result, 0);
32705 }
32706 return resultobj;
32707 fail:
32708 return NULL;
32709 }
32710
32711
32712 SWIGINTERN PyObject *_wrap_Window_SetDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32713 PyObject *resultobj = 0;
32714 wxWindow *arg1 = (wxWindow *) 0 ;
32715 wxWindow *arg2 = (wxWindow *) 0 ;
32716 wxWindow *result = 0 ;
32717 void *argp1 = 0 ;
32718 int res1 = 0 ;
32719 void *argp2 = 0 ;
32720 int res2 = 0 ;
32721 PyObject * obj0 = 0 ;
32722 PyObject * obj1 = 0 ;
32723 char * kwnames[] = {
32724 (char *) "self",(char *) "child", NULL
32725 };
32726
32727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDefaultItem",kwnames,&obj0,&obj1)) SWIG_fail;
32728 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32729 if (!SWIG_IsOK(res1)) {
32730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDefaultItem" "', expected argument " "1"" of type '" "wxWindow *""'");
32731 }
32732 arg1 = reinterpret_cast< wxWindow * >(argp1);
32733 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32734 if (!SWIG_IsOK(res2)) {
32735 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDefaultItem" "', expected argument " "2"" of type '" "wxWindow *""'");
32736 }
32737 arg2 = reinterpret_cast< wxWindow * >(argp2);
32738 {
32739 PyThreadState* __tstate = wxPyBeginAllowThreads();
32740 result = (wxWindow *)(arg1)->SetDefaultItem(arg2);
32741 wxPyEndAllowThreads(__tstate);
32742 if (PyErr_Occurred()) SWIG_fail;
32743 }
32744 {
32745 resultobj = wxPyMake_wxObject(result, 0);
32746 }
32747 return resultobj;
32748 fail:
32749 return NULL;
32750 }
32751
32752
32753 SWIGINTERN PyObject *_wrap_Window_SetTmpDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32754 PyObject *resultobj = 0;
32755 wxWindow *arg1 = (wxWindow *) 0 ;
32756 wxWindow *arg2 = (wxWindow *) 0 ;
32757 void *argp1 = 0 ;
32758 int res1 = 0 ;
32759 void *argp2 = 0 ;
32760 int res2 = 0 ;
32761 PyObject * obj0 = 0 ;
32762 PyObject * obj1 = 0 ;
32763 char * kwnames[] = {
32764 (char *) "self",(char *) "win", NULL
32765 };
32766
32767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTmpDefaultItem",kwnames,&obj0,&obj1)) SWIG_fail;
32768 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32769 if (!SWIG_IsOK(res1)) {
32770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTmpDefaultItem" "', expected argument " "1"" of type '" "wxWindow *""'");
32771 }
32772 arg1 = reinterpret_cast< wxWindow * >(argp1);
32773 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32774 if (!SWIG_IsOK(res2)) {
32775 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetTmpDefaultItem" "', expected argument " "2"" of type '" "wxWindow *""'");
32776 }
32777 arg2 = reinterpret_cast< wxWindow * >(argp2);
32778 {
32779 PyThreadState* __tstate = wxPyBeginAllowThreads();
32780 (arg1)->SetTmpDefaultItem(arg2);
32781 wxPyEndAllowThreads(__tstate);
32782 if (PyErr_Occurred()) SWIG_fail;
32783 }
32784 resultobj = SWIG_Py_Void();
32785 return resultobj;
32786 fail:
32787 return NULL;
32788 }
32789
32790
32791 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32792 PyObject *resultobj = 0;
32793 wxWindow *arg1 = (wxWindow *) 0 ;
32794 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
32795 bool result;
32796 void *argp1 = 0 ;
32797 int res1 = 0 ;
32798 int val2 ;
32799 int ecode2 = 0 ;
32800 PyObject * obj0 = 0 ;
32801 PyObject * obj1 = 0 ;
32802 char * kwnames[] = {
32803 (char *) "self",(char *) "flags", NULL
32804 };
32805
32806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
32807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32808 if (!SWIG_IsOK(res1)) {
32809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
32810 }
32811 arg1 = reinterpret_cast< wxWindow * >(argp1);
32812 if (obj1) {
32813 ecode2 = SWIG_AsVal_int(obj1, &val2);
32814 if (!SWIG_IsOK(ecode2)) {
32815 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
32816 }
32817 arg2 = static_cast< int >(val2);
32818 }
32819 {
32820 PyThreadState* __tstate = wxPyBeginAllowThreads();
32821 result = (bool)(arg1)->Navigate(arg2);
32822 wxPyEndAllowThreads(__tstate);
32823 if (PyErr_Occurred()) SWIG_fail;
32824 }
32825 {
32826 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32827 }
32828 return resultobj;
32829 fail:
32830 return NULL;
32831 }
32832
32833
32834 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32835 PyObject *resultobj = 0;
32836 wxWindow *arg1 = (wxWindow *) 0 ;
32837 wxWindow *arg2 = (wxWindow *) 0 ;
32838 void *argp1 = 0 ;
32839 int res1 = 0 ;
32840 void *argp2 = 0 ;
32841 int res2 = 0 ;
32842 PyObject * obj0 = 0 ;
32843 PyObject * obj1 = 0 ;
32844 char * kwnames[] = {
32845 (char *) "self",(char *) "win", NULL
32846 };
32847
32848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
32849 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32850 if (!SWIG_IsOK(res1)) {
32851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
32852 }
32853 arg1 = reinterpret_cast< wxWindow * >(argp1);
32854 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32855 if (!SWIG_IsOK(res2)) {
32856 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
32857 }
32858 arg2 = reinterpret_cast< wxWindow * >(argp2);
32859 {
32860 PyThreadState* __tstate = wxPyBeginAllowThreads();
32861 (arg1)->MoveAfterInTabOrder(arg2);
32862 wxPyEndAllowThreads(__tstate);
32863 if (PyErr_Occurred()) SWIG_fail;
32864 }
32865 resultobj = SWIG_Py_Void();
32866 return resultobj;
32867 fail:
32868 return NULL;
32869 }
32870
32871
32872 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32873 PyObject *resultobj = 0;
32874 wxWindow *arg1 = (wxWindow *) 0 ;
32875 wxWindow *arg2 = (wxWindow *) 0 ;
32876 void *argp1 = 0 ;
32877 int res1 = 0 ;
32878 void *argp2 = 0 ;
32879 int res2 = 0 ;
32880 PyObject * obj0 = 0 ;
32881 PyObject * obj1 = 0 ;
32882 char * kwnames[] = {
32883 (char *) "self",(char *) "win", NULL
32884 };
32885
32886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
32887 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32888 if (!SWIG_IsOK(res1)) {
32889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
32890 }
32891 arg1 = reinterpret_cast< wxWindow * >(argp1);
32892 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32893 if (!SWIG_IsOK(res2)) {
32894 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
32895 }
32896 arg2 = reinterpret_cast< wxWindow * >(argp2);
32897 {
32898 PyThreadState* __tstate = wxPyBeginAllowThreads();
32899 (arg1)->MoveBeforeInTabOrder(arg2);
32900 wxPyEndAllowThreads(__tstate);
32901 if (PyErr_Occurred()) SWIG_fail;
32902 }
32903 resultobj = SWIG_Py_Void();
32904 return resultobj;
32905 fail:
32906 return NULL;
32907 }
32908
32909
32910 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32911 PyObject *resultobj = 0;
32912 wxWindow *arg1 = (wxWindow *) 0 ;
32913 PyObject *result = 0 ;
32914 void *argp1 = 0 ;
32915 int res1 = 0 ;
32916 PyObject *swig_obj[1] ;
32917
32918 if (!args) SWIG_fail;
32919 swig_obj[0] = args;
32920 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32921 if (!SWIG_IsOK(res1)) {
32922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
32923 }
32924 arg1 = reinterpret_cast< wxWindow * >(argp1);
32925 {
32926 PyThreadState* __tstate = wxPyBeginAllowThreads();
32927 result = (PyObject *)wxWindow_GetChildren(arg1);
32928 wxPyEndAllowThreads(__tstate);
32929 if (PyErr_Occurred()) SWIG_fail;
32930 }
32931 resultobj = result;
32932 return resultobj;
32933 fail:
32934 return NULL;
32935 }
32936
32937
32938 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32939 PyObject *resultobj = 0;
32940 wxWindow *arg1 = (wxWindow *) 0 ;
32941 wxWindow *result = 0 ;
32942 void *argp1 = 0 ;
32943 int res1 = 0 ;
32944 PyObject *swig_obj[1] ;
32945
32946 if (!args) SWIG_fail;
32947 swig_obj[0] = args;
32948 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32949 if (!SWIG_IsOK(res1)) {
32950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
32951 }
32952 arg1 = reinterpret_cast< wxWindow * >(argp1);
32953 {
32954 PyThreadState* __tstate = wxPyBeginAllowThreads();
32955 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
32956 wxPyEndAllowThreads(__tstate);
32957 if (PyErr_Occurred()) SWIG_fail;
32958 }
32959 {
32960 resultobj = wxPyMake_wxObject(result, 0);
32961 }
32962 return resultobj;
32963 fail:
32964 return NULL;
32965 }
32966
32967
32968 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32969 PyObject *resultobj = 0;
32970 wxWindow *arg1 = (wxWindow *) 0 ;
32971 wxWindow *result = 0 ;
32972 void *argp1 = 0 ;
32973 int res1 = 0 ;
32974 PyObject *swig_obj[1] ;
32975
32976 if (!args) SWIG_fail;
32977 swig_obj[0] = args;
32978 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32979 if (!SWIG_IsOK(res1)) {
32980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
32981 }
32982 arg1 = reinterpret_cast< wxWindow * >(argp1);
32983 {
32984 PyThreadState* __tstate = wxPyBeginAllowThreads();
32985 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
32986 wxPyEndAllowThreads(__tstate);
32987 if (PyErr_Occurred()) SWIG_fail;
32988 }
32989 {
32990 resultobj = wxPyMake_wxObject(result, 0);
32991 }
32992 return resultobj;
32993 fail:
32994 return NULL;
32995 }
32996
32997
32998 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32999 PyObject *resultobj = 0;
33000 wxWindow *arg1 = (wxWindow *) 0 ;
33001 bool result;
33002 void *argp1 = 0 ;
33003 int res1 = 0 ;
33004 PyObject *swig_obj[1] ;
33005
33006 if (!args) SWIG_fail;
33007 swig_obj[0] = args;
33008 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33009 if (!SWIG_IsOK(res1)) {
33010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
33011 }
33012 arg1 = reinterpret_cast< wxWindow * >(argp1);
33013 {
33014 PyThreadState* __tstate = wxPyBeginAllowThreads();
33015 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
33016 wxPyEndAllowThreads(__tstate);
33017 if (PyErr_Occurred()) SWIG_fail;
33018 }
33019 {
33020 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33021 }
33022 return resultobj;
33023 fail:
33024 return NULL;
33025 }
33026
33027
33028 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33029 PyObject *resultobj = 0;
33030 wxWindow *arg1 = (wxWindow *) 0 ;
33031 wxWindow *arg2 = (wxWindow *) 0 ;
33032 bool result;
33033 void *argp1 = 0 ;
33034 int res1 = 0 ;
33035 void *argp2 = 0 ;
33036 int res2 = 0 ;
33037 PyObject * obj0 = 0 ;
33038 PyObject * obj1 = 0 ;
33039 char * kwnames[] = {
33040 (char *) "self",(char *) "newParent", NULL
33041 };
33042
33043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
33044 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33045 if (!SWIG_IsOK(res1)) {
33046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
33047 }
33048 arg1 = reinterpret_cast< wxWindow * >(argp1);
33049 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33050 if (!SWIG_IsOK(res2)) {
33051 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
33052 }
33053 arg2 = reinterpret_cast< wxWindow * >(argp2);
33054 {
33055 PyThreadState* __tstate = wxPyBeginAllowThreads();
33056 result = (bool)(arg1)->Reparent(arg2);
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_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33070 PyObject *resultobj = 0;
33071 wxWindow *arg1 = (wxWindow *) 0 ;
33072 wxWindow *arg2 = (wxWindow *) 0 ;
33073 void *argp1 = 0 ;
33074 int res1 = 0 ;
33075 void *argp2 = 0 ;
33076 int res2 = 0 ;
33077 PyObject * obj0 = 0 ;
33078 PyObject * obj1 = 0 ;
33079 char * kwnames[] = {
33080 (char *) "self",(char *) "child", NULL
33081 };
33082
33083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
33084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33085 if (!SWIG_IsOK(res1)) {
33086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33087 }
33088 arg1 = reinterpret_cast< wxWindow * >(argp1);
33089 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33090 if (!SWIG_IsOK(res2)) {
33091 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33092 }
33093 arg2 = reinterpret_cast< wxWindow * >(argp2);
33094 {
33095 PyThreadState* __tstate = wxPyBeginAllowThreads();
33096 (arg1)->AddChild(arg2);
33097 wxPyEndAllowThreads(__tstate);
33098 if (PyErr_Occurred()) SWIG_fail;
33099 }
33100 resultobj = SWIG_Py_Void();
33101 return resultobj;
33102 fail:
33103 return NULL;
33104 }
33105
33106
33107 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33108 PyObject *resultobj = 0;
33109 wxWindow *arg1 = (wxWindow *) 0 ;
33110 wxWindow *arg2 = (wxWindow *) 0 ;
33111 void *argp1 = 0 ;
33112 int res1 = 0 ;
33113 void *argp2 = 0 ;
33114 int res2 = 0 ;
33115 PyObject * obj0 = 0 ;
33116 PyObject * obj1 = 0 ;
33117 char * kwnames[] = {
33118 (char *) "self",(char *) "child", NULL
33119 };
33120
33121 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
33122 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33123 if (!SWIG_IsOK(res1)) {
33124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33125 }
33126 arg1 = reinterpret_cast< wxWindow * >(argp1);
33127 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33128 if (!SWIG_IsOK(res2)) {
33129 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33130 }
33131 arg2 = reinterpret_cast< wxWindow * >(argp2);
33132 {
33133 PyThreadState* __tstate = wxPyBeginAllowThreads();
33134 (arg1)->RemoveChild(arg2);
33135 wxPyEndAllowThreads(__tstate);
33136 if (PyErr_Occurred()) SWIG_fail;
33137 }
33138 resultobj = SWIG_Py_Void();
33139 return resultobj;
33140 fail:
33141 return NULL;
33142 }
33143
33144
33145 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33146 PyObject *resultobj = 0;
33147 wxWindow *arg1 = (wxWindow *) 0 ;
33148 long arg2 ;
33149 wxWindow *result = 0 ;
33150 void *argp1 = 0 ;
33151 int res1 = 0 ;
33152 long val2 ;
33153 int ecode2 = 0 ;
33154 PyObject * obj0 = 0 ;
33155 PyObject * obj1 = 0 ;
33156 char * kwnames[] = {
33157 (char *) "self",(char *) "winid", NULL
33158 };
33159
33160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
33161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33162 if (!SWIG_IsOK(res1)) {
33163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
33164 }
33165 arg1 = reinterpret_cast< wxWindow * >(argp1);
33166 ecode2 = SWIG_AsVal_long(obj1, &val2);
33167 if (!SWIG_IsOK(ecode2)) {
33168 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
33169 }
33170 arg2 = static_cast< long >(val2);
33171 {
33172 PyThreadState* __tstate = wxPyBeginAllowThreads();
33173 result = (wxWindow *)(arg1)->FindWindow(arg2);
33174 wxPyEndAllowThreads(__tstate);
33175 if (PyErr_Occurred()) SWIG_fail;
33176 }
33177 {
33178 resultobj = wxPyMake_wxObject(result, 0);
33179 }
33180 return resultobj;
33181 fail:
33182 return NULL;
33183 }
33184
33185
33186 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33187 PyObject *resultobj = 0;
33188 wxWindow *arg1 = (wxWindow *) 0 ;
33189 wxString *arg2 = 0 ;
33190 wxWindow *result = 0 ;
33191 void *argp1 = 0 ;
33192 int res1 = 0 ;
33193 bool temp2 = false ;
33194 PyObject * obj0 = 0 ;
33195 PyObject * obj1 = 0 ;
33196 char * kwnames[] = {
33197 (char *) "self",(char *) "name", NULL
33198 };
33199
33200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
33201 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33202 if (!SWIG_IsOK(res1)) {
33203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
33204 }
33205 arg1 = reinterpret_cast< wxWindow * >(argp1);
33206 {
33207 arg2 = wxString_in_helper(obj1);
33208 if (arg2 == NULL) SWIG_fail;
33209 temp2 = true;
33210 }
33211 {
33212 PyThreadState* __tstate = wxPyBeginAllowThreads();
33213 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
33214 wxPyEndAllowThreads(__tstate);
33215 if (PyErr_Occurred()) SWIG_fail;
33216 }
33217 {
33218 resultobj = wxPyMake_wxObject(result, 0);
33219 }
33220 {
33221 if (temp2)
33222 delete arg2;
33223 }
33224 return resultobj;
33225 fail:
33226 {
33227 if (temp2)
33228 delete arg2;
33229 }
33230 return NULL;
33231 }
33232
33233
33234 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33235 PyObject *resultobj = 0;
33236 wxWindow *arg1 = (wxWindow *) 0 ;
33237 wxEvtHandler *result = 0 ;
33238 void *argp1 = 0 ;
33239 int res1 = 0 ;
33240 PyObject *swig_obj[1] ;
33241
33242 if (!args) SWIG_fail;
33243 swig_obj[0] = args;
33244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33245 if (!SWIG_IsOK(res1)) {
33246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
33247 }
33248 arg1 = reinterpret_cast< wxWindow * >(argp1);
33249 {
33250 PyThreadState* __tstate = wxPyBeginAllowThreads();
33251 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
33252 wxPyEndAllowThreads(__tstate);
33253 if (PyErr_Occurred()) SWIG_fail;
33254 }
33255 {
33256 resultobj = wxPyMake_wxObject(result, 0);
33257 }
33258 return resultobj;
33259 fail:
33260 return NULL;
33261 }
33262
33263
33264 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33265 PyObject *resultobj = 0;
33266 wxWindow *arg1 = (wxWindow *) 0 ;
33267 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33268 void *argp1 = 0 ;
33269 int res1 = 0 ;
33270 void *argp2 = 0 ;
33271 int res2 = 0 ;
33272 PyObject * obj0 = 0 ;
33273 PyObject * obj1 = 0 ;
33274 char * kwnames[] = {
33275 (char *) "self",(char *) "handler", NULL
33276 };
33277
33278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33279 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33280 if (!SWIG_IsOK(res1)) {
33281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33282 }
33283 arg1 = reinterpret_cast< wxWindow * >(argp1);
33284 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33285 if (!SWIG_IsOK(res2)) {
33286 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33287 }
33288 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33289 {
33290 PyThreadState* __tstate = wxPyBeginAllowThreads();
33291 (arg1)->SetEventHandler(arg2);
33292 wxPyEndAllowThreads(__tstate);
33293 if (PyErr_Occurred()) SWIG_fail;
33294 }
33295 resultobj = SWIG_Py_Void();
33296 return resultobj;
33297 fail:
33298 return NULL;
33299 }
33300
33301
33302 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33303 PyObject *resultobj = 0;
33304 wxWindow *arg1 = (wxWindow *) 0 ;
33305 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33306 void *argp1 = 0 ;
33307 int res1 = 0 ;
33308 void *argp2 = 0 ;
33309 int res2 = 0 ;
33310 PyObject * obj0 = 0 ;
33311 PyObject * obj1 = 0 ;
33312 char * kwnames[] = {
33313 (char *) "self",(char *) "handler", NULL
33314 };
33315
33316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33317 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33318 if (!SWIG_IsOK(res1)) {
33319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33320 }
33321 arg1 = reinterpret_cast< wxWindow * >(argp1);
33322 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33323 if (!SWIG_IsOK(res2)) {
33324 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33325 }
33326 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33327 {
33328 PyThreadState* __tstate = wxPyBeginAllowThreads();
33329 (arg1)->PushEventHandler(arg2);
33330 wxPyEndAllowThreads(__tstate);
33331 if (PyErr_Occurred()) SWIG_fail;
33332 }
33333 resultobj = SWIG_Py_Void();
33334 return resultobj;
33335 fail:
33336 return NULL;
33337 }
33338
33339
33340 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33341 PyObject *resultobj = 0;
33342 wxWindow *arg1 = (wxWindow *) 0 ;
33343 bool arg2 = (bool) false ;
33344 wxEvtHandler *result = 0 ;
33345 void *argp1 = 0 ;
33346 int res1 = 0 ;
33347 bool val2 ;
33348 int ecode2 = 0 ;
33349 PyObject * obj0 = 0 ;
33350 PyObject * obj1 = 0 ;
33351 char * kwnames[] = {
33352 (char *) "self",(char *) "deleteHandler", NULL
33353 };
33354
33355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33356 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33357 if (!SWIG_IsOK(res1)) {
33358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33359 }
33360 arg1 = reinterpret_cast< wxWindow * >(argp1);
33361 if (obj1) {
33362 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33363 if (!SWIG_IsOK(ecode2)) {
33364 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
33365 }
33366 arg2 = static_cast< bool >(val2);
33367 }
33368 {
33369 PyThreadState* __tstate = wxPyBeginAllowThreads();
33370 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
33371 wxPyEndAllowThreads(__tstate);
33372 if (PyErr_Occurred()) SWIG_fail;
33373 }
33374 {
33375 resultobj = wxPyMake_wxObject(result, 0);
33376 }
33377 return resultobj;
33378 fail:
33379 return NULL;
33380 }
33381
33382
33383 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33384 PyObject *resultobj = 0;
33385 wxWindow *arg1 = (wxWindow *) 0 ;
33386 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33387 bool result;
33388 void *argp1 = 0 ;
33389 int res1 = 0 ;
33390 void *argp2 = 0 ;
33391 int res2 = 0 ;
33392 PyObject * obj0 = 0 ;
33393 PyObject * obj1 = 0 ;
33394 char * kwnames[] = {
33395 (char *) "self",(char *) "handler", NULL
33396 };
33397
33398 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33399 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33400 if (!SWIG_IsOK(res1)) {
33401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33402 }
33403 arg1 = reinterpret_cast< wxWindow * >(argp1);
33404 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33405 if (!SWIG_IsOK(res2)) {
33406 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33407 }
33408 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33409 {
33410 PyThreadState* __tstate = wxPyBeginAllowThreads();
33411 result = (bool)(arg1)->RemoveEventHandler(arg2);
33412 wxPyEndAllowThreads(__tstate);
33413 if (PyErr_Occurred()) SWIG_fail;
33414 }
33415 {
33416 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33417 }
33418 return resultobj;
33419 fail:
33420 return NULL;
33421 }
33422
33423
33424 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33425 PyObject *resultobj = 0;
33426 wxWindow *arg1 = (wxWindow *) 0 ;
33427 wxValidator *arg2 = 0 ;
33428 void *argp1 = 0 ;
33429 int res1 = 0 ;
33430 void *argp2 = 0 ;
33431 int res2 = 0 ;
33432 PyObject * obj0 = 0 ;
33433 PyObject * obj1 = 0 ;
33434 char * kwnames[] = {
33435 (char *) "self",(char *) "validator", NULL
33436 };
33437
33438 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
33439 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33440 if (!SWIG_IsOK(res1)) {
33441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33442 }
33443 arg1 = reinterpret_cast< wxWindow * >(argp1);
33444 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
33445 if (!SWIG_IsOK(res2)) {
33446 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33447 }
33448 if (!argp2) {
33449 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33450 }
33451 arg2 = reinterpret_cast< wxValidator * >(argp2);
33452 {
33453 PyThreadState* __tstate = wxPyBeginAllowThreads();
33454 (arg1)->SetValidator((wxValidator const &)*arg2);
33455 wxPyEndAllowThreads(__tstate);
33456 if (PyErr_Occurred()) SWIG_fail;
33457 }
33458 resultobj = SWIG_Py_Void();
33459 return resultobj;
33460 fail:
33461 return NULL;
33462 }
33463
33464
33465 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33466 PyObject *resultobj = 0;
33467 wxWindow *arg1 = (wxWindow *) 0 ;
33468 wxValidator *result = 0 ;
33469 void *argp1 = 0 ;
33470 int res1 = 0 ;
33471 PyObject *swig_obj[1] ;
33472
33473 if (!args) SWIG_fail;
33474 swig_obj[0] = args;
33475 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33476 if (!SWIG_IsOK(res1)) {
33477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33478 }
33479 arg1 = reinterpret_cast< wxWindow * >(argp1);
33480 {
33481 PyThreadState* __tstate = wxPyBeginAllowThreads();
33482 result = (wxValidator *)(arg1)->GetValidator();
33483 wxPyEndAllowThreads(__tstate);
33484 if (PyErr_Occurred()) SWIG_fail;
33485 }
33486 {
33487 resultobj = wxPyMake_wxObject(result, (bool)0);
33488 }
33489 return resultobj;
33490 fail:
33491 return NULL;
33492 }
33493
33494
33495 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33496 PyObject *resultobj = 0;
33497 wxWindow *arg1 = (wxWindow *) 0 ;
33498 bool result;
33499 void *argp1 = 0 ;
33500 int res1 = 0 ;
33501 PyObject *swig_obj[1] ;
33502
33503 if (!args) SWIG_fail;
33504 swig_obj[0] = args;
33505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33506 if (!SWIG_IsOK(res1)) {
33507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
33508 }
33509 arg1 = reinterpret_cast< wxWindow * >(argp1);
33510 {
33511 PyThreadState* __tstate = wxPyBeginAllowThreads();
33512 result = (bool)(arg1)->Validate();
33513 wxPyEndAllowThreads(__tstate);
33514 if (PyErr_Occurred()) SWIG_fail;
33515 }
33516 {
33517 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33518 }
33519 return resultobj;
33520 fail:
33521 return NULL;
33522 }
33523
33524
33525 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33526 PyObject *resultobj = 0;
33527 wxWindow *arg1 = (wxWindow *) 0 ;
33528 bool result;
33529 void *argp1 = 0 ;
33530 int res1 = 0 ;
33531 PyObject *swig_obj[1] ;
33532
33533 if (!args) SWIG_fail;
33534 swig_obj[0] = args;
33535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33536 if (!SWIG_IsOK(res1)) {
33537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33538 }
33539 arg1 = reinterpret_cast< wxWindow * >(argp1);
33540 {
33541 PyThreadState* __tstate = wxPyBeginAllowThreads();
33542 result = (bool)(arg1)->TransferDataToWindow();
33543 wxPyEndAllowThreads(__tstate);
33544 if (PyErr_Occurred()) SWIG_fail;
33545 }
33546 {
33547 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33548 }
33549 return resultobj;
33550 fail:
33551 return NULL;
33552 }
33553
33554
33555 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33556 PyObject *resultobj = 0;
33557 wxWindow *arg1 = (wxWindow *) 0 ;
33558 bool result;
33559 void *argp1 = 0 ;
33560 int res1 = 0 ;
33561 PyObject *swig_obj[1] ;
33562
33563 if (!args) SWIG_fail;
33564 swig_obj[0] = args;
33565 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33566 if (!SWIG_IsOK(res1)) {
33567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33568 }
33569 arg1 = reinterpret_cast< wxWindow * >(argp1);
33570 {
33571 PyThreadState* __tstate = wxPyBeginAllowThreads();
33572 result = (bool)(arg1)->TransferDataFromWindow();
33573 wxPyEndAllowThreads(__tstate);
33574 if (PyErr_Occurred()) SWIG_fail;
33575 }
33576 {
33577 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33578 }
33579 return resultobj;
33580 fail:
33581 return NULL;
33582 }
33583
33584
33585 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33586 PyObject *resultobj = 0;
33587 wxWindow *arg1 = (wxWindow *) 0 ;
33588 void *argp1 = 0 ;
33589 int res1 = 0 ;
33590 PyObject *swig_obj[1] ;
33591
33592 if (!args) SWIG_fail;
33593 swig_obj[0] = args;
33594 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33595 if (!SWIG_IsOK(res1)) {
33596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
33597 }
33598 arg1 = reinterpret_cast< wxWindow * >(argp1);
33599 {
33600 PyThreadState* __tstate = wxPyBeginAllowThreads();
33601 (arg1)->InitDialog();
33602 wxPyEndAllowThreads(__tstate);
33603 if (PyErr_Occurred()) SWIG_fail;
33604 }
33605 resultobj = SWIG_Py_Void();
33606 return resultobj;
33607 fail:
33608 return NULL;
33609 }
33610
33611
33612 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33613 PyObject *resultobj = 0;
33614 wxWindow *arg1 = (wxWindow *) 0 ;
33615 wxAcceleratorTable *arg2 = 0 ;
33616 void *argp1 = 0 ;
33617 int res1 = 0 ;
33618 void *argp2 = 0 ;
33619 int res2 = 0 ;
33620 PyObject * obj0 = 0 ;
33621 PyObject * obj1 = 0 ;
33622 char * kwnames[] = {
33623 (char *) "self",(char *) "accel", NULL
33624 };
33625
33626 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
33627 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33628 if (!SWIG_IsOK(res1)) {
33629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33630 }
33631 arg1 = reinterpret_cast< wxWindow * >(argp1);
33632 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
33633 if (!SWIG_IsOK(res2)) {
33634 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33635 }
33636 if (!argp2) {
33637 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33638 }
33639 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
33640 {
33641 PyThreadState* __tstate = wxPyBeginAllowThreads();
33642 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
33643 wxPyEndAllowThreads(__tstate);
33644 if (PyErr_Occurred()) SWIG_fail;
33645 }
33646 resultobj = SWIG_Py_Void();
33647 return resultobj;
33648 fail:
33649 return NULL;
33650 }
33651
33652
33653 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33654 PyObject *resultobj = 0;
33655 wxWindow *arg1 = (wxWindow *) 0 ;
33656 wxAcceleratorTable *result = 0 ;
33657 void *argp1 = 0 ;
33658 int res1 = 0 ;
33659 PyObject *swig_obj[1] ;
33660
33661 if (!args) SWIG_fail;
33662 swig_obj[0] = args;
33663 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33664 if (!SWIG_IsOK(res1)) {
33665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33666 }
33667 arg1 = reinterpret_cast< wxWindow * >(argp1);
33668 {
33669 PyThreadState* __tstate = wxPyBeginAllowThreads();
33670 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
33671 wxPyEndAllowThreads(__tstate);
33672 if (PyErr_Occurred()) SWIG_fail;
33673 }
33674 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
33675 return resultobj;
33676 fail:
33677 return NULL;
33678 }
33679
33680
33681 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33682 PyObject *resultobj = 0;
33683 wxWindow *arg1 = (wxWindow *) 0 ;
33684 int arg2 ;
33685 int arg3 ;
33686 int arg4 ;
33687 bool result;
33688 void *argp1 = 0 ;
33689 int res1 = 0 ;
33690 int val2 ;
33691 int ecode2 = 0 ;
33692 int val3 ;
33693 int ecode3 = 0 ;
33694 int val4 ;
33695 int ecode4 = 0 ;
33696 PyObject * obj0 = 0 ;
33697 PyObject * obj1 = 0 ;
33698 PyObject * obj2 = 0 ;
33699 PyObject * obj3 = 0 ;
33700 char * kwnames[] = {
33701 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
33702 };
33703
33704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33705 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33706 if (!SWIG_IsOK(res1)) {
33707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
33708 }
33709 arg1 = reinterpret_cast< wxWindow * >(argp1);
33710 ecode2 = SWIG_AsVal_int(obj1, &val2);
33711 if (!SWIG_IsOK(ecode2)) {
33712 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
33713 }
33714 arg2 = static_cast< int >(val2);
33715 ecode3 = SWIG_AsVal_int(obj2, &val3);
33716 if (!SWIG_IsOK(ecode3)) {
33717 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
33718 }
33719 arg3 = static_cast< int >(val3);
33720 ecode4 = SWIG_AsVal_int(obj3, &val4);
33721 if (!SWIG_IsOK(ecode4)) {
33722 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
33723 }
33724 arg4 = static_cast< int >(val4);
33725 {
33726 PyThreadState* __tstate = wxPyBeginAllowThreads();
33727 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
33728 wxPyEndAllowThreads(__tstate);
33729 if (PyErr_Occurred()) SWIG_fail;
33730 }
33731 {
33732 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33733 }
33734 return resultobj;
33735 fail:
33736 return NULL;
33737 }
33738
33739
33740 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33741 PyObject *resultobj = 0;
33742 wxWindow *arg1 = (wxWindow *) 0 ;
33743 int arg2 ;
33744 bool result;
33745 void *argp1 = 0 ;
33746 int res1 = 0 ;
33747 int val2 ;
33748 int ecode2 = 0 ;
33749 PyObject * obj0 = 0 ;
33750 PyObject * obj1 = 0 ;
33751 char * kwnames[] = {
33752 (char *) "self",(char *) "hotkeyId", NULL
33753 };
33754
33755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
33756 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33757 if (!SWIG_IsOK(res1)) {
33758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
33759 }
33760 arg1 = reinterpret_cast< wxWindow * >(argp1);
33761 ecode2 = SWIG_AsVal_int(obj1, &val2);
33762 if (!SWIG_IsOK(ecode2)) {
33763 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
33764 }
33765 arg2 = static_cast< int >(val2);
33766 {
33767 PyThreadState* __tstate = wxPyBeginAllowThreads();
33768 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
33769 wxPyEndAllowThreads(__tstate);
33770 if (PyErr_Occurred()) SWIG_fail;
33771 }
33772 {
33773 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33774 }
33775 return resultobj;
33776 fail:
33777 return NULL;
33778 }
33779
33780
33781 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33782 PyObject *resultobj = 0;
33783 wxWindow *arg1 = (wxWindow *) 0 ;
33784 wxPoint *arg2 = 0 ;
33785 wxPoint result;
33786 void *argp1 = 0 ;
33787 int res1 = 0 ;
33788 wxPoint temp2 ;
33789 PyObject * obj0 = 0 ;
33790 PyObject * obj1 = 0 ;
33791 char * kwnames[] = {
33792 (char *) "self",(char *) "pt", NULL
33793 };
33794
33795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
33796 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33797 if (!SWIG_IsOK(res1)) {
33798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
33799 }
33800 arg1 = reinterpret_cast< wxWindow * >(argp1);
33801 {
33802 arg2 = &temp2;
33803 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33804 }
33805 {
33806 PyThreadState* __tstate = wxPyBeginAllowThreads();
33807 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
33808 wxPyEndAllowThreads(__tstate);
33809 if (PyErr_Occurred()) SWIG_fail;
33810 }
33811 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
33812 return resultobj;
33813 fail:
33814 return NULL;
33815 }
33816
33817
33818 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33819 PyObject *resultobj = 0;
33820 wxWindow *arg1 = (wxWindow *) 0 ;
33821 wxSize *arg2 = 0 ;
33822 wxSize result;
33823 void *argp1 = 0 ;
33824 int res1 = 0 ;
33825 wxSize temp2 ;
33826 PyObject * obj0 = 0 ;
33827 PyObject * obj1 = 0 ;
33828 char * kwnames[] = {
33829 (char *) "self",(char *) "sz", NULL
33830 };
33831
33832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
33833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33834 if (!SWIG_IsOK(res1)) {
33835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
33836 }
33837 arg1 = reinterpret_cast< wxWindow * >(argp1);
33838 {
33839 arg2 = &temp2;
33840 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33841 }
33842 {
33843 PyThreadState* __tstate = wxPyBeginAllowThreads();
33844 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
33845 wxPyEndAllowThreads(__tstate);
33846 if (PyErr_Occurred()) SWIG_fail;
33847 }
33848 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33849 return resultobj;
33850 fail:
33851 return NULL;
33852 }
33853
33854
33855 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33856 PyObject *resultobj = 0;
33857 wxWindow *arg1 = (wxWindow *) 0 ;
33858 wxPoint *arg2 = 0 ;
33859 wxPoint result;
33860 void *argp1 = 0 ;
33861 int res1 = 0 ;
33862 wxPoint temp2 ;
33863 PyObject * obj0 = 0 ;
33864 PyObject * obj1 = 0 ;
33865 char * kwnames[] = {
33866 (char *) "self",(char *) "pt", NULL
33867 };
33868
33869 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
33870 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33871 if (!SWIG_IsOK(res1)) {
33872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
33873 }
33874 arg1 = reinterpret_cast< wxWindow * >(argp1);
33875 {
33876 arg2 = &temp2;
33877 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33878 }
33879 {
33880 PyThreadState* __tstate = wxPyBeginAllowThreads();
33881 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
33882 wxPyEndAllowThreads(__tstate);
33883 if (PyErr_Occurred()) SWIG_fail;
33884 }
33885 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
33886 return resultobj;
33887 fail:
33888 return NULL;
33889 }
33890
33891
33892 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33893 PyObject *resultobj = 0;
33894 wxWindow *arg1 = (wxWindow *) 0 ;
33895 wxSize *arg2 = 0 ;
33896 wxSize result;
33897 void *argp1 = 0 ;
33898 int res1 = 0 ;
33899 wxSize temp2 ;
33900 PyObject * obj0 = 0 ;
33901 PyObject * obj1 = 0 ;
33902 char * kwnames[] = {
33903 (char *) "self",(char *) "sz", NULL
33904 };
33905
33906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
33907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33908 if (!SWIG_IsOK(res1)) {
33909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
33910 }
33911 arg1 = reinterpret_cast< wxWindow * >(argp1);
33912 {
33913 arg2 = &temp2;
33914 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33915 }
33916 {
33917 PyThreadState* __tstate = wxPyBeginAllowThreads();
33918 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
33919 wxPyEndAllowThreads(__tstate);
33920 if (PyErr_Occurred()) SWIG_fail;
33921 }
33922 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33923 return resultobj;
33924 fail:
33925 return NULL;
33926 }
33927
33928
33929 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33930 PyObject *resultobj = 0;
33931 wxWindow *arg1 = (wxWindow *) 0 ;
33932 wxPoint *arg2 = 0 ;
33933 wxPoint result;
33934 void *argp1 = 0 ;
33935 int res1 = 0 ;
33936 wxPoint temp2 ;
33937 PyObject * obj0 = 0 ;
33938 PyObject * obj1 = 0 ;
33939 char * kwnames[] = {
33940 (char *) "self",(char *) "pt", NULL
33941 };
33942
33943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
33944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33945 if (!SWIG_IsOK(res1)) {
33946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
33947 }
33948 arg1 = reinterpret_cast< wxWindow * >(argp1);
33949 {
33950 arg2 = &temp2;
33951 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33952 }
33953 {
33954 PyThreadState* __tstate = wxPyBeginAllowThreads();
33955 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
33956 wxPyEndAllowThreads(__tstate);
33957 if (PyErr_Occurred()) SWIG_fail;
33958 }
33959 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
33960 return resultobj;
33961 fail:
33962 return NULL;
33963 }
33964
33965
33966 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33967 PyObject *resultobj = 0;
33968 wxWindow *arg1 = (wxWindow *) 0 ;
33969 wxSize *arg2 = 0 ;
33970 wxSize result;
33971 void *argp1 = 0 ;
33972 int res1 = 0 ;
33973 wxSize temp2 ;
33974 PyObject * obj0 = 0 ;
33975 PyObject * obj1 = 0 ;
33976 char * kwnames[] = {
33977 (char *) "self",(char *) "sz", NULL
33978 };
33979
33980 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
33981 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33982 if (!SWIG_IsOK(res1)) {
33983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
33984 }
33985 arg1 = reinterpret_cast< wxWindow * >(argp1);
33986 {
33987 arg2 = &temp2;
33988 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33989 }
33990 {
33991 PyThreadState* __tstate = wxPyBeginAllowThreads();
33992 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
33993 wxPyEndAllowThreads(__tstate);
33994 if (PyErr_Occurred()) SWIG_fail;
33995 }
33996 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33997 return resultobj;
33998 fail:
33999 return NULL;
34000 }
34001
34002
34003 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34004 PyObject *resultobj = 0;
34005 wxWindow *arg1 = (wxWindow *) 0 ;
34006 int arg2 ;
34007 int arg3 ;
34008 void *argp1 = 0 ;
34009 int res1 = 0 ;
34010 int val2 ;
34011 int ecode2 = 0 ;
34012 int val3 ;
34013 int ecode3 = 0 ;
34014 PyObject * obj0 = 0 ;
34015 PyObject * obj1 = 0 ;
34016 PyObject * obj2 = 0 ;
34017 char * kwnames[] = {
34018 (char *) "self",(char *) "x",(char *) "y", NULL
34019 };
34020
34021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34022 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34023 if (!SWIG_IsOK(res1)) {
34024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
34025 }
34026 arg1 = reinterpret_cast< wxWindow * >(argp1);
34027 ecode2 = SWIG_AsVal_int(obj1, &val2);
34028 if (!SWIG_IsOK(ecode2)) {
34029 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
34030 }
34031 arg2 = static_cast< int >(val2);
34032 ecode3 = SWIG_AsVal_int(obj2, &val3);
34033 if (!SWIG_IsOK(ecode3)) {
34034 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
34035 }
34036 arg3 = static_cast< int >(val3);
34037 {
34038 PyThreadState* __tstate = wxPyBeginAllowThreads();
34039 (arg1)->WarpPointer(arg2,arg3);
34040 wxPyEndAllowThreads(__tstate);
34041 if (PyErr_Occurred()) SWIG_fail;
34042 }
34043 resultobj = SWIG_Py_Void();
34044 return resultobj;
34045 fail:
34046 return NULL;
34047 }
34048
34049
34050 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34051 PyObject *resultobj = 0;
34052 wxWindow *arg1 = (wxWindow *) 0 ;
34053 void *argp1 = 0 ;
34054 int res1 = 0 ;
34055 PyObject *swig_obj[1] ;
34056
34057 if (!args) SWIG_fail;
34058 swig_obj[0] = args;
34059 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34060 if (!SWIG_IsOK(res1)) {
34061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34062 }
34063 arg1 = reinterpret_cast< wxWindow * >(argp1);
34064 {
34065 PyThreadState* __tstate = wxPyBeginAllowThreads();
34066 (arg1)->CaptureMouse();
34067 wxPyEndAllowThreads(__tstate);
34068 if (PyErr_Occurred()) SWIG_fail;
34069 }
34070 resultobj = SWIG_Py_Void();
34071 return resultobj;
34072 fail:
34073 return NULL;
34074 }
34075
34076
34077 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34078 PyObject *resultobj = 0;
34079 wxWindow *arg1 = (wxWindow *) 0 ;
34080 void *argp1 = 0 ;
34081 int res1 = 0 ;
34082 PyObject *swig_obj[1] ;
34083
34084 if (!args) SWIG_fail;
34085 swig_obj[0] = args;
34086 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34087 if (!SWIG_IsOK(res1)) {
34088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34089 }
34090 arg1 = reinterpret_cast< wxWindow * >(argp1);
34091 {
34092 PyThreadState* __tstate = wxPyBeginAllowThreads();
34093 (arg1)->ReleaseMouse();
34094 wxPyEndAllowThreads(__tstate);
34095 if (PyErr_Occurred()) SWIG_fail;
34096 }
34097 resultobj = SWIG_Py_Void();
34098 return resultobj;
34099 fail:
34100 return NULL;
34101 }
34102
34103
34104 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34105 PyObject *resultobj = 0;
34106 wxWindow *result = 0 ;
34107
34108 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
34109 {
34110 if (!wxPyCheckForApp()) SWIG_fail;
34111 PyThreadState* __tstate = wxPyBeginAllowThreads();
34112 result = (wxWindow *)wxWindow::GetCapture();
34113 wxPyEndAllowThreads(__tstate);
34114 if (PyErr_Occurred()) SWIG_fail;
34115 }
34116 {
34117 resultobj = wxPyMake_wxObject(result, 0);
34118 }
34119 return resultobj;
34120 fail:
34121 return NULL;
34122 }
34123
34124
34125 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34126 PyObject *resultobj = 0;
34127 wxWindow *arg1 = (wxWindow *) 0 ;
34128 bool result;
34129 void *argp1 = 0 ;
34130 int res1 = 0 ;
34131 PyObject *swig_obj[1] ;
34132
34133 if (!args) SWIG_fail;
34134 swig_obj[0] = args;
34135 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34136 if (!SWIG_IsOK(res1)) {
34137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
34138 }
34139 arg1 = reinterpret_cast< wxWindow * >(argp1);
34140 {
34141 PyThreadState* __tstate = wxPyBeginAllowThreads();
34142 result = (bool)((wxWindow const *)arg1)->HasCapture();
34143 wxPyEndAllowThreads(__tstate);
34144 if (PyErr_Occurred()) SWIG_fail;
34145 }
34146 {
34147 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34148 }
34149 return resultobj;
34150 fail:
34151 return NULL;
34152 }
34153
34154
34155 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34156 PyObject *resultobj = 0;
34157 wxWindow *arg1 = (wxWindow *) 0 ;
34158 bool arg2 = (bool) true ;
34159 wxRect *arg3 = (wxRect *) NULL ;
34160 void *argp1 = 0 ;
34161 int res1 = 0 ;
34162 bool val2 ;
34163 int ecode2 = 0 ;
34164 void *argp3 = 0 ;
34165 int res3 = 0 ;
34166 PyObject * obj0 = 0 ;
34167 PyObject * obj1 = 0 ;
34168 PyObject * obj2 = 0 ;
34169 char * kwnames[] = {
34170 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
34171 };
34172
34173 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34174 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34175 if (!SWIG_IsOK(res1)) {
34176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
34177 }
34178 arg1 = reinterpret_cast< wxWindow * >(argp1);
34179 if (obj1) {
34180 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34181 if (!SWIG_IsOK(ecode2)) {
34182 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
34183 }
34184 arg2 = static_cast< bool >(val2);
34185 }
34186 if (obj2) {
34187 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
34188 if (!SWIG_IsOK(res3)) {
34189 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
34190 }
34191 arg3 = reinterpret_cast< wxRect * >(argp3);
34192 }
34193 {
34194 PyThreadState* __tstate = wxPyBeginAllowThreads();
34195 (arg1)->Refresh(arg2,(wxRect const *)arg3);
34196 wxPyEndAllowThreads(__tstate);
34197 if (PyErr_Occurred()) SWIG_fail;
34198 }
34199 resultobj = SWIG_Py_Void();
34200 return resultobj;
34201 fail:
34202 return NULL;
34203 }
34204
34205
34206 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34207 PyObject *resultobj = 0;
34208 wxWindow *arg1 = (wxWindow *) 0 ;
34209 wxRect *arg2 = 0 ;
34210 bool arg3 = (bool) true ;
34211 void *argp1 = 0 ;
34212 int res1 = 0 ;
34213 wxRect temp2 ;
34214 bool val3 ;
34215 int ecode3 = 0 ;
34216 PyObject * obj0 = 0 ;
34217 PyObject * obj1 = 0 ;
34218 PyObject * obj2 = 0 ;
34219 char * kwnames[] = {
34220 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
34221 };
34222
34223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34225 if (!SWIG_IsOK(res1)) {
34226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34227 }
34228 arg1 = reinterpret_cast< wxWindow * >(argp1);
34229 {
34230 arg2 = &temp2;
34231 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34232 }
34233 if (obj2) {
34234 ecode3 = SWIG_AsVal_bool(obj2, &val3);
34235 if (!SWIG_IsOK(ecode3)) {
34236 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
34237 }
34238 arg3 = static_cast< bool >(val3);
34239 }
34240 {
34241 PyThreadState* __tstate = wxPyBeginAllowThreads();
34242 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
34243 wxPyEndAllowThreads(__tstate);
34244 if (PyErr_Occurred()) SWIG_fail;
34245 }
34246 resultobj = SWIG_Py_Void();
34247 return resultobj;
34248 fail:
34249 return NULL;
34250 }
34251
34252
34253 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34254 PyObject *resultobj = 0;
34255 wxWindow *arg1 = (wxWindow *) 0 ;
34256 void *argp1 = 0 ;
34257 int res1 = 0 ;
34258 PyObject *swig_obj[1] ;
34259
34260 if (!args) SWIG_fail;
34261 swig_obj[0] = args;
34262 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34263 if (!SWIG_IsOK(res1)) {
34264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
34265 }
34266 arg1 = reinterpret_cast< wxWindow * >(argp1);
34267 {
34268 PyThreadState* __tstate = wxPyBeginAllowThreads();
34269 (arg1)->Update();
34270 wxPyEndAllowThreads(__tstate);
34271 if (PyErr_Occurred()) SWIG_fail;
34272 }
34273 resultobj = SWIG_Py_Void();
34274 return resultobj;
34275 fail:
34276 return NULL;
34277 }
34278
34279
34280 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34281 PyObject *resultobj = 0;
34282 wxWindow *arg1 = (wxWindow *) 0 ;
34283 void *argp1 = 0 ;
34284 int res1 = 0 ;
34285 PyObject *swig_obj[1] ;
34286
34287 if (!args) SWIG_fail;
34288 swig_obj[0] = args;
34289 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34290 if (!SWIG_IsOK(res1)) {
34291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
34292 }
34293 arg1 = reinterpret_cast< wxWindow * >(argp1);
34294 {
34295 PyThreadState* __tstate = wxPyBeginAllowThreads();
34296 (arg1)->ClearBackground();
34297 wxPyEndAllowThreads(__tstate);
34298 if (PyErr_Occurred()) SWIG_fail;
34299 }
34300 resultobj = SWIG_Py_Void();
34301 return resultobj;
34302 fail:
34303 return NULL;
34304 }
34305
34306
34307 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34308 PyObject *resultobj = 0;
34309 wxWindow *arg1 = (wxWindow *) 0 ;
34310 void *argp1 = 0 ;
34311 int res1 = 0 ;
34312 PyObject *swig_obj[1] ;
34313
34314 if (!args) SWIG_fail;
34315 swig_obj[0] = args;
34316 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34317 if (!SWIG_IsOK(res1)) {
34318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
34319 }
34320 arg1 = reinterpret_cast< wxWindow * >(argp1);
34321 {
34322 PyThreadState* __tstate = wxPyBeginAllowThreads();
34323 (arg1)->Freeze();
34324 wxPyEndAllowThreads(__tstate);
34325 if (PyErr_Occurred()) SWIG_fail;
34326 }
34327 resultobj = SWIG_Py_Void();
34328 return resultobj;
34329 fail:
34330 return NULL;
34331 }
34332
34333
34334 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34335 PyObject *resultobj = 0;
34336 wxWindow *arg1 = (wxWindow *) 0 ;
34337 void *argp1 = 0 ;
34338 int res1 = 0 ;
34339 PyObject *swig_obj[1] ;
34340
34341 if (!args) SWIG_fail;
34342 swig_obj[0] = args;
34343 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34344 if (!SWIG_IsOK(res1)) {
34345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
34346 }
34347 arg1 = reinterpret_cast< wxWindow * >(argp1);
34348 {
34349 PyThreadState* __tstate = wxPyBeginAllowThreads();
34350 (arg1)->Thaw();
34351 wxPyEndAllowThreads(__tstate);
34352 if (PyErr_Occurred()) SWIG_fail;
34353 }
34354 resultobj = SWIG_Py_Void();
34355 return resultobj;
34356 fail:
34357 return NULL;
34358 }
34359
34360
34361 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34362 PyObject *resultobj = 0;
34363 wxWindow *arg1 = (wxWindow *) 0 ;
34364 wxDC *arg2 = 0 ;
34365 void *argp1 = 0 ;
34366 int res1 = 0 ;
34367 void *argp2 = 0 ;
34368 int res2 = 0 ;
34369 PyObject * obj0 = 0 ;
34370 PyObject * obj1 = 0 ;
34371 char * kwnames[] = {
34372 (char *) "self",(char *) "dc", NULL
34373 };
34374
34375 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
34376 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34377 if (!SWIG_IsOK(res1)) {
34378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
34379 }
34380 arg1 = reinterpret_cast< wxWindow * >(argp1);
34381 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
34382 if (!SWIG_IsOK(res2)) {
34383 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34384 }
34385 if (!argp2) {
34386 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34387 }
34388 arg2 = reinterpret_cast< wxDC * >(argp2);
34389 {
34390 PyThreadState* __tstate = wxPyBeginAllowThreads();
34391 (arg1)->PrepareDC(*arg2);
34392 wxPyEndAllowThreads(__tstate);
34393 if (PyErr_Occurred()) SWIG_fail;
34394 }
34395 resultobj = SWIG_Py_Void();
34396 return resultobj;
34397 fail:
34398 return NULL;
34399 }
34400
34401
34402 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34403 PyObject *resultobj = 0;
34404 wxWindow *arg1 = (wxWindow *) 0 ;
34405 wxRegion *result = 0 ;
34406 void *argp1 = 0 ;
34407 int res1 = 0 ;
34408 PyObject *swig_obj[1] ;
34409
34410 if (!args) SWIG_fail;
34411 swig_obj[0] = args;
34412 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34413 if (!SWIG_IsOK(res1)) {
34414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
34415 }
34416 arg1 = reinterpret_cast< wxWindow * >(argp1);
34417 {
34418 PyThreadState* __tstate = wxPyBeginAllowThreads();
34419 {
34420 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
34421 result = (wxRegion *) &_result_ref;
34422 }
34423 wxPyEndAllowThreads(__tstate);
34424 if (PyErr_Occurred()) SWIG_fail;
34425 }
34426 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
34427 return resultobj;
34428 fail:
34429 return NULL;
34430 }
34431
34432
34433 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34434 PyObject *resultobj = 0;
34435 wxWindow *arg1 = (wxWindow *) 0 ;
34436 wxRect result;
34437 void *argp1 = 0 ;
34438 int res1 = 0 ;
34439 PyObject *swig_obj[1] ;
34440
34441 if (!args) SWIG_fail;
34442 swig_obj[0] = args;
34443 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34444 if (!SWIG_IsOK(res1)) {
34445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34446 }
34447 arg1 = reinterpret_cast< wxWindow * >(argp1);
34448 {
34449 PyThreadState* __tstate = wxPyBeginAllowThreads();
34450 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
34451 wxPyEndAllowThreads(__tstate);
34452 if (PyErr_Occurred()) SWIG_fail;
34453 }
34454 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34455 return resultobj;
34456 fail:
34457 return NULL;
34458 }
34459
34460
34461 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34462 PyObject *resultobj = 0;
34463 wxWindow *arg1 = (wxWindow *) 0 ;
34464 int arg2 ;
34465 int arg3 ;
34466 int arg4 = (int) 1 ;
34467 int arg5 = (int) 1 ;
34468 bool result;
34469 void *argp1 = 0 ;
34470 int res1 = 0 ;
34471 int val2 ;
34472 int ecode2 = 0 ;
34473 int val3 ;
34474 int ecode3 = 0 ;
34475 int val4 ;
34476 int ecode4 = 0 ;
34477 int val5 ;
34478 int ecode5 = 0 ;
34479 PyObject * obj0 = 0 ;
34480 PyObject * obj1 = 0 ;
34481 PyObject * obj2 = 0 ;
34482 PyObject * obj3 = 0 ;
34483 PyObject * obj4 = 0 ;
34484 char * kwnames[] = {
34485 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
34486 };
34487
34488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
34489 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34490 if (!SWIG_IsOK(res1)) {
34491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
34492 }
34493 arg1 = reinterpret_cast< wxWindow * >(argp1);
34494 ecode2 = SWIG_AsVal_int(obj1, &val2);
34495 if (!SWIG_IsOK(ecode2)) {
34496 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
34497 }
34498 arg2 = static_cast< int >(val2);
34499 ecode3 = SWIG_AsVal_int(obj2, &val3);
34500 if (!SWIG_IsOK(ecode3)) {
34501 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
34502 }
34503 arg3 = static_cast< int >(val3);
34504 if (obj3) {
34505 ecode4 = SWIG_AsVal_int(obj3, &val4);
34506 if (!SWIG_IsOK(ecode4)) {
34507 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
34508 }
34509 arg4 = static_cast< int >(val4);
34510 }
34511 if (obj4) {
34512 ecode5 = SWIG_AsVal_int(obj4, &val5);
34513 if (!SWIG_IsOK(ecode5)) {
34514 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
34515 }
34516 arg5 = static_cast< int >(val5);
34517 }
34518 {
34519 PyThreadState* __tstate = wxPyBeginAllowThreads();
34520 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
34521 wxPyEndAllowThreads(__tstate);
34522 if (PyErr_Occurred()) SWIG_fail;
34523 }
34524 {
34525 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34526 }
34527 return resultobj;
34528 fail:
34529 return NULL;
34530 }
34531
34532
34533 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34534 PyObject *resultobj = 0;
34535 wxWindow *arg1 = (wxWindow *) 0 ;
34536 wxPoint *arg2 = 0 ;
34537 bool result;
34538 void *argp1 = 0 ;
34539 int res1 = 0 ;
34540 wxPoint temp2 ;
34541 PyObject * obj0 = 0 ;
34542 PyObject * obj1 = 0 ;
34543 char * kwnames[] = {
34544 (char *) "self",(char *) "pt", NULL
34545 };
34546
34547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
34548 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34549 if (!SWIG_IsOK(res1)) {
34550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
34551 }
34552 arg1 = reinterpret_cast< wxWindow * >(argp1);
34553 {
34554 arg2 = &temp2;
34555 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34556 }
34557 {
34558 PyThreadState* __tstate = wxPyBeginAllowThreads();
34559 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
34560 wxPyEndAllowThreads(__tstate);
34561 if (PyErr_Occurred()) SWIG_fail;
34562 }
34563 {
34564 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34565 }
34566 return resultobj;
34567 fail:
34568 return NULL;
34569 }
34570
34571
34572 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34573 PyObject *resultobj = 0;
34574 wxWindow *arg1 = (wxWindow *) 0 ;
34575 wxRect *arg2 = 0 ;
34576 bool result;
34577 void *argp1 = 0 ;
34578 int res1 = 0 ;
34579 wxRect temp2 ;
34580 PyObject * obj0 = 0 ;
34581 PyObject * obj1 = 0 ;
34582 char * kwnames[] = {
34583 (char *) "self",(char *) "rect", NULL
34584 };
34585
34586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
34587 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34588 if (!SWIG_IsOK(res1)) {
34589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34590 }
34591 arg1 = reinterpret_cast< wxWindow * >(argp1);
34592 {
34593 arg2 = &temp2;
34594 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34595 }
34596 {
34597 PyThreadState* __tstate = wxPyBeginAllowThreads();
34598 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
34599 wxPyEndAllowThreads(__tstate);
34600 if (PyErr_Occurred()) SWIG_fail;
34601 }
34602 {
34603 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34604 }
34605 return resultobj;
34606 fail:
34607 return NULL;
34608 }
34609
34610
34611 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34612 PyObject *resultobj = 0;
34613 wxWindow *arg1 = (wxWindow *) 0 ;
34614 SwigValueWrapper<wxVisualAttributes > result;
34615 void *argp1 = 0 ;
34616 int res1 = 0 ;
34617 PyObject *swig_obj[1] ;
34618
34619 if (!args) SWIG_fail;
34620 swig_obj[0] = args;
34621 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34622 if (!SWIG_IsOK(res1)) {
34623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
34624 }
34625 arg1 = reinterpret_cast< wxWindow * >(argp1);
34626 {
34627 PyThreadState* __tstate = wxPyBeginAllowThreads();
34628 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
34629 wxPyEndAllowThreads(__tstate);
34630 if (PyErr_Occurred()) SWIG_fail;
34631 }
34632 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34633 return resultobj;
34634 fail:
34635 return NULL;
34636 }
34637
34638
34639 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34640 PyObject *resultobj = 0;
34641 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
34642 SwigValueWrapper<wxVisualAttributes > result;
34643 int val1 ;
34644 int ecode1 = 0 ;
34645 PyObject * obj0 = 0 ;
34646 char * kwnames[] = {
34647 (char *) "variant", NULL
34648 };
34649
34650 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
34651 if (obj0) {
34652 ecode1 = SWIG_AsVal_int(obj0, &val1);
34653 if (!SWIG_IsOK(ecode1)) {
34654 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
34655 }
34656 arg1 = static_cast< wxWindowVariant >(val1);
34657 }
34658 {
34659 if (!wxPyCheckForApp()) SWIG_fail;
34660 PyThreadState* __tstate = wxPyBeginAllowThreads();
34661 result = wxWindow::GetClassDefaultAttributes(arg1);
34662 wxPyEndAllowThreads(__tstate);
34663 if (PyErr_Occurred()) SWIG_fail;
34664 }
34665 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34666 return resultobj;
34667 fail:
34668 return NULL;
34669 }
34670
34671
34672 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34673 PyObject *resultobj = 0;
34674 wxWindow *arg1 = (wxWindow *) 0 ;
34675 wxColour *arg2 = 0 ;
34676 bool result;
34677 void *argp1 = 0 ;
34678 int res1 = 0 ;
34679 wxColour temp2 ;
34680 PyObject * obj0 = 0 ;
34681 PyObject * obj1 = 0 ;
34682 char * kwnames[] = {
34683 (char *) "self",(char *) "colour", NULL
34684 };
34685
34686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34687 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34688 if (!SWIG_IsOK(res1)) {
34689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34690 }
34691 arg1 = reinterpret_cast< wxWindow * >(argp1);
34692 {
34693 arg2 = &temp2;
34694 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34695 }
34696 {
34697 PyThreadState* __tstate = wxPyBeginAllowThreads();
34698 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
34699 wxPyEndAllowThreads(__tstate);
34700 if (PyErr_Occurred()) SWIG_fail;
34701 }
34702 {
34703 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34704 }
34705 return resultobj;
34706 fail:
34707 return NULL;
34708 }
34709
34710
34711 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34712 PyObject *resultobj = 0;
34713 wxWindow *arg1 = (wxWindow *) 0 ;
34714 wxColour *arg2 = 0 ;
34715 void *argp1 = 0 ;
34716 int res1 = 0 ;
34717 wxColour temp2 ;
34718 PyObject * obj0 = 0 ;
34719 PyObject * obj1 = 0 ;
34720 char * kwnames[] = {
34721 (char *) "self",(char *) "colour", NULL
34722 };
34723
34724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34726 if (!SWIG_IsOK(res1)) {
34727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34728 }
34729 arg1 = reinterpret_cast< wxWindow * >(argp1);
34730 {
34731 arg2 = &temp2;
34732 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34733 }
34734 {
34735 PyThreadState* __tstate = wxPyBeginAllowThreads();
34736 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
34737 wxPyEndAllowThreads(__tstate);
34738 if (PyErr_Occurred()) SWIG_fail;
34739 }
34740 resultobj = SWIG_Py_Void();
34741 return resultobj;
34742 fail:
34743 return NULL;
34744 }
34745
34746
34747 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34748 PyObject *resultobj = 0;
34749 wxWindow *arg1 = (wxWindow *) 0 ;
34750 wxColour *arg2 = 0 ;
34751 bool result;
34752 void *argp1 = 0 ;
34753 int res1 = 0 ;
34754 wxColour temp2 ;
34755 PyObject * obj0 = 0 ;
34756 PyObject * obj1 = 0 ;
34757 char * kwnames[] = {
34758 (char *) "self",(char *) "colour", NULL
34759 };
34760
34761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34762 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34763 if (!SWIG_IsOK(res1)) {
34764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34765 }
34766 arg1 = reinterpret_cast< wxWindow * >(argp1);
34767 {
34768 arg2 = &temp2;
34769 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34770 }
34771 {
34772 PyThreadState* __tstate = wxPyBeginAllowThreads();
34773 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
34774 wxPyEndAllowThreads(__tstate);
34775 if (PyErr_Occurred()) SWIG_fail;
34776 }
34777 {
34778 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34779 }
34780 return resultobj;
34781 fail:
34782 return NULL;
34783 }
34784
34785
34786 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34787 PyObject *resultobj = 0;
34788 wxWindow *arg1 = (wxWindow *) 0 ;
34789 wxColour *arg2 = 0 ;
34790 void *argp1 = 0 ;
34791 int res1 = 0 ;
34792 wxColour temp2 ;
34793 PyObject * obj0 = 0 ;
34794 PyObject * obj1 = 0 ;
34795 char * kwnames[] = {
34796 (char *) "self",(char *) "colour", NULL
34797 };
34798
34799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34800 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34801 if (!SWIG_IsOK(res1)) {
34802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34803 }
34804 arg1 = reinterpret_cast< wxWindow * >(argp1);
34805 {
34806 arg2 = &temp2;
34807 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34808 }
34809 {
34810 PyThreadState* __tstate = wxPyBeginAllowThreads();
34811 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
34812 wxPyEndAllowThreads(__tstate);
34813 if (PyErr_Occurred()) SWIG_fail;
34814 }
34815 resultobj = SWIG_Py_Void();
34816 return resultobj;
34817 fail:
34818 return NULL;
34819 }
34820
34821
34822 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34823 PyObject *resultobj = 0;
34824 wxWindow *arg1 = (wxWindow *) 0 ;
34825 wxColour result;
34826 void *argp1 = 0 ;
34827 int res1 = 0 ;
34828 PyObject *swig_obj[1] ;
34829
34830 if (!args) SWIG_fail;
34831 swig_obj[0] = args;
34832 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34833 if (!SWIG_IsOK(res1)) {
34834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
34835 }
34836 arg1 = reinterpret_cast< wxWindow * >(argp1);
34837 {
34838 PyThreadState* __tstate = wxPyBeginAllowThreads();
34839 result = ((wxWindow const *)arg1)->GetBackgroundColour();
34840 wxPyEndAllowThreads(__tstate);
34841 if (PyErr_Occurred()) SWIG_fail;
34842 }
34843 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
34844 return resultobj;
34845 fail:
34846 return NULL;
34847 }
34848
34849
34850 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34851 PyObject *resultobj = 0;
34852 wxWindow *arg1 = (wxWindow *) 0 ;
34853 wxColour result;
34854 void *argp1 = 0 ;
34855 int res1 = 0 ;
34856 PyObject *swig_obj[1] ;
34857
34858 if (!args) SWIG_fail;
34859 swig_obj[0] = args;
34860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34861 if (!SWIG_IsOK(res1)) {
34862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
34863 }
34864 arg1 = reinterpret_cast< wxWindow * >(argp1);
34865 {
34866 PyThreadState* __tstate = wxPyBeginAllowThreads();
34867 result = ((wxWindow const *)arg1)->GetForegroundColour();
34868 wxPyEndAllowThreads(__tstate);
34869 if (PyErr_Occurred()) SWIG_fail;
34870 }
34871 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
34872 return resultobj;
34873 fail:
34874 return NULL;
34875 }
34876
34877
34878 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34879 PyObject *resultobj = 0;
34880 wxWindow *arg1 = (wxWindow *) 0 ;
34881 bool result;
34882 void *argp1 = 0 ;
34883 int res1 = 0 ;
34884 PyObject *swig_obj[1] ;
34885
34886 if (!args) SWIG_fail;
34887 swig_obj[0] = args;
34888 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34889 if (!SWIG_IsOK(res1)) {
34890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
34891 }
34892 arg1 = reinterpret_cast< wxWindow * >(argp1);
34893 {
34894 PyThreadState* __tstate = wxPyBeginAllowThreads();
34895 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
34896 wxPyEndAllowThreads(__tstate);
34897 if (PyErr_Occurred()) SWIG_fail;
34898 }
34899 {
34900 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34901 }
34902 return resultobj;
34903 fail:
34904 return NULL;
34905 }
34906
34907
34908 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34909 PyObject *resultobj = 0;
34910 wxWindow *arg1 = (wxWindow *) 0 ;
34911 bool result;
34912 void *argp1 = 0 ;
34913 int res1 = 0 ;
34914 PyObject *swig_obj[1] ;
34915
34916 if (!args) SWIG_fail;
34917 swig_obj[0] = args;
34918 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34919 if (!SWIG_IsOK(res1)) {
34920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
34921 }
34922 arg1 = reinterpret_cast< wxWindow * >(argp1);
34923 {
34924 PyThreadState* __tstate = wxPyBeginAllowThreads();
34925 result = (bool)((wxWindow const *)arg1)->UseBgCol();
34926 wxPyEndAllowThreads(__tstate);
34927 if (PyErr_Occurred()) SWIG_fail;
34928 }
34929 {
34930 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34931 }
34932 return resultobj;
34933 fail:
34934 return NULL;
34935 }
34936
34937
34938 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34939 PyObject *resultobj = 0;
34940 wxWindow *arg1 = (wxWindow *) 0 ;
34941 wxBackgroundStyle arg2 ;
34942 bool result;
34943 void *argp1 = 0 ;
34944 int res1 = 0 ;
34945 int val2 ;
34946 int ecode2 = 0 ;
34947 PyObject * obj0 = 0 ;
34948 PyObject * obj1 = 0 ;
34949 char * kwnames[] = {
34950 (char *) "self",(char *) "style", NULL
34951 };
34952
34953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
34954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34955 if (!SWIG_IsOK(res1)) {
34956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
34957 }
34958 arg1 = reinterpret_cast< wxWindow * >(argp1);
34959 ecode2 = SWIG_AsVal_int(obj1, &val2);
34960 if (!SWIG_IsOK(ecode2)) {
34961 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
34962 }
34963 arg2 = static_cast< wxBackgroundStyle >(val2);
34964 {
34965 PyThreadState* __tstate = wxPyBeginAllowThreads();
34966 result = (bool)(arg1)->SetBackgroundStyle(arg2);
34967 wxPyEndAllowThreads(__tstate);
34968 if (PyErr_Occurred()) SWIG_fail;
34969 }
34970 {
34971 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34972 }
34973 return resultobj;
34974 fail:
34975 return NULL;
34976 }
34977
34978
34979 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34980 PyObject *resultobj = 0;
34981 wxWindow *arg1 = (wxWindow *) 0 ;
34982 wxBackgroundStyle result;
34983 void *argp1 = 0 ;
34984 int res1 = 0 ;
34985 PyObject *swig_obj[1] ;
34986
34987 if (!args) SWIG_fail;
34988 swig_obj[0] = args;
34989 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34990 if (!SWIG_IsOK(res1)) {
34991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
34992 }
34993 arg1 = reinterpret_cast< wxWindow * >(argp1);
34994 {
34995 PyThreadState* __tstate = wxPyBeginAllowThreads();
34996 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
34997 wxPyEndAllowThreads(__tstate);
34998 if (PyErr_Occurred()) SWIG_fail;
34999 }
35000 resultobj = SWIG_From_int(static_cast< int >(result));
35001 return resultobj;
35002 fail:
35003 return NULL;
35004 }
35005
35006
35007 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35008 PyObject *resultobj = 0;
35009 wxWindow *arg1 = (wxWindow *) 0 ;
35010 bool result;
35011 void *argp1 = 0 ;
35012 int res1 = 0 ;
35013 PyObject *swig_obj[1] ;
35014
35015 if (!args) SWIG_fail;
35016 swig_obj[0] = args;
35017 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35018 if (!SWIG_IsOK(res1)) {
35019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
35020 }
35021 arg1 = reinterpret_cast< wxWindow * >(argp1);
35022 {
35023 PyThreadState* __tstate = wxPyBeginAllowThreads();
35024 result = (bool)(arg1)->HasTransparentBackground();
35025 wxPyEndAllowThreads(__tstate);
35026 if (PyErr_Occurred()) SWIG_fail;
35027 }
35028 {
35029 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35030 }
35031 return resultobj;
35032 fail:
35033 return NULL;
35034 }
35035
35036
35037 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35038 PyObject *resultobj = 0;
35039 wxWindow *arg1 = (wxWindow *) 0 ;
35040 wxCursor *arg2 = 0 ;
35041 bool result;
35042 void *argp1 = 0 ;
35043 int res1 = 0 ;
35044 void *argp2 = 0 ;
35045 int res2 = 0 ;
35046 PyObject * obj0 = 0 ;
35047 PyObject * obj1 = 0 ;
35048 char * kwnames[] = {
35049 (char *) "self",(char *) "cursor", NULL
35050 };
35051
35052 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
35053 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35054 if (!SWIG_IsOK(res1)) {
35055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35056 }
35057 arg1 = reinterpret_cast< wxWindow * >(argp1);
35058 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
35059 if (!SWIG_IsOK(res2)) {
35060 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35061 }
35062 if (!argp2) {
35063 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35064 }
35065 arg2 = reinterpret_cast< wxCursor * >(argp2);
35066 {
35067 PyThreadState* __tstate = wxPyBeginAllowThreads();
35068 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
35069 wxPyEndAllowThreads(__tstate);
35070 if (PyErr_Occurred()) SWIG_fail;
35071 }
35072 {
35073 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35074 }
35075 return resultobj;
35076 fail:
35077 return NULL;
35078 }
35079
35080
35081 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35082 PyObject *resultobj = 0;
35083 wxWindow *arg1 = (wxWindow *) 0 ;
35084 wxCursor result;
35085 void *argp1 = 0 ;
35086 int res1 = 0 ;
35087 PyObject *swig_obj[1] ;
35088
35089 if (!args) SWIG_fail;
35090 swig_obj[0] = args;
35091 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35092 if (!SWIG_IsOK(res1)) {
35093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35094 }
35095 arg1 = reinterpret_cast< wxWindow * >(argp1);
35096 {
35097 PyThreadState* __tstate = wxPyBeginAllowThreads();
35098 result = (arg1)->GetCursor();
35099 wxPyEndAllowThreads(__tstate);
35100 if (PyErr_Occurred()) SWIG_fail;
35101 }
35102 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
35103 return resultobj;
35104 fail:
35105 return NULL;
35106 }
35107
35108
35109 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35110 PyObject *resultobj = 0;
35111 wxWindow *arg1 = (wxWindow *) 0 ;
35112 wxFont *arg2 = 0 ;
35113 bool result;
35114 void *argp1 = 0 ;
35115 int res1 = 0 ;
35116 void *argp2 = 0 ;
35117 int res2 = 0 ;
35118 PyObject * obj0 = 0 ;
35119 PyObject * obj1 = 0 ;
35120 char * kwnames[] = {
35121 (char *) "self",(char *) "font", NULL
35122 };
35123
35124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
35125 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35126 if (!SWIG_IsOK(res1)) {
35127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35128 }
35129 arg1 = reinterpret_cast< wxWindow * >(argp1);
35130 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35131 if (!SWIG_IsOK(res2)) {
35132 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35133 }
35134 if (!argp2) {
35135 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35136 }
35137 arg2 = reinterpret_cast< wxFont * >(argp2);
35138 {
35139 PyThreadState* __tstate = wxPyBeginAllowThreads();
35140 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
35141 wxPyEndAllowThreads(__tstate);
35142 if (PyErr_Occurred()) SWIG_fail;
35143 }
35144 {
35145 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35146 }
35147 return resultobj;
35148 fail:
35149 return NULL;
35150 }
35151
35152
35153 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35154 PyObject *resultobj = 0;
35155 wxWindow *arg1 = (wxWindow *) 0 ;
35156 wxFont *arg2 = 0 ;
35157 void *argp1 = 0 ;
35158 int res1 = 0 ;
35159 void *argp2 = 0 ;
35160 int res2 = 0 ;
35161 PyObject * obj0 = 0 ;
35162 PyObject * obj1 = 0 ;
35163 char * kwnames[] = {
35164 (char *) "self",(char *) "font", NULL
35165 };
35166
35167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
35168 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35169 if (!SWIG_IsOK(res1)) {
35170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35171 }
35172 arg1 = reinterpret_cast< wxWindow * >(argp1);
35173 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35174 if (!SWIG_IsOK(res2)) {
35175 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35176 }
35177 if (!argp2) {
35178 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35179 }
35180 arg2 = reinterpret_cast< wxFont * >(argp2);
35181 {
35182 PyThreadState* __tstate = wxPyBeginAllowThreads();
35183 (arg1)->SetOwnFont((wxFont const &)*arg2);
35184 wxPyEndAllowThreads(__tstate);
35185 if (PyErr_Occurred()) SWIG_fail;
35186 }
35187 resultobj = SWIG_Py_Void();
35188 return resultobj;
35189 fail:
35190 return NULL;
35191 }
35192
35193
35194 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35195 PyObject *resultobj = 0;
35196 wxWindow *arg1 = (wxWindow *) 0 ;
35197 wxFont result;
35198 void *argp1 = 0 ;
35199 int res1 = 0 ;
35200 PyObject *swig_obj[1] ;
35201
35202 if (!args) SWIG_fail;
35203 swig_obj[0] = args;
35204 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35205 if (!SWIG_IsOK(res1)) {
35206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35207 }
35208 arg1 = reinterpret_cast< wxWindow * >(argp1);
35209 {
35210 PyThreadState* __tstate = wxPyBeginAllowThreads();
35211 result = (arg1)->GetFont();
35212 wxPyEndAllowThreads(__tstate);
35213 if (PyErr_Occurred()) SWIG_fail;
35214 }
35215 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
35216 return resultobj;
35217 fail:
35218 return NULL;
35219 }
35220
35221
35222 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35223 PyObject *resultobj = 0;
35224 wxWindow *arg1 = (wxWindow *) 0 ;
35225 wxCaret *arg2 = (wxCaret *) 0 ;
35226 void *argp1 = 0 ;
35227 int res1 = 0 ;
35228 int res2 = 0 ;
35229 PyObject * obj0 = 0 ;
35230 PyObject * obj1 = 0 ;
35231 char * kwnames[] = {
35232 (char *) "self",(char *) "caret", NULL
35233 };
35234
35235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
35236 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35237 if (!SWIG_IsOK(res1)) {
35238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
35239 }
35240 arg1 = reinterpret_cast< wxWindow * >(argp1);
35241 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
35242 if (!SWIG_IsOK(res2)) {
35243 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
35244 }
35245 {
35246 PyThreadState* __tstate = wxPyBeginAllowThreads();
35247 (arg1)->SetCaret(arg2);
35248 wxPyEndAllowThreads(__tstate);
35249 if (PyErr_Occurred()) SWIG_fail;
35250 }
35251 resultobj = SWIG_Py_Void();
35252 return resultobj;
35253 fail:
35254 return NULL;
35255 }
35256
35257
35258 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35259 PyObject *resultobj = 0;
35260 wxWindow *arg1 = (wxWindow *) 0 ;
35261 wxCaret *result = 0 ;
35262 void *argp1 = 0 ;
35263 int res1 = 0 ;
35264 PyObject *swig_obj[1] ;
35265
35266 if (!args) SWIG_fail;
35267 swig_obj[0] = args;
35268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35269 if (!SWIG_IsOK(res1)) {
35270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
35271 }
35272 arg1 = reinterpret_cast< wxWindow * >(argp1);
35273 {
35274 PyThreadState* __tstate = wxPyBeginAllowThreads();
35275 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
35276 wxPyEndAllowThreads(__tstate);
35277 if (PyErr_Occurred()) SWIG_fail;
35278 }
35279 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
35280 return resultobj;
35281 fail:
35282 return NULL;
35283 }
35284
35285
35286 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35287 PyObject *resultobj = 0;
35288 wxWindow *arg1 = (wxWindow *) 0 ;
35289 int result;
35290 void *argp1 = 0 ;
35291 int res1 = 0 ;
35292 PyObject *swig_obj[1] ;
35293
35294 if (!args) SWIG_fail;
35295 swig_obj[0] = args;
35296 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35297 if (!SWIG_IsOK(res1)) {
35298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35299 }
35300 arg1 = reinterpret_cast< wxWindow * >(argp1);
35301 {
35302 PyThreadState* __tstate = wxPyBeginAllowThreads();
35303 result = (int)((wxWindow const *)arg1)->GetCharHeight();
35304 wxPyEndAllowThreads(__tstate);
35305 if (PyErr_Occurred()) SWIG_fail;
35306 }
35307 resultobj = SWIG_From_int(static_cast< int >(result));
35308 return resultobj;
35309 fail:
35310 return NULL;
35311 }
35312
35313
35314 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35315 PyObject *resultobj = 0;
35316 wxWindow *arg1 = (wxWindow *) 0 ;
35317 int result;
35318 void *argp1 = 0 ;
35319 int res1 = 0 ;
35320 PyObject *swig_obj[1] ;
35321
35322 if (!args) SWIG_fail;
35323 swig_obj[0] = args;
35324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35325 if (!SWIG_IsOK(res1)) {
35326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35327 }
35328 arg1 = reinterpret_cast< wxWindow * >(argp1);
35329 {
35330 PyThreadState* __tstate = wxPyBeginAllowThreads();
35331 result = (int)((wxWindow const *)arg1)->GetCharWidth();
35332 wxPyEndAllowThreads(__tstate);
35333 if (PyErr_Occurred()) SWIG_fail;
35334 }
35335 resultobj = SWIG_From_int(static_cast< int >(result));
35336 return resultobj;
35337 fail:
35338 return NULL;
35339 }
35340
35341
35342 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35343 PyObject *resultobj = 0;
35344 wxWindow *arg1 = (wxWindow *) 0 ;
35345 wxString *arg2 = 0 ;
35346 int *arg3 = (int *) 0 ;
35347 int *arg4 = (int *) 0 ;
35348 void *argp1 = 0 ;
35349 int res1 = 0 ;
35350 bool temp2 = false ;
35351 int temp3 ;
35352 int res3 = SWIG_TMPOBJ ;
35353 int temp4 ;
35354 int res4 = SWIG_TMPOBJ ;
35355 PyObject * obj0 = 0 ;
35356 PyObject * obj1 = 0 ;
35357 char * kwnames[] = {
35358 (char *) "self",(char *) "string", NULL
35359 };
35360
35361 arg3 = &temp3;
35362 arg4 = &temp4;
35363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
35364 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35365 if (!SWIG_IsOK(res1)) {
35366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35367 }
35368 arg1 = reinterpret_cast< wxWindow * >(argp1);
35369 {
35370 arg2 = wxString_in_helper(obj1);
35371 if (arg2 == NULL) SWIG_fail;
35372 temp2 = true;
35373 }
35374 {
35375 PyThreadState* __tstate = wxPyBeginAllowThreads();
35376 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
35377 wxPyEndAllowThreads(__tstate);
35378 if (PyErr_Occurred()) SWIG_fail;
35379 }
35380 resultobj = SWIG_Py_Void();
35381 if (SWIG_IsTmpObj(res3)) {
35382 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35383 } else {
35384 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35385 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35386 }
35387 if (SWIG_IsTmpObj(res4)) {
35388 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35389 } else {
35390 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35391 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35392 }
35393 {
35394 if (temp2)
35395 delete arg2;
35396 }
35397 return resultobj;
35398 fail:
35399 {
35400 if (temp2)
35401 delete arg2;
35402 }
35403 return NULL;
35404 }
35405
35406
35407 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35408 PyObject *resultobj = 0;
35409 wxWindow *arg1 = (wxWindow *) 0 ;
35410 wxString *arg2 = 0 ;
35411 int *arg3 = (int *) 0 ;
35412 int *arg4 = (int *) 0 ;
35413 int *arg5 = (int *) 0 ;
35414 int *arg6 = (int *) 0 ;
35415 wxFont *arg7 = (wxFont *) NULL ;
35416 void *argp1 = 0 ;
35417 int res1 = 0 ;
35418 bool temp2 = false ;
35419 int temp3 ;
35420 int res3 = SWIG_TMPOBJ ;
35421 int temp4 ;
35422 int res4 = SWIG_TMPOBJ ;
35423 int temp5 ;
35424 int res5 = SWIG_TMPOBJ ;
35425 int temp6 ;
35426 int res6 = SWIG_TMPOBJ ;
35427 void *argp7 = 0 ;
35428 int res7 = 0 ;
35429 PyObject * obj0 = 0 ;
35430 PyObject * obj1 = 0 ;
35431 PyObject * obj2 = 0 ;
35432 char * kwnames[] = {
35433 (char *) "self",(char *) "string",(char *) "font", NULL
35434 };
35435
35436 arg3 = &temp3;
35437 arg4 = &temp4;
35438 arg5 = &temp5;
35439 arg6 = &temp6;
35440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35441 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35442 if (!SWIG_IsOK(res1)) {
35443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35444 }
35445 arg1 = reinterpret_cast< wxWindow * >(argp1);
35446 {
35447 arg2 = wxString_in_helper(obj1);
35448 if (arg2 == NULL) SWIG_fail;
35449 temp2 = true;
35450 }
35451 if (obj2) {
35452 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
35453 if (!SWIG_IsOK(res7)) {
35454 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
35455 }
35456 arg7 = reinterpret_cast< wxFont * >(argp7);
35457 }
35458 {
35459 PyThreadState* __tstate = wxPyBeginAllowThreads();
35460 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
35461 wxPyEndAllowThreads(__tstate);
35462 if (PyErr_Occurred()) SWIG_fail;
35463 }
35464 resultobj = SWIG_Py_Void();
35465 if (SWIG_IsTmpObj(res3)) {
35466 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35467 } else {
35468 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35469 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35470 }
35471 if (SWIG_IsTmpObj(res4)) {
35472 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35473 } else {
35474 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35475 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35476 }
35477 if (SWIG_IsTmpObj(res5)) {
35478 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
35479 } else {
35480 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35481 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
35482 }
35483 if (SWIG_IsTmpObj(res6)) {
35484 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
35485 } else {
35486 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35487 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
35488 }
35489 {
35490 if (temp2)
35491 delete arg2;
35492 }
35493 return resultobj;
35494 fail:
35495 {
35496 if (temp2)
35497 delete arg2;
35498 }
35499 return NULL;
35500 }
35501
35502
35503 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35504 PyObject *resultobj = 0;
35505 wxWindow *arg1 = (wxWindow *) 0 ;
35506 int *arg2 = (int *) 0 ;
35507 int *arg3 = (int *) 0 ;
35508 void *argp1 = 0 ;
35509 int res1 = 0 ;
35510 int temp2 ;
35511 int res2 = 0 ;
35512 int temp3 ;
35513 int res3 = 0 ;
35514 PyObject * obj0 = 0 ;
35515 PyObject * obj1 = 0 ;
35516 PyObject * obj2 = 0 ;
35517 char * kwnames[] = {
35518 (char *) "self",(char *) "x",(char *) "y", NULL
35519 };
35520
35521 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35522 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35523 if (!SWIG_IsOK(res1)) {
35524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35525 }
35526 arg1 = reinterpret_cast< wxWindow * >(argp1);
35527 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35528 int val;
35529 int ecode = SWIG_AsVal_int(obj1, &val);
35530 if (!SWIG_IsOK(ecode)) {
35531 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
35532 }
35533 temp2 = static_cast< int >(val);
35534 arg2 = &temp2;
35535 res2 = SWIG_AddTmpMask(ecode);
35536 }
35537 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35538 int val;
35539 int ecode = SWIG_AsVal_int(obj2, &val);
35540 if (!SWIG_IsOK(ecode)) {
35541 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
35542 }
35543 temp3 = static_cast< int >(val);
35544 arg3 = &temp3;
35545 res3 = SWIG_AddTmpMask(ecode);
35546 }
35547 {
35548 PyThreadState* __tstate = wxPyBeginAllowThreads();
35549 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
35550 wxPyEndAllowThreads(__tstate);
35551 if (PyErr_Occurred()) SWIG_fail;
35552 }
35553 resultobj = SWIG_Py_Void();
35554 if (SWIG_IsTmpObj(res2)) {
35555 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35556 } else {
35557 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35558 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35559 }
35560 if (SWIG_IsTmpObj(res3)) {
35561 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35562 } else {
35563 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35564 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35565 }
35566 return resultobj;
35567 fail:
35568 return NULL;
35569 }
35570
35571
35572 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35573 PyObject *resultobj = 0;
35574 wxWindow *arg1 = (wxWindow *) 0 ;
35575 int *arg2 = (int *) 0 ;
35576 int *arg3 = (int *) 0 ;
35577 void *argp1 = 0 ;
35578 int res1 = 0 ;
35579 int temp2 ;
35580 int res2 = 0 ;
35581 int temp3 ;
35582 int res3 = 0 ;
35583 PyObject * obj0 = 0 ;
35584 PyObject * obj1 = 0 ;
35585 PyObject * obj2 = 0 ;
35586 char * kwnames[] = {
35587 (char *) "self",(char *) "x",(char *) "y", NULL
35588 };
35589
35590 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35591 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35592 if (!SWIG_IsOK(res1)) {
35593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35594 }
35595 arg1 = reinterpret_cast< wxWindow * >(argp1);
35596 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35597 int val;
35598 int ecode = SWIG_AsVal_int(obj1, &val);
35599 if (!SWIG_IsOK(ecode)) {
35600 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
35601 }
35602 temp2 = static_cast< int >(val);
35603 arg2 = &temp2;
35604 res2 = SWIG_AddTmpMask(ecode);
35605 }
35606 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35607 int val;
35608 int ecode = SWIG_AsVal_int(obj2, &val);
35609 if (!SWIG_IsOK(ecode)) {
35610 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
35611 }
35612 temp3 = static_cast< int >(val);
35613 arg3 = &temp3;
35614 res3 = SWIG_AddTmpMask(ecode);
35615 }
35616 {
35617 PyThreadState* __tstate = wxPyBeginAllowThreads();
35618 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
35619 wxPyEndAllowThreads(__tstate);
35620 if (PyErr_Occurred()) SWIG_fail;
35621 }
35622 resultobj = SWIG_Py_Void();
35623 if (SWIG_IsTmpObj(res2)) {
35624 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35625 } else {
35626 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35627 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35628 }
35629 if (SWIG_IsTmpObj(res3)) {
35630 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35631 } else {
35632 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35633 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35634 }
35635 return resultobj;
35636 fail:
35637 return NULL;
35638 }
35639
35640
35641 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35642 PyObject *resultobj = 0;
35643 wxWindow *arg1 = (wxWindow *) 0 ;
35644 wxPoint *arg2 = 0 ;
35645 wxPoint result;
35646 void *argp1 = 0 ;
35647 int res1 = 0 ;
35648 wxPoint temp2 ;
35649 PyObject * obj0 = 0 ;
35650 PyObject * obj1 = 0 ;
35651 char * kwnames[] = {
35652 (char *) "self",(char *) "pt", NULL
35653 };
35654
35655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
35656 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35657 if (!SWIG_IsOK(res1)) {
35658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35659 }
35660 arg1 = reinterpret_cast< wxWindow * >(argp1);
35661 {
35662 arg2 = &temp2;
35663 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35664 }
35665 {
35666 PyThreadState* __tstate = wxPyBeginAllowThreads();
35667 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
35668 wxPyEndAllowThreads(__tstate);
35669 if (PyErr_Occurred()) SWIG_fail;
35670 }
35671 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35672 return resultobj;
35673 fail:
35674 return NULL;
35675 }
35676
35677
35678 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35679 PyObject *resultobj = 0;
35680 wxWindow *arg1 = (wxWindow *) 0 ;
35681 wxPoint *arg2 = 0 ;
35682 wxPoint result;
35683 void *argp1 = 0 ;
35684 int res1 = 0 ;
35685 wxPoint temp2 ;
35686 PyObject * obj0 = 0 ;
35687 PyObject * obj1 = 0 ;
35688 char * kwnames[] = {
35689 (char *) "self",(char *) "pt", NULL
35690 };
35691
35692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
35693 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35694 if (!SWIG_IsOK(res1)) {
35695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
35696 }
35697 arg1 = reinterpret_cast< wxWindow * >(argp1);
35698 {
35699 arg2 = &temp2;
35700 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35701 }
35702 {
35703 PyThreadState* __tstate = wxPyBeginAllowThreads();
35704 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
35705 wxPyEndAllowThreads(__tstate);
35706 if (PyErr_Occurred()) SWIG_fail;
35707 }
35708 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35709 return resultobj;
35710 fail:
35711 return NULL;
35712 }
35713
35714
35715 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35716 PyObject *resultobj = 0;
35717 wxWindow *arg1 = (wxWindow *) 0 ;
35718 int arg2 ;
35719 int arg3 ;
35720 wxHitTest result;
35721 void *argp1 = 0 ;
35722 int res1 = 0 ;
35723 int val2 ;
35724 int ecode2 = 0 ;
35725 int val3 ;
35726 int ecode3 = 0 ;
35727 PyObject * obj0 = 0 ;
35728 PyObject * obj1 = 0 ;
35729 PyObject * obj2 = 0 ;
35730 char * kwnames[] = {
35731 (char *) "self",(char *) "x",(char *) "y", NULL
35732 };
35733
35734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35735 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35736 if (!SWIG_IsOK(res1)) {
35737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35738 }
35739 arg1 = reinterpret_cast< wxWindow * >(argp1);
35740 ecode2 = SWIG_AsVal_int(obj1, &val2);
35741 if (!SWIG_IsOK(ecode2)) {
35742 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
35743 }
35744 arg2 = static_cast< int >(val2);
35745 ecode3 = SWIG_AsVal_int(obj2, &val3);
35746 if (!SWIG_IsOK(ecode3)) {
35747 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
35748 }
35749 arg3 = static_cast< int >(val3);
35750 {
35751 PyThreadState* __tstate = wxPyBeginAllowThreads();
35752 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
35753 wxPyEndAllowThreads(__tstate);
35754 if (PyErr_Occurred()) SWIG_fail;
35755 }
35756 resultobj = SWIG_From_int(static_cast< int >(result));
35757 return resultobj;
35758 fail:
35759 return NULL;
35760 }
35761
35762
35763 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35764 PyObject *resultobj = 0;
35765 wxWindow *arg1 = (wxWindow *) 0 ;
35766 wxPoint *arg2 = 0 ;
35767 wxHitTest result;
35768 void *argp1 = 0 ;
35769 int res1 = 0 ;
35770 wxPoint temp2 ;
35771 PyObject * obj0 = 0 ;
35772 PyObject * obj1 = 0 ;
35773 char * kwnames[] = {
35774 (char *) "self",(char *) "pt", NULL
35775 };
35776
35777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
35778 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35779 if (!SWIG_IsOK(res1)) {
35780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
35781 }
35782 arg1 = reinterpret_cast< wxWindow * >(argp1);
35783 {
35784 arg2 = &temp2;
35785 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35786 }
35787 {
35788 PyThreadState* __tstate = wxPyBeginAllowThreads();
35789 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
35790 wxPyEndAllowThreads(__tstate);
35791 if (PyErr_Occurred()) SWIG_fail;
35792 }
35793 resultobj = SWIG_From_int(static_cast< int >(result));
35794 return resultobj;
35795 fail:
35796 return NULL;
35797 }
35798
35799
35800 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
35801 PyObject *resultobj = 0;
35802 wxWindow *arg1 = (wxWindow *) 0 ;
35803 long arg2 ;
35804 wxBorder result;
35805 void *argp1 = 0 ;
35806 int res1 = 0 ;
35807 long val2 ;
35808 int ecode2 = 0 ;
35809
35810 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
35811 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35812 if (!SWIG_IsOK(res1)) {
35813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
35814 }
35815 arg1 = reinterpret_cast< wxWindow * >(argp1);
35816 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
35817 if (!SWIG_IsOK(ecode2)) {
35818 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
35819 }
35820 arg2 = static_cast< long >(val2);
35821 {
35822 PyThreadState* __tstate = wxPyBeginAllowThreads();
35823 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
35824 wxPyEndAllowThreads(__tstate);
35825 if (PyErr_Occurred()) SWIG_fail;
35826 }
35827 resultobj = SWIG_From_int(static_cast< int >(result));
35828 return resultobj;
35829 fail:
35830 return NULL;
35831 }
35832
35833
35834 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
35835 PyObject *resultobj = 0;
35836 wxWindow *arg1 = (wxWindow *) 0 ;
35837 wxBorder result;
35838 void *argp1 = 0 ;
35839 int res1 = 0 ;
35840
35841 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
35842 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35843 if (!SWIG_IsOK(res1)) {
35844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
35845 }
35846 arg1 = reinterpret_cast< wxWindow * >(argp1);
35847 {
35848 PyThreadState* __tstate = wxPyBeginAllowThreads();
35849 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
35850 wxPyEndAllowThreads(__tstate);
35851 if (PyErr_Occurred()) SWIG_fail;
35852 }
35853 resultobj = SWIG_From_int(static_cast< int >(result));
35854 return resultobj;
35855 fail:
35856 return NULL;
35857 }
35858
35859
35860 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
35861 int argc;
35862 PyObject *argv[3];
35863
35864 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
35865 --argc;
35866 if (argc == 1) {
35867 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
35868 }
35869 if (argc == 2) {
35870 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
35871 }
35872
35873 fail:
35874 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
35875 return NULL;
35876 }
35877
35878
35879 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35880 PyObject *resultobj = 0;
35881 wxWindow *arg1 = (wxWindow *) 0 ;
35882 long arg2 = (long) wxUPDATE_UI_NONE ;
35883 void *argp1 = 0 ;
35884 int res1 = 0 ;
35885 long val2 ;
35886 int ecode2 = 0 ;
35887 PyObject * obj0 = 0 ;
35888 PyObject * obj1 = 0 ;
35889 char * kwnames[] = {
35890 (char *) "self",(char *) "flags", NULL
35891 };
35892
35893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
35894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35895 if (!SWIG_IsOK(res1)) {
35896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
35897 }
35898 arg1 = reinterpret_cast< wxWindow * >(argp1);
35899 if (obj1) {
35900 ecode2 = SWIG_AsVal_long(obj1, &val2);
35901 if (!SWIG_IsOK(ecode2)) {
35902 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
35903 }
35904 arg2 = static_cast< long >(val2);
35905 }
35906 {
35907 PyThreadState* __tstate = wxPyBeginAllowThreads();
35908 (arg1)->UpdateWindowUI(arg2);
35909 wxPyEndAllowThreads(__tstate);
35910 if (PyErr_Occurred()) SWIG_fail;
35911 }
35912 resultobj = SWIG_Py_Void();
35913 return resultobj;
35914 fail:
35915 return NULL;
35916 }
35917
35918
35919 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35920 PyObject *resultobj = 0;
35921 wxWindow *arg1 = (wxWindow *) 0 ;
35922 wxMenu *arg2 = (wxMenu *) 0 ;
35923 int arg3 = (int) -1 ;
35924 int arg4 = (int) -1 ;
35925 bool result;
35926 void *argp1 = 0 ;
35927 int res1 = 0 ;
35928 void *argp2 = 0 ;
35929 int res2 = 0 ;
35930 int val3 ;
35931 int ecode3 = 0 ;
35932 int val4 ;
35933 int ecode4 = 0 ;
35934 PyObject * obj0 = 0 ;
35935 PyObject * obj1 = 0 ;
35936 PyObject * obj2 = 0 ;
35937 PyObject * obj3 = 0 ;
35938 char * kwnames[] = {
35939 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
35940 };
35941
35942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35944 if (!SWIG_IsOK(res1)) {
35945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
35946 }
35947 arg1 = reinterpret_cast< wxWindow * >(argp1);
35948 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
35949 if (!SWIG_IsOK(res2)) {
35950 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
35951 }
35952 arg2 = reinterpret_cast< wxMenu * >(argp2);
35953 if (obj2) {
35954 ecode3 = SWIG_AsVal_int(obj2, &val3);
35955 if (!SWIG_IsOK(ecode3)) {
35956 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
35957 }
35958 arg3 = static_cast< int >(val3);
35959 }
35960 if (obj3) {
35961 ecode4 = SWIG_AsVal_int(obj3, &val4);
35962 if (!SWIG_IsOK(ecode4)) {
35963 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
35964 }
35965 arg4 = static_cast< int >(val4);
35966 }
35967 {
35968 PyThreadState* __tstate = wxPyBeginAllowThreads();
35969 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
35970 wxPyEndAllowThreads(__tstate);
35971 if (PyErr_Occurred()) SWIG_fail;
35972 }
35973 {
35974 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35975 }
35976 return resultobj;
35977 fail:
35978 return NULL;
35979 }
35980
35981
35982 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35983 PyObject *resultobj = 0;
35984 wxWindow *arg1 = (wxWindow *) 0 ;
35985 wxMenu *arg2 = (wxMenu *) 0 ;
35986 wxPoint const &arg3_defvalue = wxDefaultPosition ;
35987 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
35988 bool result;
35989 void *argp1 = 0 ;
35990 int res1 = 0 ;
35991 void *argp2 = 0 ;
35992 int res2 = 0 ;
35993 wxPoint temp3 ;
35994 PyObject * obj0 = 0 ;
35995 PyObject * obj1 = 0 ;
35996 PyObject * obj2 = 0 ;
35997 char * kwnames[] = {
35998 (char *) "self",(char *) "menu",(char *) "pos", NULL
35999 };
36000
36001 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36002 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36003 if (!SWIG_IsOK(res1)) {
36004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
36005 }
36006 arg1 = reinterpret_cast< wxWindow * >(argp1);
36007 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36008 if (!SWIG_IsOK(res2)) {
36009 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
36010 }
36011 arg2 = reinterpret_cast< wxMenu * >(argp2);
36012 if (obj2) {
36013 {
36014 arg3 = &temp3;
36015 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
36016 }
36017 }
36018 {
36019 PyThreadState* __tstate = wxPyBeginAllowThreads();
36020 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
36021 wxPyEndAllowThreads(__tstate);
36022 if (PyErr_Occurred()) SWIG_fail;
36023 }
36024 {
36025 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36026 }
36027 return resultobj;
36028 fail:
36029 return NULL;
36030 }
36031
36032
36033 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36034 PyObject *resultobj = 0;
36035 wxWindow *arg1 = (wxWindow *) 0 ;
36036 long result;
36037 void *argp1 = 0 ;
36038 int res1 = 0 ;
36039 PyObject *swig_obj[1] ;
36040
36041 if (!args) SWIG_fail;
36042 swig_obj[0] = args;
36043 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36044 if (!SWIG_IsOK(res1)) {
36045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36046 }
36047 arg1 = reinterpret_cast< wxWindow * >(argp1);
36048 {
36049 PyThreadState* __tstate = wxPyBeginAllowThreads();
36050 result = (long)wxWindow_GetHandle(arg1);
36051 wxPyEndAllowThreads(__tstate);
36052 if (PyErr_Occurred()) SWIG_fail;
36053 }
36054 resultobj = SWIG_From_long(static_cast< long >(result));
36055 return resultobj;
36056 fail:
36057 return NULL;
36058 }
36059
36060
36061 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36062 PyObject *resultobj = 0;
36063 wxWindow *arg1 = (wxWindow *) 0 ;
36064 long arg2 ;
36065 void *argp1 = 0 ;
36066 int res1 = 0 ;
36067 long val2 ;
36068 int ecode2 = 0 ;
36069 PyObject * obj0 = 0 ;
36070 PyObject * obj1 = 0 ;
36071 char * kwnames[] = {
36072 (char *) "self",(char *) "handle", NULL
36073 };
36074
36075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
36076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36077 if (!SWIG_IsOK(res1)) {
36078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36079 }
36080 arg1 = reinterpret_cast< wxWindow * >(argp1);
36081 ecode2 = SWIG_AsVal_long(obj1, &val2);
36082 if (!SWIG_IsOK(ecode2)) {
36083 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
36084 }
36085 arg2 = static_cast< long >(val2);
36086 {
36087 PyThreadState* __tstate = wxPyBeginAllowThreads();
36088 wxWindow_AssociateHandle(arg1,arg2);
36089 wxPyEndAllowThreads(__tstate);
36090 if (PyErr_Occurred()) SWIG_fail;
36091 }
36092 resultobj = SWIG_Py_Void();
36093 return resultobj;
36094 fail:
36095 return NULL;
36096 }
36097
36098
36099 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36100 PyObject *resultobj = 0;
36101 wxWindow *arg1 = (wxWindow *) 0 ;
36102 void *argp1 = 0 ;
36103 int res1 = 0 ;
36104 PyObject *swig_obj[1] ;
36105
36106 if (!args) SWIG_fail;
36107 swig_obj[0] = args;
36108 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36109 if (!SWIG_IsOK(res1)) {
36110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36111 }
36112 arg1 = reinterpret_cast< wxWindow * >(argp1);
36113 {
36114 PyThreadState* __tstate = wxPyBeginAllowThreads();
36115 (arg1)->DissociateHandle();
36116 wxPyEndAllowThreads(__tstate);
36117 if (PyErr_Occurred()) SWIG_fail;
36118 }
36119 resultobj = SWIG_Py_Void();
36120 return resultobj;
36121 fail:
36122 return NULL;
36123 }
36124
36125
36126 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36127 PyObject *resultobj = 0;
36128 wxWindow *arg1 = (wxWindow *) 0 ;
36129 int arg2 ;
36130 bool result;
36131 void *argp1 = 0 ;
36132 int res1 = 0 ;
36133 int val2 ;
36134 int ecode2 = 0 ;
36135 PyObject * obj0 = 0 ;
36136 PyObject * obj1 = 0 ;
36137 char * kwnames[] = {
36138 (char *) "self",(char *) "orient", NULL
36139 };
36140
36141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
36142 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36143 if (!SWIG_IsOK(res1)) {
36144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
36145 }
36146 arg1 = reinterpret_cast< wxWindow * >(argp1);
36147 ecode2 = SWIG_AsVal_int(obj1, &val2);
36148 if (!SWIG_IsOK(ecode2)) {
36149 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
36150 }
36151 arg2 = static_cast< int >(val2);
36152 {
36153 PyThreadState* __tstate = wxPyBeginAllowThreads();
36154 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
36155 wxPyEndAllowThreads(__tstate);
36156 if (PyErr_Occurred()) SWIG_fail;
36157 }
36158 {
36159 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36160 }
36161 return resultobj;
36162 fail:
36163 return NULL;
36164 }
36165
36166
36167 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36168 PyObject *resultobj = 0;
36169 wxWindow *arg1 = (wxWindow *) 0 ;
36170 int arg2 ;
36171 int arg3 ;
36172 int arg4 ;
36173 int arg5 ;
36174 bool arg6 = (bool) true ;
36175 void *argp1 = 0 ;
36176 int res1 = 0 ;
36177 int val2 ;
36178 int ecode2 = 0 ;
36179 int val3 ;
36180 int ecode3 = 0 ;
36181 int val4 ;
36182 int ecode4 = 0 ;
36183 int val5 ;
36184 int ecode5 = 0 ;
36185 bool val6 ;
36186 int ecode6 = 0 ;
36187 PyObject * obj0 = 0 ;
36188 PyObject * obj1 = 0 ;
36189 PyObject * obj2 = 0 ;
36190 PyObject * obj3 = 0 ;
36191 PyObject * obj4 = 0 ;
36192 PyObject * obj5 = 0 ;
36193 char * kwnames[] = {
36194 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
36195 };
36196
36197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
36198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36199 if (!SWIG_IsOK(res1)) {
36200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
36201 }
36202 arg1 = reinterpret_cast< wxWindow * >(argp1);
36203 ecode2 = SWIG_AsVal_int(obj1, &val2);
36204 if (!SWIG_IsOK(ecode2)) {
36205 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
36206 }
36207 arg2 = static_cast< int >(val2);
36208 ecode3 = SWIG_AsVal_int(obj2, &val3);
36209 if (!SWIG_IsOK(ecode3)) {
36210 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
36211 }
36212 arg3 = static_cast< int >(val3);
36213 ecode4 = SWIG_AsVal_int(obj3, &val4);
36214 if (!SWIG_IsOK(ecode4)) {
36215 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
36216 }
36217 arg4 = static_cast< int >(val4);
36218 ecode5 = SWIG_AsVal_int(obj4, &val5);
36219 if (!SWIG_IsOK(ecode5)) {
36220 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
36221 }
36222 arg5 = static_cast< int >(val5);
36223 if (obj5) {
36224 ecode6 = SWIG_AsVal_bool(obj5, &val6);
36225 if (!SWIG_IsOK(ecode6)) {
36226 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
36227 }
36228 arg6 = static_cast< bool >(val6);
36229 }
36230 {
36231 PyThreadState* __tstate = wxPyBeginAllowThreads();
36232 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
36233 wxPyEndAllowThreads(__tstate);
36234 if (PyErr_Occurred()) SWIG_fail;
36235 }
36236 resultobj = SWIG_Py_Void();
36237 return resultobj;
36238 fail:
36239 return NULL;
36240 }
36241
36242
36243 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36244 PyObject *resultobj = 0;
36245 wxWindow *arg1 = (wxWindow *) 0 ;
36246 int arg2 ;
36247 int arg3 ;
36248 bool arg4 = (bool) true ;
36249 void *argp1 = 0 ;
36250 int res1 = 0 ;
36251 int val2 ;
36252 int ecode2 = 0 ;
36253 int val3 ;
36254 int ecode3 = 0 ;
36255 bool val4 ;
36256 int ecode4 = 0 ;
36257 PyObject * obj0 = 0 ;
36258 PyObject * obj1 = 0 ;
36259 PyObject * obj2 = 0 ;
36260 PyObject * obj3 = 0 ;
36261 char * kwnames[] = {
36262 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
36263 };
36264
36265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36266 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36267 if (!SWIG_IsOK(res1)) {
36268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
36269 }
36270 arg1 = reinterpret_cast< wxWindow * >(argp1);
36271 ecode2 = SWIG_AsVal_int(obj1, &val2);
36272 if (!SWIG_IsOK(ecode2)) {
36273 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
36274 }
36275 arg2 = static_cast< int >(val2);
36276 ecode3 = SWIG_AsVal_int(obj2, &val3);
36277 if (!SWIG_IsOK(ecode3)) {
36278 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
36279 }
36280 arg3 = static_cast< int >(val3);
36281 if (obj3) {
36282 ecode4 = SWIG_AsVal_bool(obj3, &val4);
36283 if (!SWIG_IsOK(ecode4)) {
36284 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
36285 }
36286 arg4 = static_cast< bool >(val4);
36287 }
36288 {
36289 PyThreadState* __tstate = wxPyBeginAllowThreads();
36290 (arg1)->SetScrollPos(arg2,arg3,arg4);
36291 wxPyEndAllowThreads(__tstate);
36292 if (PyErr_Occurred()) SWIG_fail;
36293 }
36294 resultobj = SWIG_Py_Void();
36295 return resultobj;
36296 fail:
36297 return NULL;
36298 }
36299
36300
36301 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36302 PyObject *resultobj = 0;
36303 wxWindow *arg1 = (wxWindow *) 0 ;
36304 int arg2 ;
36305 int result;
36306 void *argp1 = 0 ;
36307 int res1 = 0 ;
36308 int val2 ;
36309 int ecode2 = 0 ;
36310 PyObject * obj0 = 0 ;
36311 PyObject * obj1 = 0 ;
36312 char * kwnames[] = {
36313 (char *) "self",(char *) "orientation", NULL
36314 };
36315
36316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
36317 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36318 if (!SWIG_IsOK(res1)) {
36319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
36320 }
36321 arg1 = reinterpret_cast< wxWindow * >(argp1);
36322 ecode2 = SWIG_AsVal_int(obj1, &val2);
36323 if (!SWIG_IsOK(ecode2)) {
36324 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
36325 }
36326 arg2 = static_cast< int >(val2);
36327 {
36328 PyThreadState* __tstate = wxPyBeginAllowThreads();
36329 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
36330 wxPyEndAllowThreads(__tstate);
36331 if (PyErr_Occurred()) SWIG_fail;
36332 }
36333 resultobj = SWIG_From_int(static_cast< int >(result));
36334 return resultobj;
36335 fail:
36336 return NULL;
36337 }
36338
36339
36340 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36341 PyObject *resultobj = 0;
36342 wxWindow *arg1 = (wxWindow *) 0 ;
36343 int arg2 ;
36344 int result;
36345 void *argp1 = 0 ;
36346 int res1 = 0 ;
36347 int val2 ;
36348 int ecode2 = 0 ;
36349 PyObject * obj0 = 0 ;
36350 PyObject * obj1 = 0 ;
36351 char * kwnames[] = {
36352 (char *) "self",(char *) "orientation", NULL
36353 };
36354
36355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
36356 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36357 if (!SWIG_IsOK(res1)) {
36358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
36359 }
36360 arg1 = reinterpret_cast< wxWindow * >(argp1);
36361 ecode2 = SWIG_AsVal_int(obj1, &val2);
36362 if (!SWIG_IsOK(ecode2)) {
36363 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
36364 }
36365 arg2 = static_cast< int >(val2);
36366 {
36367 PyThreadState* __tstate = wxPyBeginAllowThreads();
36368 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
36369 wxPyEndAllowThreads(__tstate);
36370 if (PyErr_Occurred()) SWIG_fail;
36371 }
36372 resultobj = SWIG_From_int(static_cast< int >(result));
36373 return resultobj;
36374 fail:
36375 return NULL;
36376 }
36377
36378
36379 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36380 PyObject *resultobj = 0;
36381 wxWindow *arg1 = (wxWindow *) 0 ;
36382 int arg2 ;
36383 int result;
36384 void *argp1 = 0 ;
36385 int res1 = 0 ;
36386 int val2 ;
36387 int ecode2 = 0 ;
36388 PyObject * obj0 = 0 ;
36389 PyObject * obj1 = 0 ;
36390 char * kwnames[] = {
36391 (char *) "self",(char *) "orientation", NULL
36392 };
36393
36394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
36395 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36396 if (!SWIG_IsOK(res1)) {
36397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
36398 }
36399 arg1 = reinterpret_cast< wxWindow * >(argp1);
36400 ecode2 = SWIG_AsVal_int(obj1, &val2);
36401 if (!SWIG_IsOK(ecode2)) {
36402 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
36403 }
36404 arg2 = static_cast< int >(val2);
36405 {
36406 PyThreadState* __tstate = wxPyBeginAllowThreads();
36407 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
36408 wxPyEndAllowThreads(__tstate);
36409 if (PyErr_Occurred()) SWIG_fail;
36410 }
36411 resultobj = SWIG_From_int(static_cast< int >(result));
36412 return resultobj;
36413 fail:
36414 return NULL;
36415 }
36416
36417
36418 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36419 PyObject *resultobj = 0;
36420 wxWindow *arg1 = (wxWindow *) 0 ;
36421 int arg2 ;
36422 int arg3 ;
36423 wxRect *arg4 = (wxRect *) NULL ;
36424 void *argp1 = 0 ;
36425 int res1 = 0 ;
36426 int val2 ;
36427 int ecode2 = 0 ;
36428 int val3 ;
36429 int ecode3 = 0 ;
36430 void *argp4 = 0 ;
36431 int res4 = 0 ;
36432 PyObject * obj0 = 0 ;
36433 PyObject * obj1 = 0 ;
36434 PyObject * obj2 = 0 ;
36435 PyObject * obj3 = 0 ;
36436 char * kwnames[] = {
36437 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
36438 };
36439
36440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36441 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36442 if (!SWIG_IsOK(res1)) {
36443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36444 }
36445 arg1 = reinterpret_cast< wxWindow * >(argp1);
36446 ecode2 = SWIG_AsVal_int(obj1, &val2);
36447 if (!SWIG_IsOK(ecode2)) {
36448 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
36449 }
36450 arg2 = static_cast< int >(val2);
36451 ecode3 = SWIG_AsVal_int(obj2, &val3);
36452 if (!SWIG_IsOK(ecode3)) {
36453 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
36454 }
36455 arg3 = static_cast< int >(val3);
36456 if (obj3) {
36457 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
36458 if (!SWIG_IsOK(res4)) {
36459 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
36460 }
36461 arg4 = reinterpret_cast< wxRect * >(argp4);
36462 }
36463 {
36464 PyThreadState* __tstate = wxPyBeginAllowThreads();
36465 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
36466 wxPyEndAllowThreads(__tstate);
36467 if (PyErr_Occurred()) SWIG_fail;
36468 }
36469 resultobj = SWIG_Py_Void();
36470 return resultobj;
36471 fail:
36472 return NULL;
36473 }
36474
36475
36476 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36477 PyObject *resultobj = 0;
36478 wxWindow *arg1 = (wxWindow *) 0 ;
36479 int arg2 ;
36480 bool result;
36481 void *argp1 = 0 ;
36482 int res1 = 0 ;
36483 int val2 ;
36484 int ecode2 = 0 ;
36485 PyObject * obj0 = 0 ;
36486 PyObject * obj1 = 0 ;
36487 char * kwnames[] = {
36488 (char *) "self",(char *) "lines", NULL
36489 };
36490
36491 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
36492 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36493 if (!SWIG_IsOK(res1)) {
36494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
36495 }
36496 arg1 = reinterpret_cast< wxWindow * >(argp1);
36497 ecode2 = SWIG_AsVal_int(obj1, &val2);
36498 if (!SWIG_IsOK(ecode2)) {
36499 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
36500 }
36501 arg2 = static_cast< int >(val2);
36502 {
36503 PyThreadState* __tstate = wxPyBeginAllowThreads();
36504 result = (bool)(arg1)->ScrollLines(arg2);
36505 wxPyEndAllowThreads(__tstate);
36506 if (PyErr_Occurred()) SWIG_fail;
36507 }
36508 {
36509 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36510 }
36511 return resultobj;
36512 fail:
36513 return NULL;
36514 }
36515
36516
36517 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36518 PyObject *resultobj = 0;
36519 wxWindow *arg1 = (wxWindow *) 0 ;
36520 int arg2 ;
36521 bool result;
36522 void *argp1 = 0 ;
36523 int res1 = 0 ;
36524 int val2 ;
36525 int ecode2 = 0 ;
36526 PyObject * obj0 = 0 ;
36527 PyObject * obj1 = 0 ;
36528 char * kwnames[] = {
36529 (char *) "self",(char *) "pages", NULL
36530 };
36531
36532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
36533 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36534 if (!SWIG_IsOK(res1)) {
36535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
36536 }
36537 arg1 = reinterpret_cast< wxWindow * >(argp1);
36538 ecode2 = SWIG_AsVal_int(obj1, &val2);
36539 if (!SWIG_IsOK(ecode2)) {
36540 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
36541 }
36542 arg2 = static_cast< int >(val2);
36543 {
36544 PyThreadState* __tstate = wxPyBeginAllowThreads();
36545 result = (bool)(arg1)->ScrollPages(arg2);
36546 wxPyEndAllowThreads(__tstate);
36547 if (PyErr_Occurred()) SWIG_fail;
36548 }
36549 {
36550 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36551 }
36552 return resultobj;
36553 fail:
36554 return NULL;
36555 }
36556
36557
36558 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36559 PyObject *resultobj = 0;
36560 wxWindow *arg1 = (wxWindow *) 0 ;
36561 bool result;
36562 void *argp1 = 0 ;
36563 int res1 = 0 ;
36564 PyObject *swig_obj[1] ;
36565
36566 if (!args) SWIG_fail;
36567 swig_obj[0] = args;
36568 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36569 if (!SWIG_IsOK(res1)) {
36570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36571 }
36572 arg1 = reinterpret_cast< wxWindow * >(argp1);
36573 {
36574 PyThreadState* __tstate = wxPyBeginAllowThreads();
36575 result = (bool)(arg1)->LineUp();
36576 wxPyEndAllowThreads(__tstate);
36577 if (PyErr_Occurred()) SWIG_fail;
36578 }
36579 {
36580 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36581 }
36582 return resultobj;
36583 fail:
36584 return NULL;
36585 }
36586
36587
36588 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36589 PyObject *resultobj = 0;
36590 wxWindow *arg1 = (wxWindow *) 0 ;
36591 bool result;
36592 void *argp1 = 0 ;
36593 int res1 = 0 ;
36594 PyObject *swig_obj[1] ;
36595
36596 if (!args) SWIG_fail;
36597 swig_obj[0] = args;
36598 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36599 if (!SWIG_IsOK(res1)) {
36600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36601 }
36602 arg1 = reinterpret_cast< wxWindow * >(argp1);
36603 {
36604 PyThreadState* __tstate = wxPyBeginAllowThreads();
36605 result = (bool)(arg1)->LineDown();
36606 wxPyEndAllowThreads(__tstate);
36607 if (PyErr_Occurred()) SWIG_fail;
36608 }
36609 {
36610 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36611 }
36612 return resultobj;
36613 fail:
36614 return NULL;
36615 }
36616
36617
36618 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36619 PyObject *resultobj = 0;
36620 wxWindow *arg1 = (wxWindow *) 0 ;
36621 bool result;
36622 void *argp1 = 0 ;
36623 int res1 = 0 ;
36624 PyObject *swig_obj[1] ;
36625
36626 if (!args) SWIG_fail;
36627 swig_obj[0] = args;
36628 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36629 if (!SWIG_IsOK(res1)) {
36630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36631 }
36632 arg1 = reinterpret_cast< wxWindow * >(argp1);
36633 {
36634 PyThreadState* __tstate = wxPyBeginAllowThreads();
36635 result = (bool)(arg1)->PageUp();
36636 wxPyEndAllowThreads(__tstate);
36637 if (PyErr_Occurred()) SWIG_fail;
36638 }
36639 {
36640 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36641 }
36642 return resultobj;
36643 fail:
36644 return NULL;
36645 }
36646
36647
36648 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36649 PyObject *resultobj = 0;
36650 wxWindow *arg1 = (wxWindow *) 0 ;
36651 bool result;
36652 void *argp1 = 0 ;
36653 int res1 = 0 ;
36654 PyObject *swig_obj[1] ;
36655
36656 if (!args) SWIG_fail;
36657 swig_obj[0] = args;
36658 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36659 if (!SWIG_IsOK(res1)) {
36660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36661 }
36662 arg1 = reinterpret_cast< wxWindow * >(argp1);
36663 {
36664 PyThreadState* __tstate = wxPyBeginAllowThreads();
36665 result = (bool)(arg1)->PageDown();
36666 wxPyEndAllowThreads(__tstate);
36667 if (PyErr_Occurred()) SWIG_fail;
36668 }
36669 {
36670 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36671 }
36672 return resultobj;
36673 fail:
36674 return NULL;
36675 }
36676
36677
36678 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36679 PyObject *resultobj = 0;
36680 wxWindow *arg1 = (wxWindow *) 0 ;
36681 wxString *arg2 = 0 ;
36682 void *argp1 = 0 ;
36683 int res1 = 0 ;
36684 bool temp2 = false ;
36685 PyObject * obj0 = 0 ;
36686 PyObject * obj1 = 0 ;
36687 char * kwnames[] = {
36688 (char *) "self",(char *) "text", NULL
36689 };
36690
36691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
36692 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36693 if (!SWIG_IsOK(res1)) {
36694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
36695 }
36696 arg1 = reinterpret_cast< wxWindow * >(argp1);
36697 {
36698 arg2 = wxString_in_helper(obj1);
36699 if (arg2 == NULL) SWIG_fail;
36700 temp2 = true;
36701 }
36702 {
36703 PyThreadState* __tstate = wxPyBeginAllowThreads();
36704 (arg1)->SetHelpText((wxString const &)*arg2);
36705 wxPyEndAllowThreads(__tstate);
36706 if (PyErr_Occurred()) SWIG_fail;
36707 }
36708 resultobj = SWIG_Py_Void();
36709 {
36710 if (temp2)
36711 delete arg2;
36712 }
36713 return resultobj;
36714 fail:
36715 {
36716 if (temp2)
36717 delete arg2;
36718 }
36719 return NULL;
36720 }
36721
36722
36723 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36724 PyObject *resultobj = 0;
36725 wxWindow *arg1 = (wxWindow *) 0 ;
36726 wxString *arg2 = 0 ;
36727 void *argp1 = 0 ;
36728 int res1 = 0 ;
36729 bool temp2 = false ;
36730 PyObject * obj0 = 0 ;
36731 PyObject * obj1 = 0 ;
36732 char * kwnames[] = {
36733 (char *) "self",(char *) "text", NULL
36734 };
36735
36736 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
36737 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36738 if (!SWIG_IsOK(res1)) {
36739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
36740 }
36741 arg1 = reinterpret_cast< wxWindow * >(argp1);
36742 {
36743 arg2 = wxString_in_helper(obj1);
36744 if (arg2 == NULL) SWIG_fail;
36745 temp2 = true;
36746 }
36747 {
36748 PyThreadState* __tstate = wxPyBeginAllowThreads();
36749 (arg1)->SetHelpTextForId((wxString const &)*arg2);
36750 wxPyEndAllowThreads(__tstate);
36751 if (PyErr_Occurred()) SWIG_fail;
36752 }
36753 resultobj = SWIG_Py_Void();
36754 {
36755 if (temp2)
36756 delete arg2;
36757 }
36758 return resultobj;
36759 fail:
36760 {
36761 if (temp2)
36762 delete arg2;
36763 }
36764 return NULL;
36765 }
36766
36767
36768 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36769 PyObject *resultobj = 0;
36770 wxWindow *arg1 = (wxWindow *) 0 ;
36771 wxString result;
36772 void *argp1 = 0 ;
36773 int res1 = 0 ;
36774 PyObject *swig_obj[1] ;
36775
36776 if (!args) SWIG_fail;
36777 swig_obj[0] = args;
36778 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36779 if (!SWIG_IsOK(res1)) {
36780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
36781 }
36782 arg1 = reinterpret_cast< wxWindow * >(argp1);
36783 {
36784 PyThreadState* __tstate = wxPyBeginAllowThreads();
36785 result = ((wxWindow const *)arg1)->GetHelpText();
36786 wxPyEndAllowThreads(__tstate);
36787 if (PyErr_Occurred()) SWIG_fail;
36788 }
36789 {
36790 #if wxUSE_UNICODE
36791 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36792 #else
36793 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36794 #endif
36795 }
36796 return resultobj;
36797 fail:
36798 return NULL;
36799 }
36800
36801
36802 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36803 PyObject *resultobj = 0;
36804 wxWindow *arg1 = (wxWindow *) 0 ;
36805 wxString *arg2 = 0 ;
36806 void *argp1 = 0 ;
36807 int res1 = 0 ;
36808 bool temp2 = false ;
36809 PyObject * obj0 = 0 ;
36810 PyObject * obj1 = 0 ;
36811 char * kwnames[] = {
36812 (char *) "self",(char *) "tip", NULL
36813 };
36814
36815 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
36816 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36817 if (!SWIG_IsOK(res1)) {
36818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
36819 }
36820 arg1 = reinterpret_cast< wxWindow * >(argp1);
36821 {
36822 arg2 = wxString_in_helper(obj1);
36823 if (arg2 == NULL) SWIG_fail;
36824 temp2 = true;
36825 }
36826 {
36827 PyThreadState* __tstate = wxPyBeginAllowThreads();
36828 (arg1)->SetToolTip((wxString const &)*arg2);
36829 wxPyEndAllowThreads(__tstate);
36830 if (PyErr_Occurred()) SWIG_fail;
36831 }
36832 resultobj = SWIG_Py_Void();
36833 {
36834 if (temp2)
36835 delete arg2;
36836 }
36837 return resultobj;
36838 fail:
36839 {
36840 if (temp2)
36841 delete arg2;
36842 }
36843 return NULL;
36844 }
36845
36846
36847 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36848 PyObject *resultobj = 0;
36849 wxWindow *arg1 = (wxWindow *) 0 ;
36850 wxToolTip *arg2 = (wxToolTip *) 0 ;
36851 void *argp1 = 0 ;
36852 int res1 = 0 ;
36853 int res2 = 0 ;
36854 PyObject * obj0 = 0 ;
36855 PyObject * obj1 = 0 ;
36856 char * kwnames[] = {
36857 (char *) "self",(char *) "tip", NULL
36858 };
36859
36860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
36861 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36862 if (!SWIG_IsOK(res1)) {
36863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
36864 }
36865 arg1 = reinterpret_cast< wxWindow * >(argp1);
36866 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
36867 if (!SWIG_IsOK(res2)) {
36868 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
36869 }
36870 {
36871 PyThreadState* __tstate = wxPyBeginAllowThreads();
36872 (arg1)->SetToolTip(arg2);
36873 wxPyEndAllowThreads(__tstate);
36874 if (PyErr_Occurred()) SWIG_fail;
36875 }
36876 resultobj = SWIG_Py_Void();
36877 return resultobj;
36878 fail:
36879 return NULL;
36880 }
36881
36882
36883 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36884 PyObject *resultobj = 0;
36885 wxWindow *arg1 = (wxWindow *) 0 ;
36886 wxToolTip *result = 0 ;
36887 void *argp1 = 0 ;
36888 int res1 = 0 ;
36889 PyObject *swig_obj[1] ;
36890
36891 if (!args) SWIG_fail;
36892 swig_obj[0] = args;
36893 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36894 if (!SWIG_IsOK(res1)) {
36895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
36896 }
36897 arg1 = reinterpret_cast< wxWindow * >(argp1);
36898 {
36899 PyThreadState* __tstate = wxPyBeginAllowThreads();
36900 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
36901 wxPyEndAllowThreads(__tstate);
36902 if (PyErr_Occurred()) SWIG_fail;
36903 }
36904 {
36905 resultobj = wxPyMake_wxObject(result, (bool)0);
36906 }
36907 return resultobj;
36908 fail:
36909 return NULL;
36910 }
36911
36912
36913 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36914 PyObject *resultobj = 0;
36915 wxWindow *arg1 = (wxWindow *) 0 ;
36916 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
36917 void *argp1 = 0 ;
36918 int res1 = 0 ;
36919 int res2 = 0 ;
36920 PyObject * obj0 = 0 ;
36921 PyObject * obj1 = 0 ;
36922 char * kwnames[] = {
36923 (char *) "self",(char *) "dropTarget", NULL
36924 };
36925
36926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
36927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36928 if (!SWIG_IsOK(res1)) {
36929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
36930 }
36931 arg1 = reinterpret_cast< wxWindow * >(argp1);
36932 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
36933 if (!SWIG_IsOK(res2)) {
36934 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
36935 }
36936 {
36937 PyThreadState* __tstate = wxPyBeginAllowThreads();
36938 (arg1)->SetDropTarget(arg2);
36939 wxPyEndAllowThreads(__tstate);
36940 if (PyErr_Occurred()) SWIG_fail;
36941 }
36942 resultobj = SWIG_Py_Void();
36943 return resultobj;
36944 fail:
36945 return NULL;
36946 }
36947
36948
36949 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36950 PyObject *resultobj = 0;
36951 wxWindow *arg1 = (wxWindow *) 0 ;
36952 wxPyDropTarget *result = 0 ;
36953 void *argp1 = 0 ;
36954 int res1 = 0 ;
36955 PyObject *swig_obj[1] ;
36956
36957 if (!args) SWIG_fail;
36958 swig_obj[0] = args;
36959 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36960 if (!SWIG_IsOK(res1)) {
36961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
36962 }
36963 arg1 = reinterpret_cast< wxWindow * >(argp1);
36964 {
36965 PyThreadState* __tstate = wxPyBeginAllowThreads();
36966 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
36967 wxPyEndAllowThreads(__tstate);
36968 if (PyErr_Occurred()) SWIG_fail;
36969 }
36970 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
36971 return resultobj;
36972 fail:
36973 return NULL;
36974 }
36975
36976
36977 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36978 PyObject *resultobj = 0;
36979 wxWindow *arg1 = (wxWindow *) 0 ;
36980 bool arg2 ;
36981 void *argp1 = 0 ;
36982 int res1 = 0 ;
36983 bool val2 ;
36984 int ecode2 = 0 ;
36985 PyObject * obj0 = 0 ;
36986 PyObject * obj1 = 0 ;
36987 char * kwnames[] = {
36988 (char *) "self",(char *) "accept", NULL
36989 };
36990
36991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
36992 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36993 if (!SWIG_IsOK(res1)) {
36994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
36995 }
36996 arg1 = reinterpret_cast< wxWindow * >(argp1);
36997 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36998 if (!SWIG_IsOK(ecode2)) {
36999 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
37000 }
37001 arg2 = static_cast< bool >(val2);
37002 {
37003 PyThreadState* __tstate = wxPyBeginAllowThreads();
37004 wxWindow_DragAcceptFiles(arg1,arg2);
37005 wxPyEndAllowThreads(__tstate);
37006 if (PyErr_Occurred()) SWIG_fail;
37007 }
37008 resultobj = SWIG_Py_Void();
37009 return resultobj;
37010 fail:
37011 return NULL;
37012 }
37013
37014
37015 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37016 PyObject *resultobj = 0;
37017 wxWindow *arg1 = (wxWindow *) 0 ;
37018 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
37019 void *argp1 = 0 ;
37020 int res1 = 0 ;
37021 int res2 = 0 ;
37022 PyObject * obj0 = 0 ;
37023 PyObject * obj1 = 0 ;
37024 char * kwnames[] = {
37025 (char *) "self",(char *) "constraints", NULL
37026 };
37027
37028 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
37029 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37030 if (!SWIG_IsOK(res1)) {
37031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
37032 }
37033 arg1 = reinterpret_cast< wxWindow * >(argp1);
37034 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
37035 if (!SWIG_IsOK(res2)) {
37036 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
37037 }
37038 {
37039 PyThreadState* __tstate = wxPyBeginAllowThreads();
37040 (arg1)->SetConstraints(arg2);
37041 wxPyEndAllowThreads(__tstate);
37042 if (PyErr_Occurred()) SWIG_fail;
37043 }
37044 resultobj = SWIG_Py_Void();
37045 return resultobj;
37046 fail:
37047 return NULL;
37048 }
37049
37050
37051 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37052 PyObject *resultobj = 0;
37053 wxWindow *arg1 = (wxWindow *) 0 ;
37054 wxLayoutConstraints *result = 0 ;
37055 void *argp1 = 0 ;
37056 int res1 = 0 ;
37057 PyObject *swig_obj[1] ;
37058
37059 if (!args) SWIG_fail;
37060 swig_obj[0] = args;
37061 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37062 if (!SWIG_IsOK(res1)) {
37063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
37064 }
37065 arg1 = reinterpret_cast< wxWindow * >(argp1);
37066 {
37067 PyThreadState* __tstate = wxPyBeginAllowThreads();
37068 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
37069 wxPyEndAllowThreads(__tstate);
37070 if (PyErr_Occurred()) SWIG_fail;
37071 }
37072 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
37073 return resultobj;
37074 fail:
37075 return NULL;
37076 }
37077
37078
37079 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37080 PyObject *resultobj = 0;
37081 wxWindow *arg1 = (wxWindow *) 0 ;
37082 bool arg2 ;
37083 void *argp1 = 0 ;
37084 int res1 = 0 ;
37085 bool val2 ;
37086 int ecode2 = 0 ;
37087 PyObject * obj0 = 0 ;
37088 PyObject * obj1 = 0 ;
37089 char * kwnames[] = {
37090 (char *) "self",(char *) "autoLayout", NULL
37091 };
37092
37093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
37094 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37095 if (!SWIG_IsOK(res1)) {
37096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
37097 }
37098 arg1 = reinterpret_cast< wxWindow * >(argp1);
37099 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37100 if (!SWIG_IsOK(ecode2)) {
37101 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
37102 }
37103 arg2 = static_cast< bool >(val2);
37104 {
37105 PyThreadState* __tstate = wxPyBeginAllowThreads();
37106 (arg1)->SetAutoLayout(arg2);
37107 wxPyEndAllowThreads(__tstate);
37108 if (PyErr_Occurred()) SWIG_fail;
37109 }
37110 resultobj = SWIG_Py_Void();
37111 return resultobj;
37112 fail:
37113 return NULL;
37114 }
37115
37116
37117 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37118 PyObject *resultobj = 0;
37119 wxWindow *arg1 = (wxWindow *) 0 ;
37120 bool result;
37121 void *argp1 = 0 ;
37122 int res1 = 0 ;
37123 PyObject *swig_obj[1] ;
37124
37125 if (!args) SWIG_fail;
37126 swig_obj[0] = args;
37127 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37128 if (!SWIG_IsOK(res1)) {
37129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
37130 }
37131 arg1 = reinterpret_cast< wxWindow * >(argp1);
37132 {
37133 PyThreadState* __tstate = wxPyBeginAllowThreads();
37134 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
37135 wxPyEndAllowThreads(__tstate);
37136 if (PyErr_Occurred()) SWIG_fail;
37137 }
37138 {
37139 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37140 }
37141 return resultobj;
37142 fail:
37143 return NULL;
37144 }
37145
37146
37147 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37148 PyObject *resultobj = 0;
37149 wxWindow *arg1 = (wxWindow *) 0 ;
37150 bool result;
37151 void *argp1 = 0 ;
37152 int res1 = 0 ;
37153 PyObject *swig_obj[1] ;
37154
37155 if (!args) SWIG_fail;
37156 swig_obj[0] = args;
37157 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37158 if (!SWIG_IsOK(res1)) {
37159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
37160 }
37161 arg1 = reinterpret_cast< wxWindow * >(argp1);
37162 {
37163 PyThreadState* __tstate = wxPyBeginAllowThreads();
37164 result = (bool)(arg1)->Layout();
37165 wxPyEndAllowThreads(__tstate);
37166 if (PyErr_Occurred()) SWIG_fail;
37167 }
37168 {
37169 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37170 }
37171 return resultobj;
37172 fail:
37173 return NULL;
37174 }
37175
37176
37177 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37178 PyObject *resultobj = 0;
37179 wxWindow *arg1 = (wxWindow *) 0 ;
37180 wxSizer *arg2 = (wxSizer *) 0 ;
37181 bool arg3 = (bool) true ;
37182 void *argp1 = 0 ;
37183 int res1 = 0 ;
37184 int res2 = 0 ;
37185 bool val3 ;
37186 int ecode3 = 0 ;
37187 PyObject * obj0 = 0 ;
37188 PyObject * obj1 = 0 ;
37189 PyObject * obj2 = 0 ;
37190 char * kwnames[] = {
37191 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37192 };
37193
37194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37195 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37196 if (!SWIG_IsOK(res1)) {
37197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37198 }
37199 arg1 = reinterpret_cast< wxWindow * >(argp1);
37200 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37201 if (!SWIG_IsOK(res2)) {
37202 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37203 }
37204 if (obj2) {
37205 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37206 if (!SWIG_IsOK(ecode3)) {
37207 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
37208 }
37209 arg3 = static_cast< bool >(val3);
37210 }
37211 {
37212 PyThreadState* __tstate = wxPyBeginAllowThreads();
37213 (arg1)->SetSizer(arg2,arg3);
37214 wxPyEndAllowThreads(__tstate);
37215 if (PyErr_Occurred()) SWIG_fail;
37216 }
37217 resultobj = SWIG_Py_Void();
37218 return resultobj;
37219 fail:
37220 return NULL;
37221 }
37222
37223
37224 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37225 PyObject *resultobj = 0;
37226 wxWindow *arg1 = (wxWindow *) 0 ;
37227 wxSizer *arg2 = (wxSizer *) 0 ;
37228 bool arg3 = (bool) true ;
37229 void *argp1 = 0 ;
37230 int res1 = 0 ;
37231 int res2 = 0 ;
37232 bool val3 ;
37233 int ecode3 = 0 ;
37234 PyObject * obj0 = 0 ;
37235 PyObject * obj1 = 0 ;
37236 PyObject * obj2 = 0 ;
37237 char * kwnames[] = {
37238 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37239 };
37240
37241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37243 if (!SWIG_IsOK(res1)) {
37244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
37245 }
37246 arg1 = reinterpret_cast< wxWindow * >(argp1);
37247 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37248 if (!SWIG_IsOK(res2)) {
37249 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
37250 }
37251 if (obj2) {
37252 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37253 if (!SWIG_IsOK(ecode3)) {
37254 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
37255 }
37256 arg3 = static_cast< bool >(val3);
37257 }
37258 {
37259 PyThreadState* __tstate = wxPyBeginAllowThreads();
37260 (arg1)->SetSizerAndFit(arg2,arg3);
37261 wxPyEndAllowThreads(__tstate);
37262 if (PyErr_Occurred()) SWIG_fail;
37263 }
37264 resultobj = SWIG_Py_Void();
37265 return resultobj;
37266 fail:
37267 return NULL;
37268 }
37269
37270
37271 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37272 PyObject *resultobj = 0;
37273 wxWindow *arg1 = (wxWindow *) 0 ;
37274 wxSizer *result = 0 ;
37275 void *argp1 = 0 ;
37276 int res1 = 0 ;
37277 PyObject *swig_obj[1] ;
37278
37279 if (!args) SWIG_fail;
37280 swig_obj[0] = args;
37281 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37282 if (!SWIG_IsOK(res1)) {
37283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37284 }
37285 arg1 = reinterpret_cast< wxWindow * >(argp1);
37286 {
37287 PyThreadState* __tstate = wxPyBeginAllowThreads();
37288 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
37289 wxPyEndAllowThreads(__tstate);
37290 if (PyErr_Occurred()) SWIG_fail;
37291 }
37292 {
37293 resultobj = wxPyMake_wxObject(result, (bool)0);
37294 }
37295 return resultobj;
37296 fail:
37297 return NULL;
37298 }
37299
37300
37301 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37302 PyObject *resultobj = 0;
37303 wxWindow *arg1 = (wxWindow *) 0 ;
37304 wxSizer *arg2 = (wxSizer *) 0 ;
37305 void *argp1 = 0 ;
37306 int res1 = 0 ;
37307 void *argp2 = 0 ;
37308 int res2 = 0 ;
37309 PyObject * obj0 = 0 ;
37310 PyObject * obj1 = 0 ;
37311 char * kwnames[] = {
37312 (char *) "self",(char *) "sizer", NULL
37313 };
37314
37315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
37316 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37317 if (!SWIG_IsOK(res1)) {
37318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37319 }
37320 arg1 = reinterpret_cast< wxWindow * >(argp1);
37321 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
37322 if (!SWIG_IsOK(res2)) {
37323 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37324 }
37325 arg2 = reinterpret_cast< wxSizer * >(argp2);
37326 {
37327 PyThreadState* __tstate = wxPyBeginAllowThreads();
37328 (arg1)->SetContainingSizer(arg2);
37329 wxPyEndAllowThreads(__tstate);
37330 if (PyErr_Occurred()) SWIG_fail;
37331 }
37332 resultobj = SWIG_Py_Void();
37333 return resultobj;
37334 fail:
37335 return NULL;
37336 }
37337
37338
37339 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37340 PyObject *resultobj = 0;
37341 wxWindow *arg1 = (wxWindow *) 0 ;
37342 wxSizer *result = 0 ;
37343 void *argp1 = 0 ;
37344 int res1 = 0 ;
37345 PyObject *swig_obj[1] ;
37346
37347 if (!args) SWIG_fail;
37348 swig_obj[0] = args;
37349 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37350 if (!SWIG_IsOK(res1)) {
37351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37352 }
37353 arg1 = reinterpret_cast< wxWindow * >(argp1);
37354 {
37355 PyThreadState* __tstate = wxPyBeginAllowThreads();
37356 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
37357 wxPyEndAllowThreads(__tstate);
37358 if (PyErr_Occurred()) SWIG_fail;
37359 }
37360 {
37361 resultobj = wxPyMake_wxObject(result, (bool)0);
37362 }
37363 return resultobj;
37364 fail:
37365 return NULL;
37366 }
37367
37368
37369 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37370 PyObject *resultobj = 0;
37371 wxWindow *arg1 = (wxWindow *) 0 ;
37372 void *argp1 = 0 ;
37373 int res1 = 0 ;
37374 PyObject *swig_obj[1] ;
37375
37376 if (!args) SWIG_fail;
37377 swig_obj[0] = args;
37378 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37379 if (!SWIG_IsOK(res1)) {
37380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
37381 }
37382 arg1 = reinterpret_cast< wxWindow * >(argp1);
37383 {
37384 PyThreadState* __tstate = wxPyBeginAllowThreads();
37385 (arg1)->InheritAttributes();
37386 wxPyEndAllowThreads(__tstate);
37387 if (PyErr_Occurred()) SWIG_fail;
37388 }
37389 resultobj = SWIG_Py_Void();
37390 return resultobj;
37391 fail:
37392 return NULL;
37393 }
37394
37395
37396 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37397 PyObject *resultobj = 0;
37398 wxWindow *arg1 = (wxWindow *) 0 ;
37399 bool result;
37400 void *argp1 = 0 ;
37401 int res1 = 0 ;
37402 PyObject *swig_obj[1] ;
37403
37404 if (!args) SWIG_fail;
37405 swig_obj[0] = args;
37406 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37407 if (!SWIG_IsOK(res1)) {
37408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
37409 }
37410 arg1 = reinterpret_cast< wxWindow * >(argp1);
37411 {
37412 PyThreadState* __tstate = wxPyBeginAllowThreads();
37413 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
37414 wxPyEndAllowThreads(__tstate);
37415 if (PyErr_Occurred()) SWIG_fail;
37416 }
37417 {
37418 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37419 }
37420 return resultobj;
37421 fail:
37422 return NULL;
37423 }
37424
37425
37426 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37427 PyObject *obj;
37428 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37429 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
37430 return SWIG_Py_Void();
37431 }
37432
37433 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37434 return SWIG_Python_InitShadowInstance(args);
37435 }
37436
37437 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37438 PyObject *resultobj = 0;
37439 long arg1 ;
37440 wxWindow *arg2 = (wxWindow *) NULL ;
37441 wxWindow *result = 0 ;
37442 long val1 ;
37443 int ecode1 = 0 ;
37444 void *argp2 = 0 ;
37445 int res2 = 0 ;
37446 PyObject * obj0 = 0 ;
37447 PyObject * obj1 = 0 ;
37448 char * kwnames[] = {
37449 (char *) "id",(char *) "parent", NULL
37450 };
37451
37452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
37453 ecode1 = SWIG_AsVal_long(obj0, &val1);
37454 if (!SWIG_IsOK(ecode1)) {
37455 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
37456 }
37457 arg1 = static_cast< long >(val1);
37458 if (obj1) {
37459 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37460 if (!SWIG_IsOK(res2)) {
37461 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
37462 }
37463 arg2 = reinterpret_cast< wxWindow * >(argp2);
37464 }
37465 {
37466 if (!wxPyCheckForApp()) SWIG_fail;
37467 PyThreadState* __tstate = wxPyBeginAllowThreads();
37468 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
37469 wxPyEndAllowThreads(__tstate);
37470 if (PyErr_Occurred()) SWIG_fail;
37471 }
37472 {
37473 resultobj = wxPyMake_wxObject(result, 0);
37474 }
37475 return resultobj;
37476 fail:
37477 return NULL;
37478 }
37479
37480
37481 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37482 PyObject *resultobj = 0;
37483 wxString *arg1 = 0 ;
37484 wxWindow *arg2 = (wxWindow *) NULL ;
37485 wxWindow *result = 0 ;
37486 bool temp1 = false ;
37487 void *argp2 = 0 ;
37488 int res2 = 0 ;
37489 PyObject * obj0 = 0 ;
37490 PyObject * obj1 = 0 ;
37491 char * kwnames[] = {
37492 (char *) "name",(char *) "parent", NULL
37493 };
37494
37495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
37496 {
37497 arg1 = wxString_in_helper(obj0);
37498 if (arg1 == NULL) SWIG_fail;
37499 temp1 = true;
37500 }
37501 if (obj1) {
37502 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37503 if (!SWIG_IsOK(res2)) {
37504 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
37505 }
37506 arg2 = reinterpret_cast< wxWindow * >(argp2);
37507 }
37508 {
37509 if (!wxPyCheckForApp()) SWIG_fail;
37510 PyThreadState* __tstate = wxPyBeginAllowThreads();
37511 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
37512 wxPyEndAllowThreads(__tstate);
37513 if (PyErr_Occurred()) SWIG_fail;
37514 }
37515 {
37516 resultobj = wxPyMake_wxObject(result, 0);
37517 }
37518 {
37519 if (temp1)
37520 delete arg1;
37521 }
37522 return resultobj;
37523 fail:
37524 {
37525 if (temp1)
37526 delete arg1;
37527 }
37528 return NULL;
37529 }
37530
37531
37532 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37533 PyObject *resultobj = 0;
37534 wxString *arg1 = 0 ;
37535 wxWindow *arg2 = (wxWindow *) NULL ;
37536 wxWindow *result = 0 ;
37537 bool temp1 = false ;
37538 void *argp2 = 0 ;
37539 int res2 = 0 ;
37540 PyObject * obj0 = 0 ;
37541 PyObject * obj1 = 0 ;
37542 char * kwnames[] = {
37543 (char *) "label",(char *) "parent", NULL
37544 };
37545
37546 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
37547 {
37548 arg1 = wxString_in_helper(obj0);
37549 if (arg1 == NULL) SWIG_fail;
37550 temp1 = true;
37551 }
37552 if (obj1) {
37553 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37554 if (!SWIG_IsOK(res2)) {
37555 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
37556 }
37557 arg2 = reinterpret_cast< wxWindow * >(argp2);
37558 }
37559 {
37560 if (!wxPyCheckForApp()) SWIG_fail;
37561 PyThreadState* __tstate = wxPyBeginAllowThreads();
37562 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
37563 wxPyEndAllowThreads(__tstate);
37564 if (PyErr_Occurred()) SWIG_fail;
37565 }
37566 {
37567 resultobj = wxPyMake_wxObject(result, 0);
37568 }
37569 {
37570 if (temp1)
37571 delete arg1;
37572 }
37573 return resultobj;
37574 fail:
37575 {
37576 if (temp1)
37577 delete arg1;
37578 }
37579 return NULL;
37580 }
37581
37582
37583 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37584 PyObject *resultobj = 0;
37585 wxWindow *arg1 = (wxWindow *) 0 ;
37586 unsigned long arg2 ;
37587 wxWindow *result = 0 ;
37588 void *argp1 = 0 ;
37589 int res1 = 0 ;
37590 unsigned long val2 ;
37591 int ecode2 = 0 ;
37592 PyObject * obj0 = 0 ;
37593 PyObject * obj1 = 0 ;
37594 char * kwnames[] = {
37595 (char *) "parent",(char *) "_hWnd", NULL
37596 };
37597
37598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
37599 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37600 if (!SWIG_IsOK(res1)) {
37601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
37602 }
37603 arg1 = reinterpret_cast< wxWindow * >(argp1);
37604 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
37605 if (!SWIG_IsOK(ecode2)) {
37606 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
37607 }
37608 arg2 = static_cast< unsigned long >(val2);
37609 {
37610 PyThreadState* __tstate = wxPyBeginAllowThreads();
37611 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
37612 wxPyEndAllowThreads(__tstate);
37613 if (PyErr_Occurred()) SWIG_fail;
37614 }
37615 {
37616 resultobj = wxPyMake_wxObject(result, 0);
37617 }
37618 return resultobj;
37619 fail:
37620 return NULL;
37621 }
37622
37623
37624 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37625 PyObject *resultobj = 0;
37626 PyObject *result = 0 ;
37627
37628 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
37629 {
37630 PyThreadState* __tstate = wxPyBeginAllowThreads();
37631 result = (PyObject *)GetTopLevelWindows();
37632 wxPyEndAllowThreads(__tstate);
37633 if (PyErr_Occurred()) SWIG_fail;
37634 }
37635 resultobj = result;
37636 return resultobj;
37637 fail:
37638 return NULL;
37639 }
37640
37641
37642 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37643 PyObject *resultobj = 0;
37644 wxValidator *result = 0 ;
37645
37646 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
37647 {
37648 PyThreadState* __tstate = wxPyBeginAllowThreads();
37649 result = (wxValidator *)new wxValidator();
37650 wxPyEndAllowThreads(__tstate);
37651 if (PyErr_Occurred()) SWIG_fail;
37652 }
37653 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
37654 return resultobj;
37655 fail:
37656 return NULL;
37657 }
37658
37659
37660 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37661 PyObject *resultobj = 0;
37662 wxValidator *arg1 = (wxValidator *) 0 ;
37663 wxValidator *result = 0 ;
37664 void *argp1 = 0 ;
37665 int res1 = 0 ;
37666 PyObject *swig_obj[1] ;
37667
37668 if (!args) SWIG_fail;
37669 swig_obj[0] = args;
37670 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37671 if (!SWIG_IsOK(res1)) {
37672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
37673 }
37674 arg1 = reinterpret_cast< wxValidator * >(argp1);
37675 {
37676 PyThreadState* __tstate = wxPyBeginAllowThreads();
37677 result = (wxValidator *)(arg1)->Clone();
37678 wxPyEndAllowThreads(__tstate);
37679 if (PyErr_Occurred()) SWIG_fail;
37680 }
37681 {
37682 resultobj = wxPyMake_wxObject(result, 0);
37683 }
37684 return resultobj;
37685 fail:
37686 return NULL;
37687 }
37688
37689
37690 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37691 PyObject *resultobj = 0;
37692 wxValidator *arg1 = (wxValidator *) 0 ;
37693 wxWindow *arg2 = (wxWindow *) 0 ;
37694 bool result;
37695 void *argp1 = 0 ;
37696 int res1 = 0 ;
37697 void *argp2 = 0 ;
37698 int res2 = 0 ;
37699 PyObject * obj0 = 0 ;
37700 PyObject * obj1 = 0 ;
37701 char * kwnames[] = {
37702 (char *) "self",(char *) "parent", NULL
37703 };
37704
37705 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
37706 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37707 if (!SWIG_IsOK(res1)) {
37708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
37709 }
37710 arg1 = reinterpret_cast< wxValidator * >(argp1);
37711 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37712 if (!SWIG_IsOK(res2)) {
37713 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
37714 }
37715 arg2 = reinterpret_cast< wxWindow * >(argp2);
37716 {
37717 PyThreadState* __tstate = wxPyBeginAllowThreads();
37718 result = (bool)(arg1)->Validate(arg2);
37719 wxPyEndAllowThreads(__tstate);
37720 if (PyErr_Occurred()) SWIG_fail;
37721 }
37722 {
37723 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37724 }
37725 return resultobj;
37726 fail:
37727 return NULL;
37728 }
37729
37730
37731 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37732 PyObject *resultobj = 0;
37733 wxValidator *arg1 = (wxValidator *) 0 ;
37734 bool result;
37735 void *argp1 = 0 ;
37736 int res1 = 0 ;
37737 PyObject *swig_obj[1] ;
37738
37739 if (!args) SWIG_fail;
37740 swig_obj[0] = args;
37741 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37742 if (!SWIG_IsOK(res1)) {
37743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37744 }
37745 arg1 = reinterpret_cast< wxValidator * >(argp1);
37746 {
37747 PyThreadState* __tstate = wxPyBeginAllowThreads();
37748 result = (bool)(arg1)->TransferToWindow();
37749 wxPyEndAllowThreads(__tstate);
37750 if (PyErr_Occurred()) SWIG_fail;
37751 }
37752 {
37753 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37754 }
37755 return resultobj;
37756 fail:
37757 return NULL;
37758 }
37759
37760
37761 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37762 PyObject *resultobj = 0;
37763 wxValidator *arg1 = (wxValidator *) 0 ;
37764 bool result;
37765 void *argp1 = 0 ;
37766 int res1 = 0 ;
37767 PyObject *swig_obj[1] ;
37768
37769 if (!args) SWIG_fail;
37770 swig_obj[0] = args;
37771 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37772 if (!SWIG_IsOK(res1)) {
37773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37774 }
37775 arg1 = reinterpret_cast< wxValidator * >(argp1);
37776 {
37777 PyThreadState* __tstate = wxPyBeginAllowThreads();
37778 result = (bool)(arg1)->TransferFromWindow();
37779 wxPyEndAllowThreads(__tstate);
37780 if (PyErr_Occurred()) SWIG_fail;
37781 }
37782 {
37783 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37784 }
37785 return resultobj;
37786 fail:
37787 return NULL;
37788 }
37789
37790
37791 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37792 PyObject *resultobj = 0;
37793 wxValidator *arg1 = (wxValidator *) 0 ;
37794 wxWindow *result = 0 ;
37795 void *argp1 = 0 ;
37796 int res1 = 0 ;
37797 PyObject *swig_obj[1] ;
37798
37799 if (!args) SWIG_fail;
37800 swig_obj[0] = args;
37801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37802 if (!SWIG_IsOK(res1)) {
37803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37804 }
37805 arg1 = reinterpret_cast< wxValidator * >(argp1);
37806 {
37807 PyThreadState* __tstate = wxPyBeginAllowThreads();
37808 result = (wxWindow *)(arg1)->GetWindow();
37809 wxPyEndAllowThreads(__tstate);
37810 if (PyErr_Occurred()) SWIG_fail;
37811 }
37812 {
37813 resultobj = wxPyMake_wxObject(result, 0);
37814 }
37815 return resultobj;
37816 fail:
37817 return NULL;
37818 }
37819
37820
37821 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37822 PyObject *resultobj = 0;
37823 wxValidator *arg1 = (wxValidator *) 0 ;
37824 wxWindow *arg2 = (wxWindow *) 0 ;
37825 void *argp1 = 0 ;
37826 int res1 = 0 ;
37827 void *argp2 = 0 ;
37828 int res2 = 0 ;
37829 PyObject * obj0 = 0 ;
37830 PyObject * obj1 = 0 ;
37831 char * kwnames[] = {
37832 (char *) "self",(char *) "window", NULL
37833 };
37834
37835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
37836 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37837 if (!SWIG_IsOK(res1)) {
37838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37839 }
37840 arg1 = reinterpret_cast< wxValidator * >(argp1);
37841 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37842 if (!SWIG_IsOK(res2)) {
37843 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
37844 }
37845 arg2 = reinterpret_cast< wxWindow * >(argp2);
37846 {
37847 PyThreadState* __tstate = wxPyBeginAllowThreads();
37848 (arg1)->SetWindow(arg2);
37849 wxPyEndAllowThreads(__tstate);
37850 if (PyErr_Occurred()) SWIG_fail;
37851 }
37852 resultobj = SWIG_Py_Void();
37853 return resultobj;
37854 fail:
37855 return NULL;
37856 }
37857
37858
37859 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37860 PyObject *resultobj = 0;
37861 bool result;
37862
37863 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
37864 {
37865 PyThreadState* __tstate = wxPyBeginAllowThreads();
37866 result = (bool)wxValidator::IsSilent();
37867 wxPyEndAllowThreads(__tstate);
37868 if (PyErr_Occurred()) SWIG_fail;
37869 }
37870 {
37871 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37872 }
37873 return resultobj;
37874 fail:
37875 return NULL;
37876 }
37877
37878
37879 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37880 PyObject *resultobj = 0;
37881 int arg1 = (int) true ;
37882 int val1 ;
37883 int ecode1 = 0 ;
37884 PyObject * obj0 = 0 ;
37885 char * kwnames[] = {
37886 (char *) "doIt", NULL
37887 };
37888
37889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
37890 if (obj0) {
37891 ecode1 = SWIG_AsVal_int(obj0, &val1);
37892 if (!SWIG_IsOK(ecode1)) {
37893 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
37894 }
37895 arg1 = static_cast< int >(val1);
37896 }
37897 {
37898 PyThreadState* __tstate = wxPyBeginAllowThreads();
37899 wxValidator::SetBellOnError(arg1);
37900 wxPyEndAllowThreads(__tstate);
37901 if (PyErr_Occurred()) SWIG_fail;
37902 }
37903 resultobj = SWIG_Py_Void();
37904 return resultobj;
37905 fail:
37906 return NULL;
37907 }
37908
37909
37910 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37911 PyObject *obj;
37912 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37913 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
37914 return SWIG_Py_Void();
37915 }
37916
37917 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37918 return SWIG_Python_InitShadowInstance(args);
37919 }
37920
37921 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37922 PyObject *resultobj = 0;
37923 wxPyValidator *result = 0 ;
37924
37925 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
37926 {
37927 PyThreadState* __tstate = wxPyBeginAllowThreads();
37928 result = (wxPyValidator *)new wxPyValidator();
37929 wxPyEndAllowThreads(__tstate);
37930 if (PyErr_Occurred()) SWIG_fail;
37931 }
37932 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
37933 return resultobj;
37934 fail:
37935 return NULL;
37936 }
37937
37938
37939 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37940 PyObject *resultobj = 0;
37941 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
37942 PyObject *arg2 = (PyObject *) 0 ;
37943 PyObject *arg3 = (PyObject *) 0 ;
37944 int arg4 = (int) true ;
37945 void *argp1 = 0 ;
37946 int res1 = 0 ;
37947 int val4 ;
37948 int ecode4 = 0 ;
37949 PyObject * obj0 = 0 ;
37950 PyObject * obj1 = 0 ;
37951 PyObject * obj2 = 0 ;
37952 PyObject * obj3 = 0 ;
37953 char * kwnames[] = {
37954 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
37955 };
37956
37957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37958 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
37959 if (!SWIG_IsOK(res1)) {
37960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
37961 }
37962 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
37963 arg2 = obj1;
37964 arg3 = obj2;
37965 if (obj3) {
37966 ecode4 = SWIG_AsVal_int(obj3, &val4);
37967 if (!SWIG_IsOK(ecode4)) {
37968 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
37969 }
37970 arg4 = static_cast< int >(val4);
37971 }
37972 {
37973 PyThreadState* __tstate = wxPyBeginAllowThreads();
37974 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
37975 wxPyEndAllowThreads(__tstate);
37976 if (PyErr_Occurred()) SWIG_fail;
37977 }
37978 resultobj = SWIG_Py_Void();
37979 return resultobj;
37980 fail:
37981 return NULL;
37982 }
37983
37984
37985 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37986 PyObject *obj;
37987 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37988 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
37989 return SWIG_Py_Void();
37990 }
37991
37992 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37993 return SWIG_Python_InitShadowInstance(args);
37994 }
37995
37996 SWIGINTERN int DefaultValidator_set(PyObject *) {
37997 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
37998 return 1;
37999 }
38000
38001
38002 SWIGINTERN PyObject *DefaultValidator_get(void) {
38003 PyObject *pyobj = 0;
38004
38005 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
38006 return pyobj;
38007 }
38008
38009
38010 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38011 PyObject *resultobj = 0;
38012 wxString const &arg1_defvalue = wxPyEmptyString ;
38013 wxString *arg1 = (wxString *) &arg1_defvalue ;
38014 long arg2 = (long) 0 ;
38015 wxMenu *result = 0 ;
38016 bool temp1 = false ;
38017 long val2 ;
38018 int ecode2 = 0 ;
38019 PyObject * obj0 = 0 ;
38020 PyObject * obj1 = 0 ;
38021 char * kwnames[] = {
38022 (char *) "title",(char *) "style", NULL
38023 };
38024
38025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
38026 if (obj0) {
38027 {
38028 arg1 = wxString_in_helper(obj0);
38029 if (arg1 == NULL) SWIG_fail;
38030 temp1 = true;
38031 }
38032 }
38033 if (obj1) {
38034 ecode2 = SWIG_AsVal_long(obj1, &val2);
38035 if (!SWIG_IsOK(ecode2)) {
38036 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
38037 }
38038 arg2 = static_cast< long >(val2);
38039 }
38040 {
38041 if (!wxPyCheckForApp()) SWIG_fail;
38042 PyThreadState* __tstate = wxPyBeginAllowThreads();
38043 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
38044 wxPyEndAllowThreads(__tstate);
38045 if (PyErr_Occurred()) SWIG_fail;
38046 }
38047 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
38048 {
38049 if (temp1)
38050 delete arg1;
38051 }
38052 return resultobj;
38053 fail:
38054 {
38055 if (temp1)
38056 delete arg1;
38057 }
38058 return NULL;
38059 }
38060
38061
38062 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38063 PyObject *resultobj = 0;
38064 wxMenu *arg1 = (wxMenu *) 0 ;
38065 int arg2 ;
38066 wxString *arg3 = 0 ;
38067 wxString const &arg4_defvalue = wxPyEmptyString ;
38068 wxString *arg4 = (wxString *) &arg4_defvalue ;
38069 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
38070 wxMenuItem *result = 0 ;
38071 void *argp1 = 0 ;
38072 int res1 = 0 ;
38073 int val2 ;
38074 int ecode2 = 0 ;
38075 bool temp3 = false ;
38076 bool temp4 = false ;
38077 int val5 ;
38078 int ecode5 = 0 ;
38079 PyObject * obj0 = 0 ;
38080 PyObject * obj1 = 0 ;
38081 PyObject * obj2 = 0 ;
38082 PyObject * obj3 = 0 ;
38083 PyObject * obj4 = 0 ;
38084 char * kwnames[] = {
38085 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38086 };
38087
38088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38089 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38090 if (!SWIG_IsOK(res1)) {
38091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
38092 }
38093 arg1 = reinterpret_cast< wxMenu * >(argp1);
38094 ecode2 = SWIG_AsVal_int(obj1, &val2);
38095 if (!SWIG_IsOK(ecode2)) {
38096 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
38097 }
38098 arg2 = static_cast< int >(val2);
38099 {
38100 arg3 = wxString_in_helper(obj2);
38101 if (arg3 == NULL) SWIG_fail;
38102 temp3 = true;
38103 }
38104 if (obj3) {
38105 {
38106 arg4 = wxString_in_helper(obj3);
38107 if (arg4 == NULL) SWIG_fail;
38108 temp4 = true;
38109 }
38110 }
38111 if (obj4) {
38112 ecode5 = SWIG_AsVal_int(obj4, &val5);
38113 if (!SWIG_IsOK(ecode5)) {
38114 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
38115 }
38116 arg5 = static_cast< wxItemKind >(val5);
38117 }
38118 {
38119 PyThreadState* __tstate = wxPyBeginAllowThreads();
38120 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
38121 wxPyEndAllowThreads(__tstate);
38122 if (PyErr_Occurred()) SWIG_fail;
38123 }
38124 {
38125 resultobj = wxPyMake_wxObject(result, (bool)0);
38126 }
38127 {
38128 if (temp3)
38129 delete arg3;
38130 }
38131 {
38132 if (temp4)
38133 delete arg4;
38134 }
38135 return resultobj;
38136 fail:
38137 {
38138 if (temp3)
38139 delete arg3;
38140 }
38141 {
38142 if (temp4)
38143 delete arg4;
38144 }
38145 return NULL;
38146 }
38147
38148
38149 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38150 PyObject *resultobj = 0;
38151 wxMenu *arg1 = (wxMenu *) 0 ;
38152 wxMenuItem *result = 0 ;
38153 void *argp1 = 0 ;
38154 int res1 = 0 ;
38155 PyObject *swig_obj[1] ;
38156
38157 if (!args) SWIG_fail;
38158 swig_obj[0] = args;
38159 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38160 if (!SWIG_IsOK(res1)) {
38161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
38162 }
38163 arg1 = reinterpret_cast< wxMenu * >(argp1);
38164 {
38165 PyThreadState* __tstate = wxPyBeginAllowThreads();
38166 result = (wxMenuItem *)(arg1)->AppendSeparator();
38167 wxPyEndAllowThreads(__tstate);
38168 if (PyErr_Occurred()) SWIG_fail;
38169 }
38170 {
38171 resultobj = wxPyMake_wxObject(result, (bool)0);
38172 }
38173 return resultobj;
38174 fail:
38175 return NULL;
38176 }
38177
38178
38179 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38180 PyObject *resultobj = 0;
38181 wxMenu *arg1 = (wxMenu *) 0 ;
38182 int arg2 ;
38183 wxString *arg3 = 0 ;
38184 wxString const &arg4_defvalue = wxPyEmptyString ;
38185 wxString *arg4 = (wxString *) &arg4_defvalue ;
38186 wxMenuItem *result = 0 ;
38187 void *argp1 = 0 ;
38188 int res1 = 0 ;
38189 int val2 ;
38190 int ecode2 = 0 ;
38191 bool temp3 = false ;
38192 bool temp4 = false ;
38193 PyObject * obj0 = 0 ;
38194 PyObject * obj1 = 0 ;
38195 PyObject * obj2 = 0 ;
38196 PyObject * obj3 = 0 ;
38197 char * kwnames[] = {
38198 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38199 };
38200
38201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38203 if (!SWIG_IsOK(res1)) {
38204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38205 }
38206 arg1 = reinterpret_cast< wxMenu * >(argp1);
38207 ecode2 = SWIG_AsVal_int(obj1, &val2);
38208 if (!SWIG_IsOK(ecode2)) {
38209 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
38210 }
38211 arg2 = static_cast< int >(val2);
38212 {
38213 arg3 = wxString_in_helper(obj2);
38214 if (arg3 == NULL) SWIG_fail;
38215 temp3 = true;
38216 }
38217 if (obj3) {
38218 {
38219 arg4 = wxString_in_helper(obj3);
38220 if (arg4 == NULL) SWIG_fail;
38221 temp4 = true;
38222 }
38223 }
38224 {
38225 PyThreadState* __tstate = wxPyBeginAllowThreads();
38226 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38227 wxPyEndAllowThreads(__tstate);
38228 if (PyErr_Occurred()) SWIG_fail;
38229 }
38230 {
38231 resultobj = wxPyMake_wxObject(result, (bool)0);
38232 }
38233 {
38234 if (temp3)
38235 delete arg3;
38236 }
38237 {
38238 if (temp4)
38239 delete arg4;
38240 }
38241 return resultobj;
38242 fail:
38243 {
38244 if (temp3)
38245 delete arg3;
38246 }
38247 {
38248 if (temp4)
38249 delete arg4;
38250 }
38251 return NULL;
38252 }
38253
38254
38255 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38256 PyObject *resultobj = 0;
38257 wxMenu *arg1 = (wxMenu *) 0 ;
38258 int arg2 ;
38259 wxString *arg3 = 0 ;
38260 wxString const &arg4_defvalue = wxPyEmptyString ;
38261 wxString *arg4 = (wxString *) &arg4_defvalue ;
38262 wxMenuItem *result = 0 ;
38263 void *argp1 = 0 ;
38264 int res1 = 0 ;
38265 int val2 ;
38266 int ecode2 = 0 ;
38267 bool temp3 = false ;
38268 bool temp4 = false ;
38269 PyObject * obj0 = 0 ;
38270 PyObject * obj1 = 0 ;
38271 PyObject * obj2 = 0 ;
38272 PyObject * obj3 = 0 ;
38273 char * kwnames[] = {
38274 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38275 };
38276
38277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38278 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38279 if (!SWIG_IsOK(res1)) {
38280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38281 }
38282 arg1 = reinterpret_cast< wxMenu * >(argp1);
38283 ecode2 = SWIG_AsVal_int(obj1, &val2);
38284 if (!SWIG_IsOK(ecode2)) {
38285 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
38286 }
38287 arg2 = static_cast< int >(val2);
38288 {
38289 arg3 = wxString_in_helper(obj2);
38290 if (arg3 == NULL) SWIG_fail;
38291 temp3 = true;
38292 }
38293 if (obj3) {
38294 {
38295 arg4 = wxString_in_helper(obj3);
38296 if (arg4 == NULL) SWIG_fail;
38297 temp4 = true;
38298 }
38299 }
38300 {
38301 PyThreadState* __tstate = wxPyBeginAllowThreads();
38302 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38303 wxPyEndAllowThreads(__tstate);
38304 if (PyErr_Occurred()) SWIG_fail;
38305 }
38306 {
38307 resultobj = wxPyMake_wxObject(result, (bool)0);
38308 }
38309 {
38310 if (temp3)
38311 delete arg3;
38312 }
38313 {
38314 if (temp4)
38315 delete arg4;
38316 }
38317 return resultobj;
38318 fail:
38319 {
38320 if (temp3)
38321 delete arg3;
38322 }
38323 {
38324 if (temp4)
38325 delete arg4;
38326 }
38327 return NULL;
38328 }
38329
38330
38331 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38332 PyObject *resultobj = 0;
38333 wxMenu *arg1 = (wxMenu *) 0 ;
38334 int arg2 ;
38335 wxString *arg3 = 0 ;
38336 wxMenu *arg4 = (wxMenu *) 0 ;
38337 wxString const &arg5_defvalue = wxPyEmptyString ;
38338 wxString *arg5 = (wxString *) &arg5_defvalue ;
38339 wxMenuItem *result = 0 ;
38340 void *argp1 = 0 ;
38341 int res1 = 0 ;
38342 int val2 ;
38343 int ecode2 = 0 ;
38344 bool temp3 = false ;
38345 void *argp4 = 0 ;
38346 int res4 = 0 ;
38347 bool temp5 = false ;
38348 PyObject * obj0 = 0 ;
38349 PyObject * obj1 = 0 ;
38350 PyObject * obj2 = 0 ;
38351 PyObject * obj3 = 0 ;
38352 PyObject * obj4 = 0 ;
38353 char * kwnames[] = {
38354 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
38355 };
38356
38357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38358 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38359 if (!SWIG_IsOK(res1)) {
38360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38361 }
38362 arg1 = reinterpret_cast< wxMenu * >(argp1);
38363 ecode2 = SWIG_AsVal_int(obj1, &val2);
38364 if (!SWIG_IsOK(ecode2)) {
38365 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
38366 }
38367 arg2 = static_cast< int >(val2);
38368 {
38369 arg3 = wxString_in_helper(obj2);
38370 if (arg3 == NULL) SWIG_fail;
38371 temp3 = true;
38372 }
38373 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
38374 if (!SWIG_IsOK(res4)) {
38375 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
38376 }
38377 arg4 = reinterpret_cast< wxMenu * >(argp4);
38378 if (obj4) {
38379 {
38380 arg5 = wxString_in_helper(obj4);
38381 if (arg5 == NULL) SWIG_fail;
38382 temp5 = true;
38383 }
38384 }
38385 {
38386 PyThreadState* __tstate = wxPyBeginAllowThreads();
38387 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
38388 wxPyEndAllowThreads(__tstate);
38389 if (PyErr_Occurred()) SWIG_fail;
38390 }
38391 {
38392 resultobj = wxPyMake_wxObject(result, (bool)0);
38393 }
38394 {
38395 if (temp3)
38396 delete arg3;
38397 }
38398 {
38399 if (temp5)
38400 delete arg5;
38401 }
38402 return resultobj;
38403 fail:
38404 {
38405 if (temp3)
38406 delete arg3;
38407 }
38408 {
38409 if (temp5)
38410 delete arg5;
38411 }
38412 return NULL;
38413 }
38414
38415
38416 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38417 PyObject *resultobj = 0;
38418 wxMenu *arg1 = (wxMenu *) 0 ;
38419 wxMenu *arg2 = (wxMenu *) 0 ;
38420 wxString *arg3 = 0 ;
38421 wxString const &arg4_defvalue = wxPyEmptyString ;
38422 wxString *arg4 = (wxString *) &arg4_defvalue ;
38423 wxMenuItem *result = 0 ;
38424 void *argp1 = 0 ;
38425 int res1 = 0 ;
38426 void *argp2 = 0 ;
38427 int res2 = 0 ;
38428 bool temp3 = false ;
38429 bool temp4 = false ;
38430 PyObject * obj0 = 0 ;
38431 PyObject * obj1 = 0 ;
38432 PyObject * obj2 = 0 ;
38433 PyObject * obj3 = 0 ;
38434 char * kwnames[] = {
38435 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
38436 };
38437
38438 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38439 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38440 if (!SWIG_IsOK(res1)) {
38441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38442 }
38443 arg1 = reinterpret_cast< wxMenu * >(argp1);
38444 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
38445 if (!SWIG_IsOK(res2)) {
38446 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
38447 }
38448 arg2 = reinterpret_cast< wxMenu * >(argp2);
38449 {
38450 arg3 = wxString_in_helper(obj2);
38451 if (arg3 == NULL) SWIG_fail;
38452 temp3 = true;
38453 }
38454 if (obj3) {
38455 {
38456 arg4 = wxString_in_helper(obj3);
38457 if (arg4 == NULL) SWIG_fail;
38458 temp4 = true;
38459 }
38460 }
38461 {
38462 PyThreadState* __tstate = wxPyBeginAllowThreads();
38463 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38464 wxPyEndAllowThreads(__tstate);
38465 if (PyErr_Occurred()) SWIG_fail;
38466 }
38467 {
38468 resultobj = wxPyMake_wxObject(result, (bool)0);
38469 }
38470 {
38471 if (temp3)
38472 delete arg3;
38473 }
38474 {
38475 if (temp4)
38476 delete arg4;
38477 }
38478 return resultobj;
38479 fail:
38480 {
38481 if (temp3)
38482 delete arg3;
38483 }
38484 {
38485 if (temp4)
38486 delete arg4;
38487 }
38488 return NULL;
38489 }
38490
38491
38492 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38493 PyObject *resultobj = 0;
38494 wxMenu *arg1 = (wxMenu *) 0 ;
38495 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38496 wxMenuItem *result = 0 ;
38497 void *argp1 = 0 ;
38498 int res1 = 0 ;
38499 int res2 = 0 ;
38500 PyObject * obj0 = 0 ;
38501 PyObject * obj1 = 0 ;
38502 char * kwnames[] = {
38503 (char *) "self",(char *) "item", NULL
38504 };
38505
38506 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
38507 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38508 if (!SWIG_IsOK(res1)) {
38509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38510 }
38511 arg1 = reinterpret_cast< wxMenu * >(argp1);
38512 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38513 if (!SWIG_IsOK(res2)) {
38514 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
38515 }
38516 {
38517 PyThreadState* __tstate = wxPyBeginAllowThreads();
38518 result = (wxMenuItem *)(arg1)->Append(arg2);
38519 wxPyEndAllowThreads(__tstate);
38520 if (PyErr_Occurred()) SWIG_fail;
38521 }
38522 {
38523 resultobj = wxPyMake_wxObject(result, (bool)0);
38524 }
38525 return resultobj;
38526 fail:
38527 return NULL;
38528 }
38529
38530
38531 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38532 PyObject *resultobj = 0;
38533 wxMenu *arg1 = (wxMenu *) 0 ;
38534 size_t arg2 ;
38535 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
38536 wxMenuItem *result = 0 ;
38537 void *argp1 = 0 ;
38538 int res1 = 0 ;
38539 size_t val2 ;
38540 int ecode2 = 0 ;
38541 int res3 = 0 ;
38542 PyObject * obj0 = 0 ;
38543 PyObject * obj1 = 0 ;
38544 PyObject * obj2 = 0 ;
38545 char * kwnames[] = {
38546 (char *) "self",(char *) "pos",(char *) "item", NULL
38547 };
38548
38549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38550 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38551 if (!SWIG_IsOK(res1)) {
38552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38553 }
38554 arg1 = reinterpret_cast< wxMenu * >(argp1);
38555 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38556 if (!SWIG_IsOK(ecode2)) {
38557 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
38558 }
38559 arg2 = static_cast< size_t >(val2);
38560 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38561 if (!SWIG_IsOK(res3)) {
38562 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
38563 }
38564 {
38565 PyThreadState* __tstate = wxPyBeginAllowThreads();
38566 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
38567 wxPyEndAllowThreads(__tstate);
38568 if (PyErr_Occurred()) SWIG_fail;
38569 }
38570 {
38571 resultobj = wxPyMake_wxObject(result, (bool)0);
38572 }
38573 return resultobj;
38574 fail:
38575 return NULL;
38576 }
38577
38578
38579 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38580 PyObject *resultobj = 0;
38581 wxMenu *arg1 = (wxMenu *) 0 ;
38582 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38583 wxMenuItem *result = 0 ;
38584 void *argp1 = 0 ;
38585 int res1 = 0 ;
38586 int res2 = 0 ;
38587 PyObject * obj0 = 0 ;
38588 PyObject * obj1 = 0 ;
38589 char * kwnames[] = {
38590 (char *) "self",(char *) "item", NULL
38591 };
38592
38593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
38594 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38595 if (!SWIG_IsOK(res1)) {
38596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38597 }
38598 arg1 = reinterpret_cast< wxMenu * >(argp1);
38599 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38600 if (!SWIG_IsOK(res2)) {
38601 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
38602 }
38603 {
38604 PyThreadState* __tstate = wxPyBeginAllowThreads();
38605 result = (wxMenuItem *)(arg1)->Prepend(arg2);
38606 wxPyEndAllowThreads(__tstate);
38607 if (PyErr_Occurred()) SWIG_fail;
38608 }
38609 {
38610 resultobj = wxPyMake_wxObject(result, (bool)0);
38611 }
38612 return resultobj;
38613 fail:
38614 return NULL;
38615 }
38616
38617
38618 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38619 PyObject *resultobj = 0;
38620 wxMenu *arg1 = (wxMenu *) 0 ;
38621 void *argp1 = 0 ;
38622 int res1 = 0 ;
38623 PyObject *swig_obj[1] ;
38624
38625 if (!args) SWIG_fail;
38626 swig_obj[0] = args;
38627 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38628 if (!SWIG_IsOK(res1)) {
38629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
38630 }
38631 arg1 = reinterpret_cast< wxMenu * >(argp1);
38632 {
38633 PyThreadState* __tstate = wxPyBeginAllowThreads();
38634 (arg1)->Break();
38635 wxPyEndAllowThreads(__tstate);
38636 if (PyErr_Occurred()) SWIG_fail;
38637 }
38638 resultobj = SWIG_Py_Void();
38639 return resultobj;
38640 fail:
38641 return NULL;
38642 }
38643
38644
38645 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38646 PyObject *resultobj = 0;
38647 wxMenu *arg1 = (wxMenu *) 0 ;
38648 size_t arg2 ;
38649 int arg3 ;
38650 wxString *arg4 = 0 ;
38651 wxString const &arg5_defvalue = wxPyEmptyString ;
38652 wxString *arg5 = (wxString *) &arg5_defvalue ;
38653 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
38654 wxMenuItem *result = 0 ;
38655 void *argp1 = 0 ;
38656 int res1 = 0 ;
38657 size_t val2 ;
38658 int ecode2 = 0 ;
38659 int val3 ;
38660 int ecode3 = 0 ;
38661 bool temp4 = false ;
38662 bool temp5 = false ;
38663 int val6 ;
38664 int ecode6 = 0 ;
38665 PyObject * obj0 = 0 ;
38666 PyObject * obj1 = 0 ;
38667 PyObject * obj2 = 0 ;
38668 PyObject * obj3 = 0 ;
38669 PyObject * obj4 = 0 ;
38670 PyObject * obj5 = 0 ;
38671 char * kwnames[] = {
38672 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38673 };
38674
38675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
38676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38677 if (!SWIG_IsOK(res1)) {
38678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
38679 }
38680 arg1 = reinterpret_cast< wxMenu * >(argp1);
38681 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38682 if (!SWIG_IsOK(ecode2)) {
38683 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
38684 }
38685 arg2 = static_cast< size_t >(val2);
38686 ecode3 = SWIG_AsVal_int(obj2, &val3);
38687 if (!SWIG_IsOK(ecode3)) {
38688 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
38689 }
38690 arg3 = static_cast< int >(val3);
38691 {
38692 arg4 = wxString_in_helper(obj3);
38693 if (arg4 == NULL) SWIG_fail;
38694 temp4 = true;
38695 }
38696 if (obj4) {
38697 {
38698 arg5 = wxString_in_helper(obj4);
38699 if (arg5 == NULL) SWIG_fail;
38700 temp5 = true;
38701 }
38702 }
38703 if (obj5) {
38704 ecode6 = SWIG_AsVal_int(obj5, &val6);
38705 if (!SWIG_IsOK(ecode6)) {
38706 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
38707 }
38708 arg6 = static_cast< wxItemKind >(val6);
38709 }
38710 {
38711 PyThreadState* __tstate = wxPyBeginAllowThreads();
38712 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
38713 wxPyEndAllowThreads(__tstate);
38714 if (PyErr_Occurred()) SWIG_fail;
38715 }
38716 {
38717 resultobj = wxPyMake_wxObject(result, (bool)0);
38718 }
38719 {
38720 if (temp4)
38721 delete arg4;
38722 }
38723 {
38724 if (temp5)
38725 delete arg5;
38726 }
38727 return resultobj;
38728 fail:
38729 {
38730 if (temp4)
38731 delete arg4;
38732 }
38733 {
38734 if (temp5)
38735 delete arg5;
38736 }
38737 return NULL;
38738 }
38739
38740
38741 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38742 PyObject *resultobj = 0;
38743 wxMenu *arg1 = (wxMenu *) 0 ;
38744 size_t arg2 ;
38745 wxMenuItem *result = 0 ;
38746 void *argp1 = 0 ;
38747 int res1 = 0 ;
38748 size_t val2 ;
38749 int ecode2 = 0 ;
38750 PyObject * obj0 = 0 ;
38751 PyObject * obj1 = 0 ;
38752 char * kwnames[] = {
38753 (char *) "self",(char *) "pos", NULL
38754 };
38755
38756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
38757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38758 if (!SWIG_IsOK(res1)) {
38759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
38760 }
38761 arg1 = reinterpret_cast< wxMenu * >(argp1);
38762 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38763 if (!SWIG_IsOK(ecode2)) {
38764 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
38765 }
38766 arg2 = static_cast< size_t >(val2);
38767 {
38768 PyThreadState* __tstate = wxPyBeginAllowThreads();
38769 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
38770 wxPyEndAllowThreads(__tstate);
38771 if (PyErr_Occurred()) SWIG_fail;
38772 }
38773 {
38774 resultobj = wxPyMake_wxObject(result, (bool)0);
38775 }
38776 return resultobj;
38777 fail:
38778 return NULL;
38779 }
38780
38781
38782 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38783 PyObject *resultobj = 0;
38784 wxMenu *arg1 = (wxMenu *) 0 ;
38785 size_t arg2 ;
38786 int arg3 ;
38787 wxString *arg4 = 0 ;
38788 wxString const &arg5_defvalue = wxPyEmptyString ;
38789 wxString *arg5 = (wxString *) &arg5_defvalue ;
38790 wxMenuItem *result = 0 ;
38791 void *argp1 = 0 ;
38792 int res1 = 0 ;
38793 size_t val2 ;
38794 int ecode2 = 0 ;
38795 int val3 ;
38796 int ecode3 = 0 ;
38797 bool temp4 = false ;
38798 bool temp5 = false ;
38799 PyObject * obj0 = 0 ;
38800 PyObject * obj1 = 0 ;
38801 PyObject * obj2 = 0 ;
38802 PyObject * obj3 = 0 ;
38803 PyObject * obj4 = 0 ;
38804 char * kwnames[] = {
38805 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
38806 };
38807
38808 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38809 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38810 if (!SWIG_IsOK(res1)) {
38811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38812 }
38813 arg1 = reinterpret_cast< wxMenu * >(argp1);
38814 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38815 if (!SWIG_IsOK(ecode2)) {
38816 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
38817 }
38818 arg2 = static_cast< size_t >(val2);
38819 ecode3 = SWIG_AsVal_int(obj2, &val3);
38820 if (!SWIG_IsOK(ecode3)) {
38821 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
38822 }
38823 arg3 = static_cast< int >(val3);
38824 {
38825 arg4 = wxString_in_helper(obj3);
38826 if (arg4 == NULL) SWIG_fail;
38827 temp4 = true;
38828 }
38829 if (obj4) {
38830 {
38831 arg5 = wxString_in_helper(obj4);
38832 if (arg5 == NULL) SWIG_fail;
38833 temp5 = true;
38834 }
38835 }
38836 {
38837 PyThreadState* __tstate = wxPyBeginAllowThreads();
38838 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
38839 wxPyEndAllowThreads(__tstate);
38840 if (PyErr_Occurred()) SWIG_fail;
38841 }
38842 {
38843 resultobj = wxPyMake_wxObject(result, (bool)0);
38844 }
38845 {
38846 if (temp4)
38847 delete arg4;
38848 }
38849 {
38850 if (temp5)
38851 delete arg5;
38852 }
38853 return resultobj;
38854 fail:
38855 {
38856 if (temp4)
38857 delete arg4;
38858 }
38859 {
38860 if (temp5)
38861 delete arg5;
38862 }
38863 return NULL;
38864 }
38865
38866
38867 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38868 PyObject *resultobj = 0;
38869 wxMenu *arg1 = (wxMenu *) 0 ;
38870 size_t arg2 ;
38871 int arg3 ;
38872 wxString *arg4 = 0 ;
38873 wxString const &arg5_defvalue = wxPyEmptyString ;
38874 wxString *arg5 = (wxString *) &arg5_defvalue ;
38875 wxMenuItem *result = 0 ;
38876 void *argp1 = 0 ;
38877 int res1 = 0 ;
38878 size_t val2 ;
38879 int ecode2 = 0 ;
38880 int val3 ;
38881 int ecode3 = 0 ;
38882 bool temp4 = false ;
38883 bool temp5 = false ;
38884 PyObject * obj0 = 0 ;
38885 PyObject * obj1 = 0 ;
38886 PyObject * obj2 = 0 ;
38887 PyObject * obj3 = 0 ;
38888 PyObject * obj4 = 0 ;
38889 char * kwnames[] = {
38890 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
38891 };
38892
38893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38895 if (!SWIG_IsOK(res1)) {
38896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38897 }
38898 arg1 = reinterpret_cast< wxMenu * >(argp1);
38899 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38900 if (!SWIG_IsOK(ecode2)) {
38901 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
38902 }
38903 arg2 = static_cast< size_t >(val2);
38904 ecode3 = SWIG_AsVal_int(obj2, &val3);
38905 if (!SWIG_IsOK(ecode3)) {
38906 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
38907 }
38908 arg3 = static_cast< int >(val3);
38909 {
38910 arg4 = wxString_in_helper(obj3);
38911 if (arg4 == NULL) SWIG_fail;
38912 temp4 = true;
38913 }
38914 if (obj4) {
38915 {
38916 arg5 = wxString_in_helper(obj4);
38917 if (arg5 == NULL) SWIG_fail;
38918 temp5 = true;
38919 }
38920 }
38921 {
38922 PyThreadState* __tstate = wxPyBeginAllowThreads();
38923 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
38924 wxPyEndAllowThreads(__tstate);
38925 if (PyErr_Occurred()) SWIG_fail;
38926 }
38927 {
38928 resultobj = wxPyMake_wxObject(result, (bool)0);
38929 }
38930 {
38931 if (temp4)
38932 delete arg4;
38933 }
38934 {
38935 if (temp5)
38936 delete arg5;
38937 }
38938 return resultobj;
38939 fail:
38940 {
38941 if (temp4)
38942 delete arg4;
38943 }
38944 {
38945 if (temp5)
38946 delete arg5;
38947 }
38948 return NULL;
38949 }
38950
38951
38952 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38953 PyObject *resultobj = 0;
38954 wxMenu *arg1 = (wxMenu *) 0 ;
38955 size_t arg2 ;
38956 int arg3 ;
38957 wxString *arg4 = 0 ;
38958 wxMenu *arg5 = (wxMenu *) 0 ;
38959 wxString const &arg6_defvalue = wxPyEmptyString ;
38960 wxString *arg6 = (wxString *) &arg6_defvalue ;
38961 wxMenuItem *result = 0 ;
38962 void *argp1 = 0 ;
38963 int res1 = 0 ;
38964 size_t val2 ;
38965 int ecode2 = 0 ;
38966 int val3 ;
38967 int ecode3 = 0 ;
38968 bool temp4 = false ;
38969 void *argp5 = 0 ;
38970 int res5 = 0 ;
38971 bool temp6 = false ;
38972 PyObject * obj0 = 0 ;
38973 PyObject * obj1 = 0 ;
38974 PyObject * obj2 = 0 ;
38975 PyObject * obj3 = 0 ;
38976 PyObject * obj4 = 0 ;
38977 PyObject * obj5 = 0 ;
38978 char * kwnames[] = {
38979 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
38980 };
38981
38982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
38983 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38984 if (!SWIG_IsOK(res1)) {
38985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38986 }
38987 arg1 = reinterpret_cast< wxMenu * >(argp1);
38988 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38989 if (!SWIG_IsOK(ecode2)) {
38990 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
38991 }
38992 arg2 = static_cast< size_t >(val2);
38993 ecode3 = SWIG_AsVal_int(obj2, &val3);
38994 if (!SWIG_IsOK(ecode3)) {
38995 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
38996 }
38997 arg3 = static_cast< int >(val3);
38998 {
38999 arg4 = wxString_in_helper(obj3);
39000 if (arg4 == NULL) SWIG_fail;
39001 temp4 = true;
39002 }
39003 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
39004 if (!SWIG_IsOK(res5)) {
39005 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
39006 }
39007 arg5 = reinterpret_cast< wxMenu * >(argp5);
39008 if (obj5) {
39009 {
39010 arg6 = wxString_in_helper(obj5);
39011 if (arg6 == NULL) SWIG_fail;
39012 temp6 = true;
39013 }
39014 }
39015 {
39016 PyThreadState* __tstate = wxPyBeginAllowThreads();
39017 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
39018 wxPyEndAllowThreads(__tstate);
39019 if (PyErr_Occurred()) SWIG_fail;
39020 }
39021 {
39022 resultobj = wxPyMake_wxObject(result, (bool)0);
39023 }
39024 {
39025 if (temp4)
39026 delete arg4;
39027 }
39028 {
39029 if (temp6)
39030 delete arg6;
39031 }
39032 return resultobj;
39033 fail:
39034 {
39035 if (temp4)
39036 delete arg4;
39037 }
39038 {
39039 if (temp6)
39040 delete arg6;
39041 }
39042 return NULL;
39043 }
39044
39045
39046 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39047 PyObject *resultobj = 0;
39048 wxMenu *arg1 = (wxMenu *) 0 ;
39049 int arg2 ;
39050 wxString *arg3 = 0 ;
39051 wxString const &arg4_defvalue = wxPyEmptyString ;
39052 wxString *arg4 = (wxString *) &arg4_defvalue ;
39053 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
39054 wxMenuItem *result = 0 ;
39055 void *argp1 = 0 ;
39056 int res1 = 0 ;
39057 int val2 ;
39058 int ecode2 = 0 ;
39059 bool temp3 = false ;
39060 bool temp4 = false ;
39061 int val5 ;
39062 int ecode5 = 0 ;
39063 PyObject * obj0 = 0 ;
39064 PyObject * obj1 = 0 ;
39065 PyObject * obj2 = 0 ;
39066 PyObject * obj3 = 0 ;
39067 PyObject * obj4 = 0 ;
39068 char * kwnames[] = {
39069 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
39070 };
39071
39072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39073 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39074 if (!SWIG_IsOK(res1)) {
39075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
39076 }
39077 arg1 = reinterpret_cast< wxMenu * >(argp1);
39078 ecode2 = SWIG_AsVal_int(obj1, &val2);
39079 if (!SWIG_IsOK(ecode2)) {
39080 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
39081 }
39082 arg2 = static_cast< int >(val2);
39083 {
39084 arg3 = wxString_in_helper(obj2);
39085 if (arg3 == NULL) SWIG_fail;
39086 temp3 = true;
39087 }
39088 if (obj3) {
39089 {
39090 arg4 = wxString_in_helper(obj3);
39091 if (arg4 == NULL) SWIG_fail;
39092 temp4 = true;
39093 }
39094 }
39095 if (obj4) {
39096 ecode5 = SWIG_AsVal_int(obj4, &val5);
39097 if (!SWIG_IsOK(ecode5)) {
39098 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
39099 }
39100 arg5 = static_cast< wxItemKind >(val5);
39101 }
39102 {
39103 PyThreadState* __tstate = wxPyBeginAllowThreads();
39104 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
39105 wxPyEndAllowThreads(__tstate);
39106 if (PyErr_Occurred()) SWIG_fail;
39107 }
39108 {
39109 resultobj = wxPyMake_wxObject(result, (bool)0);
39110 }
39111 {
39112 if (temp3)
39113 delete arg3;
39114 }
39115 {
39116 if (temp4)
39117 delete arg4;
39118 }
39119 return resultobj;
39120 fail:
39121 {
39122 if (temp3)
39123 delete arg3;
39124 }
39125 {
39126 if (temp4)
39127 delete arg4;
39128 }
39129 return NULL;
39130 }
39131
39132
39133 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39134 PyObject *resultobj = 0;
39135 wxMenu *arg1 = (wxMenu *) 0 ;
39136 wxMenuItem *result = 0 ;
39137 void *argp1 = 0 ;
39138 int res1 = 0 ;
39139 PyObject *swig_obj[1] ;
39140
39141 if (!args) SWIG_fail;
39142 swig_obj[0] = args;
39143 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39144 if (!SWIG_IsOK(res1)) {
39145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39146 }
39147 arg1 = reinterpret_cast< wxMenu * >(argp1);
39148 {
39149 PyThreadState* __tstate = wxPyBeginAllowThreads();
39150 result = (wxMenuItem *)(arg1)->PrependSeparator();
39151 wxPyEndAllowThreads(__tstate);
39152 if (PyErr_Occurred()) SWIG_fail;
39153 }
39154 {
39155 resultobj = wxPyMake_wxObject(result, (bool)0);
39156 }
39157 return resultobj;
39158 fail:
39159 return NULL;
39160 }
39161
39162
39163 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39164 PyObject *resultobj = 0;
39165 wxMenu *arg1 = (wxMenu *) 0 ;
39166 int arg2 ;
39167 wxString *arg3 = 0 ;
39168 wxString const &arg4_defvalue = wxPyEmptyString ;
39169 wxString *arg4 = (wxString *) &arg4_defvalue ;
39170 wxMenuItem *result = 0 ;
39171 void *argp1 = 0 ;
39172 int res1 = 0 ;
39173 int val2 ;
39174 int ecode2 = 0 ;
39175 bool temp3 = false ;
39176 bool temp4 = false ;
39177 PyObject * obj0 = 0 ;
39178 PyObject * obj1 = 0 ;
39179 PyObject * obj2 = 0 ;
39180 PyObject * obj3 = 0 ;
39181 char * kwnames[] = {
39182 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39183 };
39184
39185 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39186 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39187 if (!SWIG_IsOK(res1)) {
39188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39189 }
39190 arg1 = reinterpret_cast< wxMenu * >(argp1);
39191 ecode2 = SWIG_AsVal_int(obj1, &val2);
39192 if (!SWIG_IsOK(ecode2)) {
39193 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
39194 }
39195 arg2 = static_cast< int >(val2);
39196 {
39197 arg3 = wxString_in_helper(obj2);
39198 if (arg3 == NULL) SWIG_fail;
39199 temp3 = true;
39200 }
39201 if (obj3) {
39202 {
39203 arg4 = wxString_in_helper(obj3);
39204 if (arg4 == NULL) SWIG_fail;
39205 temp4 = true;
39206 }
39207 }
39208 {
39209 PyThreadState* __tstate = wxPyBeginAllowThreads();
39210 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39211 wxPyEndAllowThreads(__tstate);
39212 if (PyErr_Occurred()) SWIG_fail;
39213 }
39214 {
39215 resultobj = wxPyMake_wxObject(result, (bool)0);
39216 }
39217 {
39218 if (temp3)
39219 delete arg3;
39220 }
39221 {
39222 if (temp4)
39223 delete arg4;
39224 }
39225 return resultobj;
39226 fail:
39227 {
39228 if (temp3)
39229 delete arg3;
39230 }
39231 {
39232 if (temp4)
39233 delete arg4;
39234 }
39235 return NULL;
39236 }
39237
39238
39239 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39240 PyObject *resultobj = 0;
39241 wxMenu *arg1 = (wxMenu *) 0 ;
39242 int arg2 ;
39243 wxString *arg3 = 0 ;
39244 wxString const &arg4_defvalue = wxPyEmptyString ;
39245 wxString *arg4 = (wxString *) &arg4_defvalue ;
39246 wxMenuItem *result = 0 ;
39247 void *argp1 = 0 ;
39248 int res1 = 0 ;
39249 int val2 ;
39250 int ecode2 = 0 ;
39251 bool temp3 = false ;
39252 bool temp4 = false ;
39253 PyObject * obj0 = 0 ;
39254 PyObject * obj1 = 0 ;
39255 PyObject * obj2 = 0 ;
39256 PyObject * obj3 = 0 ;
39257 char * kwnames[] = {
39258 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39259 };
39260
39261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39262 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39263 if (!SWIG_IsOK(res1)) {
39264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39265 }
39266 arg1 = reinterpret_cast< wxMenu * >(argp1);
39267 ecode2 = SWIG_AsVal_int(obj1, &val2);
39268 if (!SWIG_IsOK(ecode2)) {
39269 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
39270 }
39271 arg2 = static_cast< int >(val2);
39272 {
39273 arg3 = wxString_in_helper(obj2);
39274 if (arg3 == NULL) SWIG_fail;
39275 temp3 = true;
39276 }
39277 if (obj3) {
39278 {
39279 arg4 = wxString_in_helper(obj3);
39280 if (arg4 == NULL) SWIG_fail;
39281 temp4 = true;
39282 }
39283 }
39284 {
39285 PyThreadState* __tstate = wxPyBeginAllowThreads();
39286 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39287 wxPyEndAllowThreads(__tstate);
39288 if (PyErr_Occurred()) SWIG_fail;
39289 }
39290 {
39291 resultobj = wxPyMake_wxObject(result, (bool)0);
39292 }
39293 {
39294 if (temp3)
39295 delete arg3;
39296 }
39297 {
39298 if (temp4)
39299 delete arg4;
39300 }
39301 return resultobj;
39302 fail:
39303 {
39304 if (temp3)
39305 delete arg3;
39306 }
39307 {
39308 if (temp4)
39309 delete arg4;
39310 }
39311 return NULL;
39312 }
39313
39314
39315 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39316 PyObject *resultobj = 0;
39317 wxMenu *arg1 = (wxMenu *) 0 ;
39318 int arg2 ;
39319 wxString *arg3 = 0 ;
39320 wxMenu *arg4 = (wxMenu *) 0 ;
39321 wxString const &arg5_defvalue = wxPyEmptyString ;
39322 wxString *arg5 = (wxString *) &arg5_defvalue ;
39323 wxMenuItem *result = 0 ;
39324 void *argp1 = 0 ;
39325 int res1 = 0 ;
39326 int val2 ;
39327 int ecode2 = 0 ;
39328 bool temp3 = false ;
39329 void *argp4 = 0 ;
39330 int res4 = 0 ;
39331 bool temp5 = false ;
39332 PyObject * obj0 = 0 ;
39333 PyObject * obj1 = 0 ;
39334 PyObject * obj2 = 0 ;
39335 PyObject * obj3 = 0 ;
39336 PyObject * obj4 = 0 ;
39337 char * kwnames[] = {
39338 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39339 };
39340
39341 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39342 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39343 if (!SWIG_IsOK(res1)) {
39344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39345 }
39346 arg1 = reinterpret_cast< wxMenu * >(argp1);
39347 ecode2 = SWIG_AsVal_int(obj1, &val2);
39348 if (!SWIG_IsOK(ecode2)) {
39349 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
39350 }
39351 arg2 = static_cast< int >(val2);
39352 {
39353 arg3 = wxString_in_helper(obj2);
39354 if (arg3 == NULL) SWIG_fail;
39355 temp3 = true;
39356 }
39357 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
39358 if (!SWIG_IsOK(res4)) {
39359 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
39360 }
39361 arg4 = reinterpret_cast< wxMenu * >(argp4);
39362 if (obj4) {
39363 {
39364 arg5 = wxString_in_helper(obj4);
39365 if (arg5 == NULL) SWIG_fail;
39366 temp5 = true;
39367 }
39368 }
39369 {
39370 PyThreadState* __tstate = wxPyBeginAllowThreads();
39371 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
39372 wxPyEndAllowThreads(__tstate);
39373 if (PyErr_Occurred()) SWIG_fail;
39374 }
39375 {
39376 resultobj = wxPyMake_wxObject(result, (bool)0);
39377 }
39378 {
39379 if (temp3)
39380 delete arg3;
39381 }
39382 {
39383 if (temp5)
39384 delete arg5;
39385 }
39386 return resultobj;
39387 fail:
39388 {
39389 if (temp3)
39390 delete arg3;
39391 }
39392 {
39393 if (temp5)
39394 delete arg5;
39395 }
39396 return NULL;
39397 }
39398
39399
39400 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39401 PyObject *resultobj = 0;
39402 wxMenu *arg1 = (wxMenu *) 0 ;
39403 int arg2 ;
39404 wxMenuItem *result = 0 ;
39405 void *argp1 = 0 ;
39406 int res1 = 0 ;
39407 int val2 ;
39408 int ecode2 = 0 ;
39409 PyObject * obj0 = 0 ;
39410 PyObject * obj1 = 0 ;
39411 char * kwnames[] = {
39412 (char *) "self",(char *) "id", NULL
39413 };
39414
39415 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
39416 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39417 if (!SWIG_IsOK(res1)) {
39418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
39419 }
39420 arg1 = reinterpret_cast< wxMenu * >(argp1);
39421 ecode2 = SWIG_AsVal_int(obj1, &val2);
39422 if (!SWIG_IsOK(ecode2)) {
39423 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
39424 }
39425 arg2 = static_cast< int >(val2);
39426 {
39427 PyThreadState* __tstate = wxPyBeginAllowThreads();
39428 result = (wxMenuItem *)(arg1)->Remove(arg2);
39429 wxPyEndAllowThreads(__tstate);
39430 if (PyErr_Occurred()) SWIG_fail;
39431 }
39432 {
39433 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39434 }
39435 return resultobj;
39436 fail:
39437 return NULL;
39438 }
39439
39440
39441 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39442 PyObject *resultobj = 0;
39443 wxMenu *arg1 = (wxMenu *) 0 ;
39444 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39445 wxMenuItem *result = 0 ;
39446 void *argp1 = 0 ;
39447 int res1 = 0 ;
39448 void *argp2 = 0 ;
39449 int res2 = 0 ;
39450 PyObject * obj0 = 0 ;
39451 PyObject * obj1 = 0 ;
39452 char * kwnames[] = {
39453 (char *) "self",(char *) "item", NULL
39454 };
39455
39456 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
39457 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39458 if (!SWIG_IsOK(res1)) {
39459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39460 }
39461 arg1 = reinterpret_cast< wxMenu * >(argp1);
39462 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39463 if (!SWIG_IsOK(res2)) {
39464 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39465 }
39466 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39467 {
39468 PyThreadState* __tstate = wxPyBeginAllowThreads();
39469 result = (wxMenuItem *)(arg1)->Remove(arg2);
39470 wxPyEndAllowThreads(__tstate);
39471 if (PyErr_Occurred()) SWIG_fail;
39472 }
39473 {
39474 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39475 }
39476 return resultobj;
39477 fail:
39478 return NULL;
39479 }
39480
39481
39482 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39483 PyObject *resultobj = 0;
39484 wxMenu *arg1 = (wxMenu *) 0 ;
39485 int arg2 ;
39486 bool result;
39487 void *argp1 = 0 ;
39488 int res1 = 0 ;
39489 int val2 ;
39490 int ecode2 = 0 ;
39491 PyObject * obj0 = 0 ;
39492 PyObject * obj1 = 0 ;
39493 char * kwnames[] = {
39494 (char *) "self",(char *) "id", NULL
39495 };
39496
39497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
39498 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39499 if (!SWIG_IsOK(res1)) {
39500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
39501 }
39502 arg1 = reinterpret_cast< wxMenu * >(argp1);
39503 ecode2 = SWIG_AsVal_int(obj1, &val2);
39504 if (!SWIG_IsOK(ecode2)) {
39505 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
39506 }
39507 arg2 = static_cast< int >(val2);
39508 {
39509 PyThreadState* __tstate = wxPyBeginAllowThreads();
39510 result = (bool)(arg1)->Delete(arg2);
39511 wxPyEndAllowThreads(__tstate);
39512 if (PyErr_Occurred()) SWIG_fail;
39513 }
39514 {
39515 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39516 }
39517 return resultobj;
39518 fail:
39519 return NULL;
39520 }
39521
39522
39523 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39524 PyObject *resultobj = 0;
39525 wxMenu *arg1 = (wxMenu *) 0 ;
39526 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39527 bool result;
39528 void *argp1 = 0 ;
39529 int res1 = 0 ;
39530 void *argp2 = 0 ;
39531 int res2 = 0 ;
39532 PyObject * obj0 = 0 ;
39533 PyObject * obj1 = 0 ;
39534 char * kwnames[] = {
39535 (char *) "self",(char *) "item", NULL
39536 };
39537
39538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
39539 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39540 if (!SWIG_IsOK(res1)) {
39541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39542 }
39543 arg1 = reinterpret_cast< wxMenu * >(argp1);
39544 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39545 if (!SWIG_IsOK(res2)) {
39546 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39547 }
39548 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39549 {
39550 PyThreadState* __tstate = wxPyBeginAllowThreads();
39551 result = (bool)(arg1)->Delete(arg2);
39552 wxPyEndAllowThreads(__tstate);
39553 if (PyErr_Occurred()) SWIG_fail;
39554 }
39555 {
39556 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39557 }
39558 return resultobj;
39559 fail:
39560 return NULL;
39561 }
39562
39563
39564 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39565 PyObject *resultobj = 0;
39566 wxMenu *arg1 = (wxMenu *) 0 ;
39567 void *argp1 = 0 ;
39568 int res1 = 0 ;
39569 PyObject *swig_obj[1] ;
39570
39571 if (!args) SWIG_fail;
39572 swig_obj[0] = args;
39573 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39574 if (!SWIG_IsOK(res1)) {
39575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
39576 }
39577 arg1 = reinterpret_cast< wxMenu * >(argp1);
39578 {
39579 PyThreadState* __tstate = wxPyBeginAllowThreads();
39580 wxMenu_Destroy(arg1);
39581 wxPyEndAllowThreads(__tstate);
39582 if (PyErr_Occurred()) SWIG_fail;
39583 }
39584 resultobj = SWIG_Py_Void();
39585 return resultobj;
39586 fail:
39587 return NULL;
39588 }
39589
39590
39591 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39592 PyObject *resultobj = 0;
39593 wxMenu *arg1 = (wxMenu *) 0 ;
39594 int arg2 ;
39595 bool result;
39596 void *argp1 = 0 ;
39597 int res1 = 0 ;
39598 int val2 ;
39599 int ecode2 = 0 ;
39600 PyObject * obj0 = 0 ;
39601 PyObject * obj1 = 0 ;
39602 char * kwnames[] = {
39603 (char *) "self",(char *) "id", NULL
39604 };
39605
39606 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
39607 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39608 if (!SWIG_IsOK(res1)) {
39609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
39610 }
39611 arg1 = reinterpret_cast< wxMenu * >(argp1);
39612 ecode2 = SWIG_AsVal_int(obj1, &val2);
39613 if (!SWIG_IsOK(ecode2)) {
39614 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
39615 }
39616 arg2 = static_cast< int >(val2);
39617 {
39618 PyThreadState* __tstate = wxPyBeginAllowThreads();
39619 result = (bool)(arg1)->Destroy(arg2);
39620 wxPyEndAllowThreads(__tstate);
39621 if (PyErr_Occurred()) SWIG_fail;
39622 }
39623 {
39624 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39625 }
39626 return resultobj;
39627 fail:
39628 return NULL;
39629 }
39630
39631
39632 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39633 PyObject *resultobj = 0;
39634 wxMenu *arg1 = (wxMenu *) 0 ;
39635 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39636 bool result;
39637 void *argp1 = 0 ;
39638 int res1 = 0 ;
39639 void *argp2 = 0 ;
39640 int res2 = 0 ;
39641 PyObject * obj0 = 0 ;
39642 PyObject * obj1 = 0 ;
39643 char * kwnames[] = {
39644 (char *) "self",(char *) "item", NULL
39645 };
39646
39647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
39648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39649 if (!SWIG_IsOK(res1)) {
39650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39651 }
39652 arg1 = reinterpret_cast< wxMenu * >(argp1);
39653 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39654 if (!SWIG_IsOK(res2)) {
39655 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39656 }
39657 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39658 {
39659 PyThreadState* __tstate = wxPyBeginAllowThreads();
39660 result = (bool)(arg1)->Destroy(arg2);
39661 wxPyEndAllowThreads(__tstate);
39662 if (PyErr_Occurred()) SWIG_fail;
39663 }
39664 {
39665 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39666 }
39667 return resultobj;
39668 fail:
39669 return NULL;
39670 }
39671
39672
39673 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39674 PyObject *resultobj = 0;
39675 wxMenu *arg1 = (wxMenu *) 0 ;
39676 size_t result;
39677 void *argp1 = 0 ;
39678 int res1 = 0 ;
39679 PyObject *swig_obj[1] ;
39680
39681 if (!args) SWIG_fail;
39682 swig_obj[0] = args;
39683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39684 if (!SWIG_IsOK(res1)) {
39685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
39686 }
39687 arg1 = reinterpret_cast< wxMenu * >(argp1);
39688 {
39689 PyThreadState* __tstate = wxPyBeginAllowThreads();
39690 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
39691 wxPyEndAllowThreads(__tstate);
39692 if (PyErr_Occurred()) SWIG_fail;
39693 }
39694 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
39695 return resultobj;
39696 fail:
39697 return NULL;
39698 }
39699
39700
39701 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39702 PyObject *resultobj = 0;
39703 wxMenu *arg1 = (wxMenu *) 0 ;
39704 PyObject *result = 0 ;
39705 void *argp1 = 0 ;
39706 int res1 = 0 ;
39707 PyObject *swig_obj[1] ;
39708
39709 if (!args) SWIG_fail;
39710 swig_obj[0] = args;
39711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39712 if (!SWIG_IsOK(res1)) {
39713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
39714 }
39715 arg1 = reinterpret_cast< wxMenu * >(argp1);
39716 {
39717 PyThreadState* __tstate = wxPyBeginAllowThreads();
39718 result = (PyObject *)wxMenu_GetMenuItems(arg1);
39719 wxPyEndAllowThreads(__tstate);
39720 if (PyErr_Occurred()) SWIG_fail;
39721 }
39722 resultobj = result;
39723 return resultobj;
39724 fail:
39725 return NULL;
39726 }
39727
39728
39729 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39730 PyObject *resultobj = 0;
39731 wxMenu *arg1 = (wxMenu *) 0 ;
39732 wxString *arg2 = 0 ;
39733 int result;
39734 void *argp1 = 0 ;
39735 int res1 = 0 ;
39736 bool temp2 = false ;
39737 PyObject * obj0 = 0 ;
39738 PyObject * obj1 = 0 ;
39739 char * kwnames[] = {
39740 (char *) "self",(char *) "item", NULL
39741 };
39742
39743 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
39744 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39745 if (!SWIG_IsOK(res1)) {
39746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
39747 }
39748 arg1 = reinterpret_cast< wxMenu * >(argp1);
39749 {
39750 arg2 = wxString_in_helper(obj1);
39751 if (arg2 == NULL) SWIG_fail;
39752 temp2 = true;
39753 }
39754 {
39755 PyThreadState* __tstate = wxPyBeginAllowThreads();
39756 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
39757 wxPyEndAllowThreads(__tstate);
39758 if (PyErr_Occurred()) SWIG_fail;
39759 }
39760 resultobj = SWIG_From_int(static_cast< int >(result));
39761 {
39762 if (temp2)
39763 delete arg2;
39764 }
39765 return resultobj;
39766 fail:
39767 {
39768 if (temp2)
39769 delete arg2;
39770 }
39771 return NULL;
39772 }
39773
39774
39775 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39776 PyObject *resultobj = 0;
39777 wxMenu *arg1 = (wxMenu *) 0 ;
39778 int arg2 ;
39779 wxMenuItem *result = 0 ;
39780 void *argp1 = 0 ;
39781 int res1 = 0 ;
39782 int val2 ;
39783 int ecode2 = 0 ;
39784 PyObject * obj0 = 0 ;
39785 PyObject * obj1 = 0 ;
39786 char * kwnames[] = {
39787 (char *) "self",(char *) "id", NULL
39788 };
39789
39790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
39791 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39792 if (!SWIG_IsOK(res1)) {
39793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
39794 }
39795 arg1 = reinterpret_cast< wxMenu * >(argp1);
39796 ecode2 = SWIG_AsVal_int(obj1, &val2);
39797 if (!SWIG_IsOK(ecode2)) {
39798 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
39799 }
39800 arg2 = static_cast< int >(val2);
39801 {
39802 PyThreadState* __tstate = wxPyBeginAllowThreads();
39803 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
39804 wxPyEndAllowThreads(__tstate);
39805 if (PyErr_Occurred()) SWIG_fail;
39806 }
39807 {
39808 resultobj = wxPyMake_wxObject(result, (bool)0);
39809 }
39810 return resultobj;
39811 fail:
39812 return NULL;
39813 }
39814
39815
39816 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39817 PyObject *resultobj = 0;
39818 wxMenu *arg1 = (wxMenu *) 0 ;
39819 size_t arg2 ;
39820 wxMenuItem *result = 0 ;
39821 void *argp1 = 0 ;
39822 int res1 = 0 ;
39823 size_t val2 ;
39824 int ecode2 = 0 ;
39825 PyObject * obj0 = 0 ;
39826 PyObject * obj1 = 0 ;
39827 char * kwnames[] = {
39828 (char *) "self",(char *) "position", NULL
39829 };
39830
39831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
39832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39833 if (!SWIG_IsOK(res1)) {
39834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
39835 }
39836 arg1 = reinterpret_cast< wxMenu * >(argp1);
39837 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39838 if (!SWIG_IsOK(ecode2)) {
39839 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
39840 }
39841 arg2 = static_cast< size_t >(val2);
39842 {
39843 PyThreadState* __tstate = wxPyBeginAllowThreads();
39844 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
39845 wxPyEndAllowThreads(__tstate);
39846 if (PyErr_Occurred()) SWIG_fail;
39847 }
39848 {
39849 resultobj = wxPyMake_wxObject(result, (bool)0);
39850 }
39851 return resultobj;
39852 fail:
39853 return NULL;
39854 }
39855
39856
39857 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39858 PyObject *resultobj = 0;
39859 wxMenu *arg1 = (wxMenu *) 0 ;
39860 int arg2 ;
39861 bool arg3 ;
39862 void *argp1 = 0 ;
39863 int res1 = 0 ;
39864 int val2 ;
39865 int ecode2 = 0 ;
39866 bool val3 ;
39867 int ecode3 = 0 ;
39868 PyObject * obj0 = 0 ;
39869 PyObject * obj1 = 0 ;
39870 PyObject * obj2 = 0 ;
39871 char * kwnames[] = {
39872 (char *) "self",(char *) "id",(char *) "enable", NULL
39873 };
39874
39875 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39876 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39877 if (!SWIG_IsOK(res1)) {
39878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
39879 }
39880 arg1 = reinterpret_cast< wxMenu * >(argp1);
39881 ecode2 = SWIG_AsVal_int(obj1, &val2);
39882 if (!SWIG_IsOK(ecode2)) {
39883 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
39884 }
39885 arg2 = static_cast< int >(val2);
39886 ecode3 = SWIG_AsVal_bool(obj2, &val3);
39887 if (!SWIG_IsOK(ecode3)) {
39888 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
39889 }
39890 arg3 = static_cast< bool >(val3);
39891 {
39892 PyThreadState* __tstate = wxPyBeginAllowThreads();
39893 (arg1)->Enable(arg2,arg3);
39894 wxPyEndAllowThreads(__tstate);
39895 if (PyErr_Occurred()) SWIG_fail;
39896 }
39897 resultobj = SWIG_Py_Void();
39898 return resultobj;
39899 fail:
39900 return NULL;
39901 }
39902
39903
39904 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39905 PyObject *resultobj = 0;
39906 wxMenu *arg1 = (wxMenu *) 0 ;
39907 int arg2 ;
39908 bool result;
39909 void *argp1 = 0 ;
39910 int res1 = 0 ;
39911 int val2 ;
39912 int ecode2 = 0 ;
39913 PyObject * obj0 = 0 ;
39914 PyObject * obj1 = 0 ;
39915 char * kwnames[] = {
39916 (char *) "self",(char *) "id", NULL
39917 };
39918
39919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
39920 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39921 if (!SWIG_IsOK(res1)) {
39922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
39923 }
39924 arg1 = reinterpret_cast< wxMenu * >(argp1);
39925 ecode2 = SWIG_AsVal_int(obj1, &val2);
39926 if (!SWIG_IsOK(ecode2)) {
39927 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
39928 }
39929 arg2 = static_cast< int >(val2);
39930 {
39931 PyThreadState* __tstate = wxPyBeginAllowThreads();
39932 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
39933 wxPyEndAllowThreads(__tstate);
39934 if (PyErr_Occurred()) SWIG_fail;
39935 }
39936 {
39937 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39938 }
39939 return resultobj;
39940 fail:
39941 return NULL;
39942 }
39943
39944
39945 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39946 PyObject *resultobj = 0;
39947 wxMenu *arg1 = (wxMenu *) 0 ;
39948 int arg2 ;
39949 bool arg3 ;
39950 void *argp1 = 0 ;
39951 int res1 = 0 ;
39952 int val2 ;
39953 int ecode2 = 0 ;
39954 bool val3 ;
39955 int ecode3 = 0 ;
39956 PyObject * obj0 = 0 ;
39957 PyObject * obj1 = 0 ;
39958 PyObject * obj2 = 0 ;
39959 char * kwnames[] = {
39960 (char *) "self",(char *) "id",(char *) "check", NULL
39961 };
39962
39963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39964 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39965 if (!SWIG_IsOK(res1)) {
39966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
39967 }
39968 arg1 = reinterpret_cast< wxMenu * >(argp1);
39969 ecode2 = SWIG_AsVal_int(obj1, &val2);
39970 if (!SWIG_IsOK(ecode2)) {
39971 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
39972 }
39973 arg2 = static_cast< int >(val2);
39974 ecode3 = SWIG_AsVal_bool(obj2, &val3);
39975 if (!SWIG_IsOK(ecode3)) {
39976 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
39977 }
39978 arg3 = static_cast< bool >(val3);
39979 {
39980 PyThreadState* __tstate = wxPyBeginAllowThreads();
39981 (arg1)->Check(arg2,arg3);
39982 wxPyEndAllowThreads(__tstate);
39983 if (PyErr_Occurred()) SWIG_fail;
39984 }
39985 resultobj = SWIG_Py_Void();
39986 return resultobj;
39987 fail:
39988 return NULL;
39989 }
39990
39991
39992 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39993 PyObject *resultobj = 0;
39994 wxMenu *arg1 = (wxMenu *) 0 ;
39995 int arg2 ;
39996 bool result;
39997 void *argp1 = 0 ;
39998 int res1 = 0 ;
39999 int val2 ;
40000 int ecode2 = 0 ;
40001 PyObject * obj0 = 0 ;
40002 PyObject * obj1 = 0 ;
40003 char * kwnames[] = {
40004 (char *) "self",(char *) "id", NULL
40005 };
40006
40007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
40008 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40009 if (!SWIG_IsOK(res1)) {
40010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
40011 }
40012 arg1 = reinterpret_cast< wxMenu * >(argp1);
40013 ecode2 = SWIG_AsVal_int(obj1, &val2);
40014 if (!SWIG_IsOK(ecode2)) {
40015 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
40016 }
40017 arg2 = static_cast< int >(val2);
40018 {
40019 PyThreadState* __tstate = wxPyBeginAllowThreads();
40020 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
40021 wxPyEndAllowThreads(__tstate);
40022 if (PyErr_Occurred()) SWIG_fail;
40023 }
40024 {
40025 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40026 }
40027 return resultobj;
40028 fail:
40029 return NULL;
40030 }
40031
40032
40033 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40034 PyObject *resultobj = 0;
40035 wxMenu *arg1 = (wxMenu *) 0 ;
40036 int arg2 ;
40037 wxString *arg3 = 0 ;
40038 void *argp1 = 0 ;
40039 int res1 = 0 ;
40040 int val2 ;
40041 int ecode2 = 0 ;
40042 bool temp3 = false ;
40043 PyObject * obj0 = 0 ;
40044 PyObject * obj1 = 0 ;
40045 PyObject * obj2 = 0 ;
40046 char * kwnames[] = {
40047 (char *) "self",(char *) "id",(char *) "label", NULL
40048 };
40049
40050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40051 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40052 if (!SWIG_IsOK(res1)) {
40053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
40054 }
40055 arg1 = reinterpret_cast< wxMenu * >(argp1);
40056 ecode2 = SWIG_AsVal_int(obj1, &val2);
40057 if (!SWIG_IsOK(ecode2)) {
40058 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
40059 }
40060 arg2 = static_cast< int >(val2);
40061 {
40062 arg3 = wxString_in_helper(obj2);
40063 if (arg3 == NULL) SWIG_fail;
40064 temp3 = true;
40065 }
40066 {
40067 PyThreadState* __tstate = wxPyBeginAllowThreads();
40068 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
40069 wxPyEndAllowThreads(__tstate);
40070 if (PyErr_Occurred()) SWIG_fail;
40071 }
40072 resultobj = SWIG_Py_Void();
40073 {
40074 if (temp3)
40075 delete arg3;
40076 }
40077 return resultobj;
40078 fail:
40079 {
40080 if (temp3)
40081 delete arg3;
40082 }
40083 return NULL;
40084 }
40085
40086
40087 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40088 PyObject *resultobj = 0;
40089 wxMenu *arg1 = (wxMenu *) 0 ;
40090 int arg2 ;
40091 wxString result;
40092 void *argp1 = 0 ;
40093 int res1 = 0 ;
40094 int val2 ;
40095 int ecode2 = 0 ;
40096 PyObject * obj0 = 0 ;
40097 PyObject * obj1 = 0 ;
40098 char * kwnames[] = {
40099 (char *) "self",(char *) "id", NULL
40100 };
40101
40102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
40103 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40104 if (!SWIG_IsOK(res1)) {
40105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
40106 }
40107 arg1 = reinterpret_cast< wxMenu * >(argp1);
40108 ecode2 = SWIG_AsVal_int(obj1, &val2);
40109 if (!SWIG_IsOK(ecode2)) {
40110 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
40111 }
40112 arg2 = static_cast< int >(val2);
40113 {
40114 PyThreadState* __tstate = wxPyBeginAllowThreads();
40115 result = ((wxMenu const *)arg1)->GetLabel(arg2);
40116 wxPyEndAllowThreads(__tstate);
40117 if (PyErr_Occurred()) SWIG_fail;
40118 }
40119 {
40120 #if wxUSE_UNICODE
40121 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40122 #else
40123 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40124 #endif
40125 }
40126 return resultobj;
40127 fail:
40128 return NULL;
40129 }
40130
40131
40132 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40133 PyObject *resultobj = 0;
40134 wxMenu *arg1 = (wxMenu *) 0 ;
40135 int arg2 ;
40136 wxString *arg3 = 0 ;
40137 void *argp1 = 0 ;
40138 int res1 = 0 ;
40139 int val2 ;
40140 int ecode2 = 0 ;
40141 bool temp3 = false ;
40142 PyObject * obj0 = 0 ;
40143 PyObject * obj1 = 0 ;
40144 PyObject * obj2 = 0 ;
40145 char * kwnames[] = {
40146 (char *) "self",(char *) "id",(char *) "helpString", NULL
40147 };
40148
40149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40150 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40151 if (!SWIG_IsOK(res1)) {
40152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
40153 }
40154 arg1 = reinterpret_cast< wxMenu * >(argp1);
40155 ecode2 = SWIG_AsVal_int(obj1, &val2);
40156 if (!SWIG_IsOK(ecode2)) {
40157 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
40158 }
40159 arg2 = static_cast< int >(val2);
40160 {
40161 arg3 = wxString_in_helper(obj2);
40162 if (arg3 == NULL) SWIG_fail;
40163 temp3 = true;
40164 }
40165 {
40166 PyThreadState* __tstate = wxPyBeginAllowThreads();
40167 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
40168 wxPyEndAllowThreads(__tstate);
40169 if (PyErr_Occurred()) SWIG_fail;
40170 }
40171 resultobj = SWIG_Py_Void();
40172 {
40173 if (temp3)
40174 delete arg3;
40175 }
40176 return resultobj;
40177 fail:
40178 {
40179 if (temp3)
40180 delete arg3;
40181 }
40182 return NULL;
40183 }
40184
40185
40186 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40187 PyObject *resultobj = 0;
40188 wxMenu *arg1 = (wxMenu *) 0 ;
40189 int arg2 ;
40190 wxString result;
40191 void *argp1 = 0 ;
40192 int res1 = 0 ;
40193 int val2 ;
40194 int ecode2 = 0 ;
40195 PyObject * obj0 = 0 ;
40196 PyObject * obj1 = 0 ;
40197 char * kwnames[] = {
40198 (char *) "self",(char *) "id", NULL
40199 };
40200
40201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
40202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40203 if (!SWIG_IsOK(res1)) {
40204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
40205 }
40206 arg1 = reinterpret_cast< wxMenu * >(argp1);
40207 ecode2 = SWIG_AsVal_int(obj1, &val2);
40208 if (!SWIG_IsOK(ecode2)) {
40209 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
40210 }
40211 arg2 = static_cast< int >(val2);
40212 {
40213 PyThreadState* __tstate = wxPyBeginAllowThreads();
40214 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
40215 wxPyEndAllowThreads(__tstate);
40216 if (PyErr_Occurred()) SWIG_fail;
40217 }
40218 {
40219 #if wxUSE_UNICODE
40220 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40221 #else
40222 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40223 #endif
40224 }
40225 return resultobj;
40226 fail:
40227 return NULL;
40228 }
40229
40230
40231 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40232 PyObject *resultobj = 0;
40233 wxMenu *arg1 = (wxMenu *) 0 ;
40234 wxString *arg2 = 0 ;
40235 void *argp1 = 0 ;
40236 int res1 = 0 ;
40237 bool temp2 = false ;
40238 PyObject * obj0 = 0 ;
40239 PyObject * obj1 = 0 ;
40240 char * kwnames[] = {
40241 (char *) "self",(char *) "title", NULL
40242 };
40243
40244 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
40245 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40246 if (!SWIG_IsOK(res1)) {
40247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
40248 }
40249 arg1 = reinterpret_cast< wxMenu * >(argp1);
40250 {
40251 arg2 = wxString_in_helper(obj1);
40252 if (arg2 == NULL) SWIG_fail;
40253 temp2 = true;
40254 }
40255 {
40256 PyThreadState* __tstate = wxPyBeginAllowThreads();
40257 (arg1)->SetTitle((wxString const &)*arg2);
40258 wxPyEndAllowThreads(__tstate);
40259 if (PyErr_Occurred()) SWIG_fail;
40260 }
40261 resultobj = SWIG_Py_Void();
40262 {
40263 if (temp2)
40264 delete arg2;
40265 }
40266 return resultobj;
40267 fail:
40268 {
40269 if (temp2)
40270 delete arg2;
40271 }
40272 return NULL;
40273 }
40274
40275
40276 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40277 PyObject *resultobj = 0;
40278 wxMenu *arg1 = (wxMenu *) 0 ;
40279 wxString result;
40280 void *argp1 = 0 ;
40281 int res1 = 0 ;
40282 PyObject *swig_obj[1] ;
40283
40284 if (!args) SWIG_fail;
40285 swig_obj[0] = args;
40286 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40287 if (!SWIG_IsOK(res1)) {
40288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40289 }
40290 arg1 = reinterpret_cast< wxMenu * >(argp1);
40291 {
40292 PyThreadState* __tstate = wxPyBeginAllowThreads();
40293 result = ((wxMenu const *)arg1)->GetTitle();
40294 wxPyEndAllowThreads(__tstate);
40295 if (PyErr_Occurred()) SWIG_fail;
40296 }
40297 {
40298 #if wxUSE_UNICODE
40299 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40300 #else
40301 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40302 #endif
40303 }
40304 return resultobj;
40305 fail:
40306 return NULL;
40307 }
40308
40309
40310 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40311 PyObject *resultobj = 0;
40312 wxMenu *arg1 = (wxMenu *) 0 ;
40313 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
40314 void *argp1 = 0 ;
40315 int res1 = 0 ;
40316 void *argp2 = 0 ;
40317 int res2 = 0 ;
40318 PyObject * obj0 = 0 ;
40319 PyObject * obj1 = 0 ;
40320 char * kwnames[] = {
40321 (char *) "self",(char *) "handler", NULL
40322 };
40323
40324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
40325 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40326 if (!SWIG_IsOK(res1)) {
40327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
40328 }
40329 arg1 = reinterpret_cast< wxMenu * >(argp1);
40330 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40331 if (!SWIG_IsOK(res2)) {
40332 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40333 }
40334 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40335 {
40336 PyThreadState* __tstate = wxPyBeginAllowThreads();
40337 (arg1)->SetEventHandler(arg2);
40338 wxPyEndAllowThreads(__tstate);
40339 if (PyErr_Occurred()) SWIG_fail;
40340 }
40341 resultobj = SWIG_Py_Void();
40342 return resultobj;
40343 fail:
40344 return NULL;
40345 }
40346
40347
40348 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40349 PyObject *resultobj = 0;
40350 wxMenu *arg1 = (wxMenu *) 0 ;
40351 wxEvtHandler *result = 0 ;
40352 void *argp1 = 0 ;
40353 int res1 = 0 ;
40354 PyObject *swig_obj[1] ;
40355
40356 if (!args) SWIG_fail;
40357 swig_obj[0] = args;
40358 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40359 if (!SWIG_IsOK(res1)) {
40360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
40361 }
40362 arg1 = reinterpret_cast< wxMenu * >(argp1);
40363 {
40364 PyThreadState* __tstate = wxPyBeginAllowThreads();
40365 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
40366 wxPyEndAllowThreads(__tstate);
40367 if (PyErr_Occurred()) SWIG_fail;
40368 }
40369 {
40370 resultobj = wxPyMake_wxObject(result, 0);
40371 }
40372 return resultobj;
40373 fail:
40374 return NULL;
40375 }
40376
40377
40378 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40379 PyObject *resultobj = 0;
40380 wxMenu *arg1 = (wxMenu *) 0 ;
40381 wxWindow *arg2 = (wxWindow *) 0 ;
40382 void *argp1 = 0 ;
40383 int res1 = 0 ;
40384 void *argp2 = 0 ;
40385 int res2 = 0 ;
40386 PyObject * obj0 = 0 ;
40387 PyObject * obj1 = 0 ;
40388 char * kwnames[] = {
40389 (char *) "self",(char *) "win", NULL
40390 };
40391
40392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
40393 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40394 if (!SWIG_IsOK(res1)) {
40395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
40396 }
40397 arg1 = reinterpret_cast< wxMenu * >(argp1);
40398 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
40399 if (!SWIG_IsOK(res2)) {
40400 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
40401 }
40402 arg2 = reinterpret_cast< wxWindow * >(argp2);
40403 {
40404 PyThreadState* __tstate = wxPyBeginAllowThreads();
40405 (arg1)->SetInvokingWindow(arg2);
40406 wxPyEndAllowThreads(__tstate);
40407 if (PyErr_Occurred()) SWIG_fail;
40408 }
40409 resultobj = SWIG_Py_Void();
40410 return resultobj;
40411 fail:
40412 return NULL;
40413 }
40414
40415
40416 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40417 PyObject *resultobj = 0;
40418 wxMenu *arg1 = (wxMenu *) 0 ;
40419 wxWindow *result = 0 ;
40420 void *argp1 = 0 ;
40421 int res1 = 0 ;
40422 PyObject *swig_obj[1] ;
40423
40424 if (!args) SWIG_fail;
40425 swig_obj[0] = args;
40426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40427 if (!SWIG_IsOK(res1)) {
40428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
40429 }
40430 arg1 = reinterpret_cast< wxMenu * >(argp1);
40431 {
40432 PyThreadState* __tstate = wxPyBeginAllowThreads();
40433 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
40434 wxPyEndAllowThreads(__tstate);
40435 if (PyErr_Occurred()) SWIG_fail;
40436 }
40437 {
40438 resultobj = wxPyMake_wxObject(result, 0);
40439 }
40440 return resultobj;
40441 fail:
40442 return NULL;
40443 }
40444
40445
40446 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40447 PyObject *resultobj = 0;
40448 wxMenu *arg1 = (wxMenu *) 0 ;
40449 long result;
40450 void *argp1 = 0 ;
40451 int res1 = 0 ;
40452 PyObject *swig_obj[1] ;
40453
40454 if (!args) SWIG_fail;
40455 swig_obj[0] = args;
40456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40457 if (!SWIG_IsOK(res1)) {
40458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40459 }
40460 arg1 = reinterpret_cast< wxMenu * >(argp1);
40461 {
40462 PyThreadState* __tstate = wxPyBeginAllowThreads();
40463 result = (long)((wxMenu const *)arg1)->GetStyle();
40464 wxPyEndAllowThreads(__tstate);
40465 if (PyErr_Occurred()) SWIG_fail;
40466 }
40467 resultobj = SWIG_From_long(static_cast< long >(result));
40468 return resultobj;
40469 fail:
40470 return NULL;
40471 }
40472
40473
40474 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40475 PyObject *resultobj = 0;
40476 wxMenu *arg1 = (wxMenu *) 0 ;
40477 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
40478 void *argp1 = 0 ;
40479 int res1 = 0 ;
40480 void *argp2 = 0 ;
40481 int res2 = 0 ;
40482 PyObject * obj0 = 0 ;
40483 PyObject * obj1 = 0 ;
40484 char * kwnames[] = {
40485 (char *) "self",(char *) "source", NULL
40486 };
40487
40488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
40489 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40490 if (!SWIG_IsOK(res1)) {
40491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
40492 }
40493 arg1 = reinterpret_cast< wxMenu * >(argp1);
40494 if (obj1) {
40495 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40496 if (!SWIG_IsOK(res2)) {
40497 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40498 }
40499 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40500 }
40501 {
40502 PyThreadState* __tstate = wxPyBeginAllowThreads();
40503 (arg1)->UpdateUI(arg2);
40504 wxPyEndAllowThreads(__tstate);
40505 if (PyErr_Occurred()) SWIG_fail;
40506 }
40507 resultobj = SWIG_Py_Void();
40508 return resultobj;
40509 fail:
40510 return NULL;
40511 }
40512
40513
40514 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40515 PyObject *resultobj = 0;
40516 wxMenu *arg1 = (wxMenu *) 0 ;
40517 wxMenuBar *result = 0 ;
40518 void *argp1 = 0 ;
40519 int res1 = 0 ;
40520 PyObject *swig_obj[1] ;
40521
40522 if (!args) SWIG_fail;
40523 swig_obj[0] = args;
40524 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40525 if (!SWIG_IsOK(res1)) {
40526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
40527 }
40528 arg1 = reinterpret_cast< wxMenu * >(argp1);
40529 {
40530 PyThreadState* __tstate = wxPyBeginAllowThreads();
40531 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
40532 wxPyEndAllowThreads(__tstate);
40533 if (PyErr_Occurred()) SWIG_fail;
40534 }
40535 {
40536 resultobj = wxPyMake_wxObject(result, (bool)0);
40537 }
40538 return resultobj;
40539 fail:
40540 return NULL;
40541 }
40542
40543
40544 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40545 PyObject *resultobj = 0;
40546 wxMenu *arg1 = (wxMenu *) 0 ;
40547 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
40548 void *argp1 = 0 ;
40549 int res1 = 0 ;
40550 void *argp2 = 0 ;
40551 int res2 = 0 ;
40552 PyObject * obj0 = 0 ;
40553 PyObject * obj1 = 0 ;
40554 char * kwnames[] = {
40555 (char *) "self",(char *) "menubar", NULL
40556 };
40557
40558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
40559 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40560 if (!SWIG_IsOK(res1)) {
40561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
40562 }
40563 arg1 = reinterpret_cast< wxMenu * >(argp1);
40564 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
40565 if (!SWIG_IsOK(res2)) {
40566 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
40567 }
40568 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
40569 {
40570 PyThreadState* __tstate = wxPyBeginAllowThreads();
40571 (arg1)->Attach(arg2);
40572 wxPyEndAllowThreads(__tstate);
40573 if (PyErr_Occurred()) SWIG_fail;
40574 }
40575 resultobj = SWIG_Py_Void();
40576 return resultobj;
40577 fail:
40578 return NULL;
40579 }
40580
40581
40582 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40583 PyObject *resultobj = 0;
40584 wxMenu *arg1 = (wxMenu *) 0 ;
40585 void *argp1 = 0 ;
40586 int res1 = 0 ;
40587 PyObject *swig_obj[1] ;
40588
40589 if (!args) SWIG_fail;
40590 swig_obj[0] = args;
40591 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40592 if (!SWIG_IsOK(res1)) {
40593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
40594 }
40595 arg1 = reinterpret_cast< wxMenu * >(argp1);
40596 {
40597 PyThreadState* __tstate = wxPyBeginAllowThreads();
40598 (arg1)->Detach();
40599 wxPyEndAllowThreads(__tstate);
40600 if (PyErr_Occurred()) SWIG_fail;
40601 }
40602 resultobj = SWIG_Py_Void();
40603 return resultobj;
40604 fail:
40605 return NULL;
40606 }
40607
40608
40609 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40610 PyObject *resultobj = 0;
40611 wxMenu *arg1 = (wxMenu *) 0 ;
40612 bool result;
40613 void *argp1 = 0 ;
40614 int res1 = 0 ;
40615 PyObject *swig_obj[1] ;
40616
40617 if (!args) SWIG_fail;
40618 swig_obj[0] = args;
40619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40620 if (!SWIG_IsOK(res1)) {
40621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
40622 }
40623 arg1 = reinterpret_cast< wxMenu * >(argp1);
40624 {
40625 PyThreadState* __tstate = wxPyBeginAllowThreads();
40626 result = (bool)((wxMenu const *)arg1)->IsAttached();
40627 wxPyEndAllowThreads(__tstate);
40628 if (PyErr_Occurred()) SWIG_fail;
40629 }
40630 {
40631 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40632 }
40633 return resultobj;
40634 fail:
40635 return NULL;
40636 }
40637
40638
40639 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40640 PyObject *resultobj = 0;
40641 wxMenu *arg1 = (wxMenu *) 0 ;
40642 wxMenu *arg2 = (wxMenu *) 0 ;
40643 void *argp1 = 0 ;
40644 int res1 = 0 ;
40645 void *argp2 = 0 ;
40646 int res2 = 0 ;
40647 PyObject * obj0 = 0 ;
40648 PyObject * obj1 = 0 ;
40649 char * kwnames[] = {
40650 (char *) "self",(char *) "parent", NULL
40651 };
40652
40653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
40654 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40655 if (!SWIG_IsOK(res1)) {
40656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
40657 }
40658 arg1 = reinterpret_cast< wxMenu * >(argp1);
40659 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
40660 if (!SWIG_IsOK(res2)) {
40661 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
40662 }
40663 arg2 = reinterpret_cast< wxMenu * >(argp2);
40664 {
40665 PyThreadState* __tstate = wxPyBeginAllowThreads();
40666 (arg1)->SetParent(arg2);
40667 wxPyEndAllowThreads(__tstate);
40668 if (PyErr_Occurred()) SWIG_fail;
40669 }
40670 resultobj = SWIG_Py_Void();
40671 return resultobj;
40672 fail:
40673 return NULL;
40674 }
40675
40676
40677 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40678 PyObject *resultobj = 0;
40679 wxMenu *arg1 = (wxMenu *) 0 ;
40680 wxMenu *result = 0 ;
40681 void *argp1 = 0 ;
40682 int res1 = 0 ;
40683 PyObject *swig_obj[1] ;
40684
40685 if (!args) SWIG_fail;
40686 swig_obj[0] = args;
40687 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40688 if (!SWIG_IsOK(res1)) {
40689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
40690 }
40691 arg1 = reinterpret_cast< wxMenu * >(argp1);
40692 {
40693 PyThreadState* __tstate = wxPyBeginAllowThreads();
40694 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
40695 wxPyEndAllowThreads(__tstate);
40696 if (PyErr_Occurred()) SWIG_fail;
40697 }
40698 {
40699 resultobj = wxPyMake_wxObject(result, 0);
40700 }
40701 return resultobj;
40702 fail:
40703 return NULL;
40704 }
40705
40706
40707 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40708 PyObject *obj;
40709 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
40710 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
40711 return SWIG_Py_Void();
40712 }
40713
40714 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40715 return SWIG_Python_InitShadowInstance(args);
40716 }
40717
40718 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40719 PyObject *resultobj = 0;
40720 long arg1 = (long) 0 ;
40721 wxMenuBar *result = 0 ;
40722 long val1 ;
40723 int ecode1 = 0 ;
40724 PyObject * obj0 = 0 ;
40725 char * kwnames[] = {
40726 (char *) "style", NULL
40727 };
40728
40729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
40730 if (obj0) {
40731 ecode1 = SWIG_AsVal_long(obj0, &val1);
40732 if (!SWIG_IsOK(ecode1)) {
40733 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
40734 }
40735 arg1 = static_cast< long >(val1);
40736 }
40737 {
40738 if (!wxPyCheckForApp()) SWIG_fail;
40739 PyThreadState* __tstate = wxPyBeginAllowThreads();
40740 result = (wxMenuBar *)new wxMenuBar(arg1);
40741 wxPyEndAllowThreads(__tstate);
40742 if (PyErr_Occurred()) SWIG_fail;
40743 }
40744 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
40745 return resultobj;
40746 fail:
40747 return NULL;
40748 }
40749
40750
40751 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40752 PyObject *resultobj = 0;
40753 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40754 wxMenu *arg2 = (wxMenu *) 0 ;
40755 wxString *arg3 = 0 ;
40756 bool result;
40757 void *argp1 = 0 ;
40758 int res1 = 0 ;
40759 void *argp2 = 0 ;
40760 int res2 = 0 ;
40761 bool temp3 = false ;
40762 PyObject * obj0 = 0 ;
40763 PyObject * obj1 = 0 ;
40764 PyObject * obj2 = 0 ;
40765 char * kwnames[] = {
40766 (char *) "self",(char *) "menu",(char *) "title", NULL
40767 };
40768
40769 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40770 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40771 if (!SWIG_IsOK(res1)) {
40772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40773 }
40774 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40775 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
40776 if (!SWIG_IsOK(res2)) {
40777 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
40778 }
40779 arg2 = reinterpret_cast< wxMenu * >(argp2);
40780 {
40781 arg3 = wxString_in_helper(obj2);
40782 if (arg3 == NULL) SWIG_fail;
40783 temp3 = true;
40784 }
40785 {
40786 PyThreadState* __tstate = wxPyBeginAllowThreads();
40787 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
40788 wxPyEndAllowThreads(__tstate);
40789 if (PyErr_Occurred()) SWIG_fail;
40790 }
40791 {
40792 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40793 }
40794 {
40795 if (temp3)
40796 delete arg3;
40797 }
40798 return resultobj;
40799 fail:
40800 {
40801 if (temp3)
40802 delete arg3;
40803 }
40804 return NULL;
40805 }
40806
40807
40808 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40809 PyObject *resultobj = 0;
40810 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40811 size_t arg2 ;
40812 wxMenu *arg3 = (wxMenu *) 0 ;
40813 wxString *arg4 = 0 ;
40814 bool result;
40815 void *argp1 = 0 ;
40816 int res1 = 0 ;
40817 size_t val2 ;
40818 int ecode2 = 0 ;
40819 void *argp3 = 0 ;
40820 int res3 = 0 ;
40821 bool temp4 = false ;
40822 PyObject * obj0 = 0 ;
40823 PyObject * obj1 = 0 ;
40824 PyObject * obj2 = 0 ;
40825 PyObject * obj3 = 0 ;
40826 char * kwnames[] = {
40827 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
40828 };
40829
40830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40831 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40832 if (!SWIG_IsOK(res1)) {
40833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40834 }
40835 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40836 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40837 if (!SWIG_IsOK(ecode2)) {
40838 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
40839 }
40840 arg2 = static_cast< size_t >(val2);
40841 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
40842 if (!SWIG_IsOK(res3)) {
40843 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
40844 }
40845 arg3 = reinterpret_cast< wxMenu * >(argp3);
40846 {
40847 arg4 = wxString_in_helper(obj3);
40848 if (arg4 == NULL) SWIG_fail;
40849 temp4 = true;
40850 }
40851 {
40852 PyThreadState* __tstate = wxPyBeginAllowThreads();
40853 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
40854 wxPyEndAllowThreads(__tstate);
40855 if (PyErr_Occurred()) SWIG_fail;
40856 }
40857 {
40858 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40859 }
40860 {
40861 if (temp4)
40862 delete arg4;
40863 }
40864 return resultobj;
40865 fail:
40866 {
40867 if (temp4)
40868 delete arg4;
40869 }
40870 return NULL;
40871 }
40872
40873
40874 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40875 PyObject *resultobj = 0;
40876 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40877 size_t result;
40878 void *argp1 = 0 ;
40879 int res1 = 0 ;
40880 PyObject *swig_obj[1] ;
40881
40882 if (!args) SWIG_fail;
40883 swig_obj[0] = args;
40884 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40885 if (!SWIG_IsOK(res1)) {
40886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
40887 }
40888 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40889 {
40890 PyThreadState* __tstate = wxPyBeginAllowThreads();
40891 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
40892 wxPyEndAllowThreads(__tstate);
40893 if (PyErr_Occurred()) SWIG_fail;
40894 }
40895 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
40896 return resultobj;
40897 fail:
40898 return NULL;
40899 }
40900
40901
40902 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40903 PyObject *resultobj = 0;
40904 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40905 size_t arg2 ;
40906 wxMenu *result = 0 ;
40907 void *argp1 = 0 ;
40908 int res1 = 0 ;
40909 size_t val2 ;
40910 int ecode2 = 0 ;
40911 PyObject * obj0 = 0 ;
40912 PyObject * obj1 = 0 ;
40913 char * kwnames[] = {
40914 (char *) "self",(char *) "pos", NULL
40915 };
40916
40917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
40918 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40919 if (!SWIG_IsOK(res1)) {
40920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
40921 }
40922 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40923 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40924 if (!SWIG_IsOK(ecode2)) {
40925 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
40926 }
40927 arg2 = static_cast< size_t >(val2);
40928 {
40929 PyThreadState* __tstate = wxPyBeginAllowThreads();
40930 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
40931 wxPyEndAllowThreads(__tstate);
40932 if (PyErr_Occurred()) SWIG_fail;
40933 }
40934 {
40935 resultobj = wxPyMake_wxObject(result, 0);
40936 }
40937 return resultobj;
40938 fail:
40939 return NULL;
40940 }
40941
40942
40943 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40944 PyObject *resultobj = 0;
40945 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40946 size_t arg2 ;
40947 wxMenu *arg3 = (wxMenu *) 0 ;
40948 wxString *arg4 = 0 ;
40949 wxMenu *result = 0 ;
40950 void *argp1 = 0 ;
40951 int res1 = 0 ;
40952 size_t val2 ;
40953 int ecode2 = 0 ;
40954 void *argp3 = 0 ;
40955 int res3 = 0 ;
40956 bool temp4 = false ;
40957 PyObject * obj0 = 0 ;
40958 PyObject * obj1 = 0 ;
40959 PyObject * obj2 = 0 ;
40960 PyObject * obj3 = 0 ;
40961 char * kwnames[] = {
40962 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
40963 };
40964
40965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40966 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40967 if (!SWIG_IsOK(res1)) {
40968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40969 }
40970 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40971 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40972 if (!SWIG_IsOK(ecode2)) {
40973 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
40974 }
40975 arg2 = static_cast< size_t >(val2);
40976 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
40977 if (!SWIG_IsOK(res3)) {
40978 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
40979 }
40980 arg3 = reinterpret_cast< wxMenu * >(argp3);
40981 {
40982 arg4 = wxString_in_helper(obj3);
40983 if (arg4 == NULL) SWIG_fail;
40984 temp4 = true;
40985 }
40986 {
40987 PyThreadState* __tstate = wxPyBeginAllowThreads();
40988 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
40989 wxPyEndAllowThreads(__tstate);
40990 if (PyErr_Occurred()) SWIG_fail;
40991 }
40992 {
40993 resultobj = wxPyMake_wxObject(result, 0);
40994 }
40995 {
40996 if (temp4)
40997 delete arg4;
40998 }
40999 return resultobj;
41000 fail:
41001 {
41002 if (temp4)
41003 delete arg4;
41004 }
41005 return NULL;
41006 }
41007
41008
41009 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41010 PyObject *resultobj = 0;
41011 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41012 size_t arg2 ;
41013 wxMenu *result = 0 ;
41014 void *argp1 = 0 ;
41015 int res1 = 0 ;
41016 size_t val2 ;
41017 int ecode2 = 0 ;
41018 PyObject * obj0 = 0 ;
41019 PyObject * obj1 = 0 ;
41020 char * kwnames[] = {
41021 (char *) "self",(char *) "pos", NULL
41022 };
41023
41024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
41025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41026 if (!SWIG_IsOK(res1)) {
41027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41028 }
41029 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41030 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41031 if (!SWIG_IsOK(ecode2)) {
41032 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
41033 }
41034 arg2 = static_cast< size_t >(val2);
41035 {
41036 PyThreadState* __tstate = wxPyBeginAllowThreads();
41037 result = (wxMenu *)(arg1)->Remove(arg2);
41038 wxPyEndAllowThreads(__tstate);
41039 if (PyErr_Occurred()) SWIG_fail;
41040 }
41041 {
41042 resultobj = wxPyMake_wxObject(result, 0);
41043 }
41044 return resultobj;
41045 fail:
41046 return NULL;
41047 }
41048
41049
41050 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41051 PyObject *resultobj = 0;
41052 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41053 size_t arg2 ;
41054 bool arg3 ;
41055 void *argp1 = 0 ;
41056 int res1 = 0 ;
41057 size_t val2 ;
41058 int ecode2 = 0 ;
41059 bool val3 ;
41060 int ecode3 = 0 ;
41061 PyObject * obj0 = 0 ;
41062 PyObject * obj1 = 0 ;
41063 PyObject * obj2 = 0 ;
41064 char * kwnames[] = {
41065 (char *) "self",(char *) "pos",(char *) "enable", NULL
41066 };
41067
41068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41069 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41070 if (!SWIG_IsOK(res1)) {
41071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41072 }
41073 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41074 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41075 if (!SWIG_IsOK(ecode2)) {
41076 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
41077 }
41078 arg2 = static_cast< size_t >(val2);
41079 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41080 if (!SWIG_IsOK(ecode3)) {
41081 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
41082 }
41083 arg3 = static_cast< bool >(val3);
41084 {
41085 PyThreadState* __tstate = wxPyBeginAllowThreads();
41086 (arg1)->EnableTop(arg2,arg3);
41087 wxPyEndAllowThreads(__tstate);
41088 if (PyErr_Occurred()) SWIG_fail;
41089 }
41090 resultobj = SWIG_Py_Void();
41091 return resultobj;
41092 fail:
41093 return NULL;
41094 }
41095
41096
41097 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41098 PyObject *resultobj = 0;
41099 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41100 size_t arg2 ;
41101 bool result;
41102 void *argp1 = 0 ;
41103 int res1 = 0 ;
41104 size_t val2 ;
41105 int ecode2 = 0 ;
41106 PyObject * obj0 = 0 ;
41107 PyObject * obj1 = 0 ;
41108 char * kwnames[] = {
41109 (char *) "self",(char *) "pos", NULL
41110 };
41111
41112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
41113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41114 if (!SWIG_IsOK(res1)) {
41115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41116 }
41117 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41118 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41119 if (!SWIG_IsOK(ecode2)) {
41120 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
41121 }
41122 arg2 = static_cast< size_t >(val2);
41123 {
41124 PyThreadState* __tstate = wxPyBeginAllowThreads();
41125 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
41126 wxPyEndAllowThreads(__tstate);
41127 if (PyErr_Occurred()) SWIG_fail;
41128 }
41129 {
41130 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41131 }
41132 return resultobj;
41133 fail:
41134 return NULL;
41135 }
41136
41137
41138 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41139 PyObject *resultobj = 0;
41140 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41141 size_t arg2 ;
41142 wxString *arg3 = 0 ;
41143 void *argp1 = 0 ;
41144 int res1 = 0 ;
41145 size_t val2 ;
41146 int ecode2 = 0 ;
41147 bool temp3 = false ;
41148 PyObject * obj0 = 0 ;
41149 PyObject * obj1 = 0 ;
41150 PyObject * obj2 = 0 ;
41151 char * kwnames[] = {
41152 (char *) "self",(char *) "pos",(char *) "label", NULL
41153 };
41154
41155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41156 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41157 if (!SWIG_IsOK(res1)) {
41158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41159 }
41160 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41161 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41162 if (!SWIG_IsOK(ecode2)) {
41163 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41164 }
41165 arg2 = static_cast< size_t >(val2);
41166 {
41167 arg3 = wxString_in_helper(obj2);
41168 if (arg3 == NULL) SWIG_fail;
41169 temp3 = true;
41170 }
41171 {
41172 PyThreadState* __tstate = wxPyBeginAllowThreads();
41173 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
41174 wxPyEndAllowThreads(__tstate);
41175 if (PyErr_Occurred()) SWIG_fail;
41176 }
41177 resultobj = SWIG_Py_Void();
41178 {
41179 if (temp3)
41180 delete arg3;
41181 }
41182 return resultobj;
41183 fail:
41184 {
41185 if (temp3)
41186 delete arg3;
41187 }
41188 return NULL;
41189 }
41190
41191
41192 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41193 PyObject *resultobj = 0;
41194 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41195 size_t arg2 ;
41196 wxString result;
41197 void *argp1 = 0 ;
41198 int res1 = 0 ;
41199 size_t val2 ;
41200 int ecode2 = 0 ;
41201 PyObject * obj0 = 0 ;
41202 PyObject * obj1 = 0 ;
41203 char * kwnames[] = {
41204 (char *) "self",(char *) "pos", NULL
41205 };
41206
41207 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
41208 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41209 if (!SWIG_IsOK(res1)) {
41210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41211 }
41212 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41213 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41214 if (!SWIG_IsOK(ecode2)) {
41215 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41216 }
41217 arg2 = static_cast< size_t >(val2);
41218 {
41219 PyThreadState* __tstate = wxPyBeginAllowThreads();
41220 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
41221 wxPyEndAllowThreads(__tstate);
41222 if (PyErr_Occurred()) SWIG_fail;
41223 }
41224 {
41225 #if wxUSE_UNICODE
41226 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41227 #else
41228 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41229 #endif
41230 }
41231 return resultobj;
41232 fail:
41233 return NULL;
41234 }
41235
41236
41237 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41238 PyObject *resultobj = 0;
41239 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41240 wxString *arg2 = 0 ;
41241 wxString *arg3 = 0 ;
41242 int result;
41243 void *argp1 = 0 ;
41244 int res1 = 0 ;
41245 bool temp2 = false ;
41246 bool temp3 = false ;
41247 PyObject * obj0 = 0 ;
41248 PyObject * obj1 = 0 ;
41249 PyObject * obj2 = 0 ;
41250 char * kwnames[] = {
41251 (char *) "self",(char *) "menu",(char *) "item", NULL
41252 };
41253
41254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41255 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41256 if (!SWIG_IsOK(res1)) {
41257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41258 }
41259 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41260 {
41261 arg2 = wxString_in_helper(obj1);
41262 if (arg2 == NULL) SWIG_fail;
41263 temp2 = true;
41264 }
41265 {
41266 arg3 = wxString_in_helper(obj2);
41267 if (arg3 == NULL) SWIG_fail;
41268 temp3 = true;
41269 }
41270 {
41271 PyThreadState* __tstate = wxPyBeginAllowThreads();
41272 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
41273 wxPyEndAllowThreads(__tstate);
41274 if (PyErr_Occurred()) SWIG_fail;
41275 }
41276 resultobj = SWIG_From_int(static_cast< int >(result));
41277 {
41278 if (temp2)
41279 delete arg2;
41280 }
41281 {
41282 if (temp3)
41283 delete arg3;
41284 }
41285 return resultobj;
41286 fail:
41287 {
41288 if (temp2)
41289 delete arg2;
41290 }
41291 {
41292 if (temp3)
41293 delete arg3;
41294 }
41295 return NULL;
41296 }
41297
41298
41299 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41300 PyObject *resultobj = 0;
41301 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41302 int arg2 ;
41303 wxMenuItem *result = 0 ;
41304 void *argp1 = 0 ;
41305 int res1 = 0 ;
41306 int val2 ;
41307 int ecode2 = 0 ;
41308 PyObject * obj0 = 0 ;
41309 PyObject * obj1 = 0 ;
41310 char * kwnames[] = {
41311 (char *) "self",(char *) "id", NULL
41312 };
41313
41314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
41315 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41316 if (!SWIG_IsOK(res1)) {
41317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41318 }
41319 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41320 ecode2 = SWIG_AsVal_int(obj1, &val2);
41321 if (!SWIG_IsOK(ecode2)) {
41322 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
41323 }
41324 arg2 = static_cast< int >(val2);
41325 {
41326 PyThreadState* __tstate = wxPyBeginAllowThreads();
41327 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
41328 wxPyEndAllowThreads(__tstate);
41329 if (PyErr_Occurred()) SWIG_fail;
41330 }
41331 {
41332 resultobj = wxPyMake_wxObject(result, (bool)0);
41333 }
41334 return resultobj;
41335 fail:
41336 return NULL;
41337 }
41338
41339
41340 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41341 PyObject *resultobj = 0;
41342 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41343 wxString *arg2 = 0 ;
41344 int result;
41345 void *argp1 = 0 ;
41346 int res1 = 0 ;
41347 bool temp2 = false ;
41348 PyObject * obj0 = 0 ;
41349 PyObject * obj1 = 0 ;
41350 char * kwnames[] = {
41351 (char *) "self",(char *) "title", NULL
41352 };
41353
41354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41355 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41356 if (!SWIG_IsOK(res1)) {
41357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41358 }
41359 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41360 {
41361 arg2 = wxString_in_helper(obj1);
41362 if (arg2 == NULL) SWIG_fail;
41363 temp2 = true;
41364 }
41365 {
41366 PyThreadState* __tstate = wxPyBeginAllowThreads();
41367 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
41368 wxPyEndAllowThreads(__tstate);
41369 if (PyErr_Occurred()) SWIG_fail;
41370 }
41371 resultobj = SWIG_From_int(static_cast< int >(result));
41372 {
41373 if (temp2)
41374 delete arg2;
41375 }
41376 return resultobj;
41377 fail:
41378 {
41379 if (temp2)
41380 delete arg2;
41381 }
41382 return NULL;
41383 }
41384
41385
41386 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41387 PyObject *resultobj = 0;
41388 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41389 int arg2 ;
41390 bool arg3 ;
41391 void *argp1 = 0 ;
41392 int res1 = 0 ;
41393 int val2 ;
41394 int ecode2 = 0 ;
41395 bool val3 ;
41396 int ecode3 = 0 ;
41397 PyObject * obj0 = 0 ;
41398 PyObject * obj1 = 0 ;
41399 PyObject * obj2 = 0 ;
41400 char * kwnames[] = {
41401 (char *) "self",(char *) "id",(char *) "enable", NULL
41402 };
41403
41404 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41405 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41406 if (!SWIG_IsOK(res1)) {
41407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41408 }
41409 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41410 ecode2 = SWIG_AsVal_int(obj1, &val2);
41411 if (!SWIG_IsOK(ecode2)) {
41412 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
41413 }
41414 arg2 = static_cast< int >(val2);
41415 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41416 if (!SWIG_IsOK(ecode3)) {
41417 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
41418 }
41419 arg3 = static_cast< bool >(val3);
41420 {
41421 PyThreadState* __tstate = wxPyBeginAllowThreads();
41422 (arg1)->Enable(arg2,arg3);
41423 wxPyEndAllowThreads(__tstate);
41424 if (PyErr_Occurred()) SWIG_fail;
41425 }
41426 resultobj = SWIG_Py_Void();
41427 return resultobj;
41428 fail:
41429 return NULL;
41430 }
41431
41432
41433 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41434 PyObject *resultobj = 0;
41435 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41436 int arg2 ;
41437 bool arg3 ;
41438 void *argp1 = 0 ;
41439 int res1 = 0 ;
41440 int val2 ;
41441 int ecode2 = 0 ;
41442 bool val3 ;
41443 int ecode3 = 0 ;
41444 PyObject * obj0 = 0 ;
41445 PyObject * obj1 = 0 ;
41446 PyObject * obj2 = 0 ;
41447 char * kwnames[] = {
41448 (char *) "self",(char *) "id",(char *) "check", NULL
41449 };
41450
41451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41452 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41453 if (!SWIG_IsOK(res1)) {
41454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41455 }
41456 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41457 ecode2 = SWIG_AsVal_int(obj1, &val2);
41458 if (!SWIG_IsOK(ecode2)) {
41459 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
41460 }
41461 arg2 = static_cast< int >(val2);
41462 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41463 if (!SWIG_IsOK(ecode3)) {
41464 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
41465 }
41466 arg3 = static_cast< bool >(val3);
41467 {
41468 PyThreadState* __tstate = wxPyBeginAllowThreads();
41469 (arg1)->Check(arg2,arg3);
41470 wxPyEndAllowThreads(__tstate);
41471 if (PyErr_Occurred()) SWIG_fail;
41472 }
41473 resultobj = SWIG_Py_Void();
41474 return resultobj;
41475 fail:
41476 return NULL;
41477 }
41478
41479
41480 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41481 PyObject *resultobj = 0;
41482 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41483 int arg2 ;
41484 bool result;
41485 void *argp1 = 0 ;
41486 int res1 = 0 ;
41487 int val2 ;
41488 int ecode2 = 0 ;
41489 PyObject * obj0 = 0 ;
41490 PyObject * obj1 = 0 ;
41491 char * kwnames[] = {
41492 (char *) "self",(char *) "id", NULL
41493 };
41494
41495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
41496 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41497 if (!SWIG_IsOK(res1)) {
41498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41499 }
41500 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41501 ecode2 = SWIG_AsVal_int(obj1, &val2);
41502 if (!SWIG_IsOK(ecode2)) {
41503 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
41504 }
41505 arg2 = static_cast< int >(val2);
41506 {
41507 PyThreadState* __tstate = wxPyBeginAllowThreads();
41508 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
41509 wxPyEndAllowThreads(__tstate);
41510 if (PyErr_Occurred()) SWIG_fail;
41511 }
41512 {
41513 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41514 }
41515 return resultobj;
41516 fail:
41517 return NULL;
41518 }
41519
41520
41521 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41522 PyObject *resultobj = 0;
41523 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41524 int arg2 ;
41525 bool result;
41526 void *argp1 = 0 ;
41527 int res1 = 0 ;
41528 int val2 ;
41529 int ecode2 = 0 ;
41530 PyObject * obj0 = 0 ;
41531 PyObject * obj1 = 0 ;
41532 char * kwnames[] = {
41533 (char *) "self",(char *) "id", NULL
41534 };
41535
41536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
41537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41538 if (!SWIG_IsOK(res1)) {
41539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41540 }
41541 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41542 ecode2 = SWIG_AsVal_int(obj1, &val2);
41543 if (!SWIG_IsOK(ecode2)) {
41544 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
41545 }
41546 arg2 = static_cast< int >(val2);
41547 {
41548 PyThreadState* __tstate = wxPyBeginAllowThreads();
41549 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
41550 wxPyEndAllowThreads(__tstate);
41551 if (PyErr_Occurred()) SWIG_fail;
41552 }
41553 {
41554 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41555 }
41556 return resultobj;
41557 fail:
41558 return NULL;
41559 }
41560
41561
41562 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41563 PyObject *resultobj = 0;
41564 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41565 int arg2 ;
41566 wxString *arg3 = 0 ;
41567 void *argp1 = 0 ;
41568 int res1 = 0 ;
41569 int val2 ;
41570 int ecode2 = 0 ;
41571 bool temp3 = false ;
41572 PyObject * obj0 = 0 ;
41573 PyObject * obj1 = 0 ;
41574 PyObject * obj2 = 0 ;
41575 char * kwnames[] = {
41576 (char *) "self",(char *) "id",(char *) "label", NULL
41577 };
41578
41579 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41580 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41581 if (!SWIG_IsOK(res1)) {
41582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41583 }
41584 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41585 ecode2 = SWIG_AsVal_int(obj1, &val2);
41586 if (!SWIG_IsOK(ecode2)) {
41587 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
41588 }
41589 arg2 = static_cast< int >(val2);
41590 {
41591 arg3 = wxString_in_helper(obj2);
41592 if (arg3 == NULL) SWIG_fail;
41593 temp3 = true;
41594 }
41595 {
41596 PyThreadState* __tstate = wxPyBeginAllowThreads();
41597 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
41598 wxPyEndAllowThreads(__tstate);
41599 if (PyErr_Occurred()) SWIG_fail;
41600 }
41601 resultobj = SWIG_Py_Void();
41602 {
41603 if (temp3)
41604 delete arg3;
41605 }
41606 return resultobj;
41607 fail:
41608 {
41609 if (temp3)
41610 delete arg3;
41611 }
41612 return NULL;
41613 }
41614
41615
41616 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41617 PyObject *resultobj = 0;
41618 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41619 int arg2 ;
41620 wxString result;
41621 void *argp1 = 0 ;
41622 int res1 = 0 ;
41623 int val2 ;
41624 int ecode2 = 0 ;
41625 PyObject * obj0 = 0 ;
41626 PyObject * obj1 = 0 ;
41627 char * kwnames[] = {
41628 (char *) "self",(char *) "id", NULL
41629 };
41630
41631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41632 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41633 if (!SWIG_IsOK(res1)) {
41634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41635 }
41636 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41637 ecode2 = SWIG_AsVal_int(obj1, &val2);
41638 if (!SWIG_IsOK(ecode2)) {
41639 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
41640 }
41641 arg2 = static_cast< int >(val2);
41642 {
41643 PyThreadState* __tstate = wxPyBeginAllowThreads();
41644 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
41645 wxPyEndAllowThreads(__tstate);
41646 if (PyErr_Occurred()) SWIG_fail;
41647 }
41648 {
41649 #if wxUSE_UNICODE
41650 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41651 #else
41652 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41653 #endif
41654 }
41655 return resultobj;
41656 fail:
41657 return NULL;
41658 }
41659
41660
41661 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41662 PyObject *resultobj = 0;
41663 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41664 int arg2 ;
41665 wxString *arg3 = 0 ;
41666 void *argp1 = 0 ;
41667 int res1 = 0 ;
41668 int val2 ;
41669 int ecode2 = 0 ;
41670 bool temp3 = false ;
41671 PyObject * obj0 = 0 ;
41672 PyObject * obj1 = 0 ;
41673 PyObject * obj2 = 0 ;
41674 char * kwnames[] = {
41675 (char *) "self",(char *) "id",(char *) "helpString", NULL
41676 };
41677
41678 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41679 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41680 if (!SWIG_IsOK(res1)) {
41681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41682 }
41683 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41684 ecode2 = SWIG_AsVal_int(obj1, &val2);
41685 if (!SWIG_IsOK(ecode2)) {
41686 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
41687 }
41688 arg2 = static_cast< int >(val2);
41689 {
41690 arg3 = wxString_in_helper(obj2);
41691 if (arg3 == NULL) SWIG_fail;
41692 temp3 = true;
41693 }
41694 {
41695 PyThreadState* __tstate = wxPyBeginAllowThreads();
41696 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
41697 wxPyEndAllowThreads(__tstate);
41698 if (PyErr_Occurred()) SWIG_fail;
41699 }
41700 resultobj = SWIG_Py_Void();
41701 {
41702 if (temp3)
41703 delete arg3;
41704 }
41705 return resultobj;
41706 fail:
41707 {
41708 if (temp3)
41709 delete arg3;
41710 }
41711 return NULL;
41712 }
41713
41714
41715 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41716 PyObject *resultobj = 0;
41717 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41718 int arg2 ;
41719 wxString result;
41720 void *argp1 = 0 ;
41721 int res1 = 0 ;
41722 int val2 ;
41723 int ecode2 = 0 ;
41724 PyObject * obj0 = 0 ;
41725 PyObject * obj1 = 0 ;
41726 char * kwnames[] = {
41727 (char *) "self",(char *) "id", NULL
41728 };
41729
41730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
41731 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41732 if (!SWIG_IsOK(res1)) {
41733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41734 }
41735 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41736 ecode2 = SWIG_AsVal_int(obj1, &val2);
41737 if (!SWIG_IsOK(ecode2)) {
41738 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
41739 }
41740 arg2 = static_cast< int >(val2);
41741 {
41742 PyThreadState* __tstate = wxPyBeginAllowThreads();
41743 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
41744 wxPyEndAllowThreads(__tstate);
41745 if (PyErr_Occurred()) SWIG_fail;
41746 }
41747 {
41748 #if wxUSE_UNICODE
41749 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41750 #else
41751 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41752 #endif
41753 }
41754 return resultobj;
41755 fail:
41756 return NULL;
41757 }
41758
41759
41760 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41761 PyObject *resultobj = 0;
41762 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41763 wxFrame *result = 0 ;
41764 void *argp1 = 0 ;
41765 int res1 = 0 ;
41766 PyObject *swig_obj[1] ;
41767
41768 if (!args) SWIG_fail;
41769 swig_obj[0] = args;
41770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41771 if (!SWIG_IsOK(res1)) {
41772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41773 }
41774 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41775 {
41776 PyThreadState* __tstate = wxPyBeginAllowThreads();
41777 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
41778 wxPyEndAllowThreads(__tstate);
41779 if (PyErr_Occurred()) SWIG_fail;
41780 }
41781 {
41782 resultobj = wxPyMake_wxObject(result, (bool)0);
41783 }
41784 return resultobj;
41785 fail:
41786 return NULL;
41787 }
41788
41789
41790 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41791 PyObject *resultobj = 0;
41792 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41793 bool result;
41794 void *argp1 = 0 ;
41795 int res1 = 0 ;
41796 PyObject *swig_obj[1] ;
41797
41798 if (!args) SWIG_fail;
41799 swig_obj[0] = args;
41800 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41801 if (!SWIG_IsOK(res1)) {
41802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41803 }
41804 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41805 {
41806 PyThreadState* __tstate = wxPyBeginAllowThreads();
41807 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
41808 wxPyEndAllowThreads(__tstate);
41809 if (PyErr_Occurred()) SWIG_fail;
41810 }
41811 {
41812 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41813 }
41814 return resultobj;
41815 fail:
41816 return NULL;
41817 }
41818
41819
41820 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41821 PyObject *resultobj = 0;
41822 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41823 wxFrame *arg2 = (wxFrame *) 0 ;
41824 void *argp1 = 0 ;
41825 int res1 = 0 ;
41826 void *argp2 = 0 ;
41827 int res2 = 0 ;
41828 PyObject * obj0 = 0 ;
41829 PyObject * obj1 = 0 ;
41830 char * kwnames[] = {
41831 (char *) "self",(char *) "frame", NULL
41832 };
41833
41834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
41835 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41836 if (!SWIG_IsOK(res1)) {
41837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41838 }
41839 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41840 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
41841 if (!SWIG_IsOK(res2)) {
41842 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
41843 }
41844 arg2 = reinterpret_cast< wxFrame * >(argp2);
41845 {
41846 PyThreadState* __tstate = wxPyBeginAllowThreads();
41847 (arg1)->Attach(arg2);
41848 wxPyEndAllowThreads(__tstate);
41849 if (PyErr_Occurred()) SWIG_fail;
41850 }
41851 resultobj = SWIG_Py_Void();
41852 return resultobj;
41853 fail:
41854 return NULL;
41855 }
41856
41857
41858 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41859 PyObject *resultobj = 0;
41860 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41861 void *argp1 = 0 ;
41862 int res1 = 0 ;
41863 PyObject *swig_obj[1] ;
41864
41865 if (!args) SWIG_fail;
41866 swig_obj[0] = args;
41867 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41868 if (!SWIG_IsOK(res1)) {
41869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41870 }
41871 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41872 {
41873 PyThreadState* __tstate = wxPyBeginAllowThreads();
41874 (arg1)->Detach();
41875 wxPyEndAllowThreads(__tstate);
41876 if (PyErr_Occurred()) SWIG_fail;
41877 }
41878 resultobj = SWIG_Py_Void();
41879 return resultobj;
41880 fail:
41881 return NULL;
41882 }
41883
41884
41885 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41886 PyObject *resultobj = 0;
41887 bool arg1 ;
41888 bool val1 ;
41889 int ecode1 = 0 ;
41890 PyObject * obj0 = 0 ;
41891 char * kwnames[] = {
41892 (char *) "enable", NULL
41893 };
41894
41895 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
41896 ecode1 = SWIG_AsVal_bool(obj0, &val1);
41897 if (!SWIG_IsOK(ecode1)) {
41898 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
41899 }
41900 arg1 = static_cast< bool >(val1);
41901 {
41902 PyThreadState* __tstate = wxPyBeginAllowThreads();
41903 wxMenuBar_SetAutoWindowMenu(arg1);
41904 wxPyEndAllowThreads(__tstate);
41905 if (PyErr_Occurred()) SWIG_fail;
41906 }
41907 resultobj = SWIG_Py_Void();
41908 return resultobj;
41909 fail:
41910 return NULL;
41911 }
41912
41913
41914 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41915 PyObject *resultobj = 0;
41916 bool result;
41917
41918 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
41919 {
41920 PyThreadState* __tstate = wxPyBeginAllowThreads();
41921 result = (bool)wxMenuBar_GetAutoWindowMenu();
41922 wxPyEndAllowThreads(__tstate);
41923 if (PyErr_Occurred()) SWIG_fail;
41924 }
41925 {
41926 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41927 }
41928 return resultobj;
41929 fail:
41930 return NULL;
41931 }
41932
41933
41934 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41935 PyObject *obj;
41936 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41937 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
41938 return SWIG_Py_Void();
41939 }
41940
41941 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41942 return SWIG_Python_InitShadowInstance(args);
41943 }
41944
41945 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41946 PyObject *resultobj = 0;
41947 wxMenu *arg1 = (wxMenu *) NULL ;
41948 int arg2 = (int) wxID_ANY ;
41949 wxString const &arg3_defvalue = wxPyEmptyString ;
41950 wxString *arg3 = (wxString *) &arg3_defvalue ;
41951 wxString const &arg4_defvalue = wxPyEmptyString ;
41952 wxString *arg4 = (wxString *) &arg4_defvalue ;
41953 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
41954 wxMenu *arg6 = (wxMenu *) NULL ;
41955 wxMenuItem *result = 0 ;
41956 void *argp1 = 0 ;
41957 int res1 = 0 ;
41958 int val2 ;
41959 int ecode2 = 0 ;
41960 bool temp3 = false ;
41961 bool temp4 = false ;
41962 int val5 ;
41963 int ecode5 = 0 ;
41964 void *argp6 = 0 ;
41965 int res6 = 0 ;
41966 PyObject * obj0 = 0 ;
41967 PyObject * obj1 = 0 ;
41968 PyObject * obj2 = 0 ;
41969 PyObject * obj3 = 0 ;
41970 PyObject * obj4 = 0 ;
41971 PyObject * obj5 = 0 ;
41972 char * kwnames[] = {
41973 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
41974 };
41975
41976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
41977 if (obj0) {
41978 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41979 if (!SWIG_IsOK(res1)) {
41980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
41981 }
41982 arg1 = reinterpret_cast< wxMenu * >(argp1);
41983 }
41984 if (obj1) {
41985 ecode2 = SWIG_AsVal_int(obj1, &val2);
41986 if (!SWIG_IsOK(ecode2)) {
41987 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
41988 }
41989 arg2 = static_cast< int >(val2);
41990 }
41991 if (obj2) {
41992 {
41993 arg3 = wxString_in_helper(obj2);
41994 if (arg3 == NULL) SWIG_fail;
41995 temp3 = true;
41996 }
41997 }
41998 if (obj3) {
41999 {
42000 arg4 = wxString_in_helper(obj3);
42001 if (arg4 == NULL) SWIG_fail;
42002 temp4 = true;
42003 }
42004 }
42005 if (obj4) {
42006 ecode5 = SWIG_AsVal_int(obj4, &val5);
42007 if (!SWIG_IsOK(ecode5)) {
42008 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
42009 }
42010 arg5 = static_cast< wxItemKind >(val5);
42011 }
42012 if (obj5) {
42013 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
42014 if (!SWIG_IsOK(res6)) {
42015 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
42016 }
42017 arg6 = reinterpret_cast< wxMenu * >(argp6);
42018 }
42019 {
42020 PyThreadState* __tstate = wxPyBeginAllowThreads();
42021 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
42022 wxPyEndAllowThreads(__tstate);
42023 if (PyErr_Occurred()) SWIG_fail;
42024 }
42025 {
42026 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
42027 }
42028 {
42029 if (temp3)
42030 delete arg3;
42031 }
42032 {
42033 if (temp4)
42034 delete arg4;
42035 }
42036 return resultobj;
42037 fail:
42038 {
42039 if (temp3)
42040 delete arg3;
42041 }
42042 {
42043 if (temp4)
42044 delete arg4;
42045 }
42046 return NULL;
42047 }
42048
42049
42050 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42051 PyObject *resultobj = 0;
42052 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42053 void *argp1 = 0 ;
42054 int res1 = 0 ;
42055 PyObject *swig_obj[1] ;
42056
42057 if (!args) SWIG_fail;
42058 swig_obj[0] = args;
42059 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42060 if (!SWIG_IsOK(res1)) {
42061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42062 }
42063 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42064 {
42065 PyThreadState* __tstate = wxPyBeginAllowThreads();
42066 delete arg1;
42067
42068 wxPyEndAllowThreads(__tstate);
42069 if (PyErr_Occurred()) SWIG_fail;
42070 }
42071 resultobj = SWIG_Py_Void();
42072 return resultobj;
42073 fail:
42074 return NULL;
42075 }
42076
42077
42078 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42079 PyObject *resultobj = 0;
42080 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42081 wxMenu *result = 0 ;
42082 void *argp1 = 0 ;
42083 int res1 = 0 ;
42084 PyObject *swig_obj[1] ;
42085
42086 if (!args) SWIG_fail;
42087 swig_obj[0] = args;
42088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42089 if (!SWIG_IsOK(res1)) {
42090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42091 }
42092 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42093 {
42094 PyThreadState* __tstate = wxPyBeginAllowThreads();
42095 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
42096 wxPyEndAllowThreads(__tstate);
42097 if (PyErr_Occurred()) SWIG_fail;
42098 }
42099 {
42100 resultobj = wxPyMake_wxObject(result, 0);
42101 }
42102 return resultobj;
42103 fail:
42104 return NULL;
42105 }
42106
42107
42108 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42109 PyObject *resultobj = 0;
42110 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42111 wxMenu *arg2 = (wxMenu *) 0 ;
42112 void *argp1 = 0 ;
42113 int res1 = 0 ;
42114 void *argp2 = 0 ;
42115 int res2 = 0 ;
42116 PyObject * obj0 = 0 ;
42117 PyObject * obj1 = 0 ;
42118 char * kwnames[] = {
42119 (char *) "self",(char *) "menu", NULL
42120 };
42121
42122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42123 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42124 if (!SWIG_IsOK(res1)) {
42125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42126 }
42127 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42128 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42129 if (!SWIG_IsOK(res2)) {
42130 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42131 }
42132 arg2 = reinterpret_cast< wxMenu * >(argp2);
42133 {
42134 PyThreadState* __tstate = wxPyBeginAllowThreads();
42135 (arg1)->SetMenu(arg2);
42136 wxPyEndAllowThreads(__tstate);
42137 if (PyErr_Occurred()) SWIG_fail;
42138 }
42139 resultobj = SWIG_Py_Void();
42140 return resultobj;
42141 fail:
42142 return NULL;
42143 }
42144
42145
42146 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42147 PyObject *resultobj = 0;
42148 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42149 int arg2 ;
42150 void *argp1 = 0 ;
42151 int res1 = 0 ;
42152 int val2 ;
42153 int ecode2 = 0 ;
42154 PyObject * obj0 = 0 ;
42155 PyObject * obj1 = 0 ;
42156 char * kwnames[] = {
42157 (char *) "self",(char *) "id", NULL
42158 };
42159
42160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
42161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42162 if (!SWIG_IsOK(res1)) {
42163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42164 }
42165 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42166 ecode2 = SWIG_AsVal_int(obj1, &val2);
42167 if (!SWIG_IsOK(ecode2)) {
42168 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
42169 }
42170 arg2 = static_cast< int >(val2);
42171 {
42172 PyThreadState* __tstate = wxPyBeginAllowThreads();
42173 (arg1)->SetId(arg2);
42174 wxPyEndAllowThreads(__tstate);
42175 if (PyErr_Occurred()) SWIG_fail;
42176 }
42177 resultobj = SWIG_Py_Void();
42178 return resultobj;
42179 fail:
42180 return NULL;
42181 }
42182
42183
42184 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42185 PyObject *resultobj = 0;
42186 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42187 int result;
42188 void *argp1 = 0 ;
42189 int res1 = 0 ;
42190 PyObject *swig_obj[1] ;
42191
42192 if (!args) SWIG_fail;
42193 swig_obj[0] = args;
42194 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42195 if (!SWIG_IsOK(res1)) {
42196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42197 }
42198 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42199 {
42200 PyThreadState* __tstate = wxPyBeginAllowThreads();
42201 result = (int)((wxMenuItem const *)arg1)->GetId();
42202 wxPyEndAllowThreads(__tstate);
42203 if (PyErr_Occurred()) SWIG_fail;
42204 }
42205 resultobj = SWIG_From_int(static_cast< int >(result));
42206 return resultobj;
42207 fail:
42208 return NULL;
42209 }
42210
42211
42212 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42213 PyObject *resultobj = 0;
42214 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42215 bool result;
42216 void *argp1 = 0 ;
42217 int res1 = 0 ;
42218 PyObject *swig_obj[1] ;
42219
42220 if (!args) SWIG_fail;
42221 swig_obj[0] = args;
42222 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42223 if (!SWIG_IsOK(res1)) {
42224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42225 }
42226 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42227 {
42228 PyThreadState* __tstate = wxPyBeginAllowThreads();
42229 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
42230 wxPyEndAllowThreads(__tstate);
42231 if (PyErr_Occurred()) SWIG_fail;
42232 }
42233 {
42234 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42235 }
42236 return resultobj;
42237 fail:
42238 return NULL;
42239 }
42240
42241
42242 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42243 PyObject *resultobj = 0;
42244 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42245 wxString *arg2 = 0 ;
42246 void *argp1 = 0 ;
42247 int res1 = 0 ;
42248 bool temp2 = false ;
42249 PyObject * obj0 = 0 ;
42250 PyObject * obj1 = 0 ;
42251 char * kwnames[] = {
42252 (char *) "self",(char *) "str", NULL
42253 };
42254
42255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
42256 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42257 if (!SWIG_IsOK(res1)) {
42258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42259 }
42260 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42261 {
42262 arg2 = wxString_in_helper(obj1);
42263 if (arg2 == NULL) SWIG_fail;
42264 temp2 = true;
42265 }
42266 {
42267 PyThreadState* __tstate = wxPyBeginAllowThreads();
42268 (arg1)->SetText((wxString const &)*arg2);
42269 wxPyEndAllowThreads(__tstate);
42270 if (PyErr_Occurred()) SWIG_fail;
42271 }
42272 resultobj = SWIG_Py_Void();
42273 {
42274 if (temp2)
42275 delete arg2;
42276 }
42277 return resultobj;
42278 fail:
42279 {
42280 if (temp2)
42281 delete arg2;
42282 }
42283 return NULL;
42284 }
42285
42286
42287 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42288 PyObject *resultobj = 0;
42289 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42290 wxString result;
42291 void *argp1 = 0 ;
42292 int res1 = 0 ;
42293 PyObject *swig_obj[1] ;
42294
42295 if (!args) SWIG_fail;
42296 swig_obj[0] = args;
42297 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42298 if (!SWIG_IsOK(res1)) {
42299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42300 }
42301 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42302 {
42303 PyThreadState* __tstate = wxPyBeginAllowThreads();
42304 result = ((wxMenuItem const *)arg1)->GetLabel();
42305 wxPyEndAllowThreads(__tstate);
42306 if (PyErr_Occurred()) SWIG_fail;
42307 }
42308 {
42309 #if wxUSE_UNICODE
42310 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42311 #else
42312 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42313 #endif
42314 }
42315 return resultobj;
42316 fail:
42317 return NULL;
42318 }
42319
42320
42321 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42322 PyObject *resultobj = 0;
42323 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42324 wxString *result = 0 ;
42325 void *argp1 = 0 ;
42326 int res1 = 0 ;
42327 PyObject *swig_obj[1] ;
42328
42329 if (!args) SWIG_fail;
42330 swig_obj[0] = args;
42331 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42332 if (!SWIG_IsOK(res1)) {
42333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42334 }
42335 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42336 {
42337 PyThreadState* __tstate = wxPyBeginAllowThreads();
42338 {
42339 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
42340 result = (wxString *) &_result_ref;
42341 }
42342 wxPyEndAllowThreads(__tstate);
42343 if (PyErr_Occurred()) SWIG_fail;
42344 }
42345 {
42346 #if wxUSE_UNICODE
42347 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
42348 #else
42349 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
42350 #endif
42351 }
42352 return resultobj;
42353 fail:
42354 return NULL;
42355 }
42356
42357
42358 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42359 PyObject *resultobj = 0;
42360 wxString *arg1 = 0 ;
42361 wxString result;
42362 bool temp1 = false ;
42363 PyObject * obj0 = 0 ;
42364 char * kwnames[] = {
42365 (char *) "text", NULL
42366 };
42367
42368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
42369 {
42370 arg1 = wxString_in_helper(obj0);
42371 if (arg1 == NULL) SWIG_fail;
42372 temp1 = true;
42373 }
42374 {
42375 PyThreadState* __tstate = wxPyBeginAllowThreads();
42376 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
42377 wxPyEndAllowThreads(__tstate);
42378 if (PyErr_Occurred()) SWIG_fail;
42379 }
42380 {
42381 #if wxUSE_UNICODE
42382 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42383 #else
42384 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42385 #endif
42386 }
42387 {
42388 if (temp1)
42389 delete arg1;
42390 }
42391 return resultobj;
42392 fail:
42393 {
42394 if (temp1)
42395 delete arg1;
42396 }
42397 return NULL;
42398 }
42399
42400
42401 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42402 PyObject *resultobj = 0;
42403 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42404 wxItemKind result;
42405 void *argp1 = 0 ;
42406 int res1 = 0 ;
42407 PyObject *swig_obj[1] ;
42408
42409 if (!args) SWIG_fail;
42410 swig_obj[0] = args;
42411 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42412 if (!SWIG_IsOK(res1)) {
42413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42414 }
42415 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42416 {
42417 PyThreadState* __tstate = wxPyBeginAllowThreads();
42418 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
42419 wxPyEndAllowThreads(__tstate);
42420 if (PyErr_Occurred()) SWIG_fail;
42421 }
42422 resultobj = SWIG_From_int(static_cast< int >(result));
42423 return resultobj;
42424 fail:
42425 return NULL;
42426 }
42427
42428
42429 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42430 PyObject *resultobj = 0;
42431 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42432 wxItemKind arg2 ;
42433 void *argp1 = 0 ;
42434 int res1 = 0 ;
42435 int val2 ;
42436 int ecode2 = 0 ;
42437 PyObject * obj0 = 0 ;
42438 PyObject * obj1 = 0 ;
42439 char * kwnames[] = {
42440 (char *) "self",(char *) "kind", NULL
42441 };
42442
42443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
42444 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42445 if (!SWIG_IsOK(res1)) {
42446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42447 }
42448 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42449 ecode2 = SWIG_AsVal_int(obj1, &val2);
42450 if (!SWIG_IsOK(ecode2)) {
42451 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
42452 }
42453 arg2 = static_cast< wxItemKind >(val2);
42454 {
42455 PyThreadState* __tstate = wxPyBeginAllowThreads();
42456 (arg1)->SetKind(arg2);
42457 wxPyEndAllowThreads(__tstate);
42458 if (PyErr_Occurred()) SWIG_fail;
42459 }
42460 resultobj = SWIG_Py_Void();
42461 return resultobj;
42462 fail:
42463 return NULL;
42464 }
42465
42466
42467 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42468 PyObject *resultobj = 0;
42469 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42470 bool arg2 ;
42471 void *argp1 = 0 ;
42472 int res1 = 0 ;
42473 bool val2 ;
42474 int ecode2 = 0 ;
42475 PyObject * obj0 = 0 ;
42476 PyObject * obj1 = 0 ;
42477 char * kwnames[] = {
42478 (char *) "self",(char *) "checkable", NULL
42479 };
42480
42481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
42482 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42483 if (!SWIG_IsOK(res1)) {
42484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42485 }
42486 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42487 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42488 if (!SWIG_IsOK(ecode2)) {
42489 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
42490 }
42491 arg2 = static_cast< bool >(val2);
42492 {
42493 PyThreadState* __tstate = wxPyBeginAllowThreads();
42494 (arg1)->SetCheckable(arg2);
42495 wxPyEndAllowThreads(__tstate);
42496 if (PyErr_Occurred()) SWIG_fail;
42497 }
42498 resultobj = SWIG_Py_Void();
42499 return resultobj;
42500 fail:
42501 return NULL;
42502 }
42503
42504
42505 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42506 PyObject *resultobj = 0;
42507 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42508 bool result;
42509 void *argp1 = 0 ;
42510 int res1 = 0 ;
42511 PyObject *swig_obj[1] ;
42512
42513 if (!args) SWIG_fail;
42514 swig_obj[0] = args;
42515 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42516 if (!SWIG_IsOK(res1)) {
42517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42518 }
42519 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42520 {
42521 PyThreadState* __tstate = wxPyBeginAllowThreads();
42522 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
42523 wxPyEndAllowThreads(__tstate);
42524 if (PyErr_Occurred()) SWIG_fail;
42525 }
42526 {
42527 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42528 }
42529 return resultobj;
42530 fail:
42531 return NULL;
42532 }
42533
42534
42535 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42536 PyObject *resultobj = 0;
42537 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42538 bool result;
42539 void *argp1 = 0 ;
42540 int res1 = 0 ;
42541 PyObject *swig_obj[1] ;
42542
42543 if (!args) SWIG_fail;
42544 swig_obj[0] = args;
42545 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42546 if (!SWIG_IsOK(res1)) {
42547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42548 }
42549 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42550 {
42551 PyThreadState* __tstate = wxPyBeginAllowThreads();
42552 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
42553 wxPyEndAllowThreads(__tstate);
42554 if (PyErr_Occurred()) SWIG_fail;
42555 }
42556 {
42557 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42558 }
42559 return resultobj;
42560 fail:
42561 return NULL;
42562 }
42563
42564
42565 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42566 PyObject *resultobj = 0;
42567 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42568 wxMenu *arg2 = (wxMenu *) 0 ;
42569 void *argp1 = 0 ;
42570 int res1 = 0 ;
42571 void *argp2 = 0 ;
42572 int res2 = 0 ;
42573 PyObject * obj0 = 0 ;
42574 PyObject * obj1 = 0 ;
42575 char * kwnames[] = {
42576 (char *) "self",(char *) "menu", NULL
42577 };
42578
42579 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42580 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42581 if (!SWIG_IsOK(res1)) {
42582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42583 }
42584 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42585 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42586 if (!SWIG_IsOK(res2)) {
42587 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42588 }
42589 arg2 = reinterpret_cast< wxMenu * >(argp2);
42590 {
42591 PyThreadState* __tstate = wxPyBeginAllowThreads();
42592 (arg1)->SetSubMenu(arg2);
42593 wxPyEndAllowThreads(__tstate);
42594 if (PyErr_Occurred()) SWIG_fail;
42595 }
42596 resultobj = SWIG_Py_Void();
42597 return resultobj;
42598 fail:
42599 return NULL;
42600 }
42601
42602
42603 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42604 PyObject *resultobj = 0;
42605 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42606 wxMenu *result = 0 ;
42607 void *argp1 = 0 ;
42608 int res1 = 0 ;
42609 PyObject *swig_obj[1] ;
42610
42611 if (!args) SWIG_fail;
42612 swig_obj[0] = args;
42613 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42614 if (!SWIG_IsOK(res1)) {
42615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42616 }
42617 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42618 {
42619 PyThreadState* __tstate = wxPyBeginAllowThreads();
42620 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
42621 wxPyEndAllowThreads(__tstate);
42622 if (PyErr_Occurred()) SWIG_fail;
42623 }
42624 {
42625 resultobj = wxPyMake_wxObject(result, 0);
42626 }
42627 return resultobj;
42628 fail:
42629 return NULL;
42630 }
42631
42632
42633 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42634 PyObject *resultobj = 0;
42635 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42636 bool arg2 = (bool) true ;
42637 void *argp1 = 0 ;
42638 int res1 = 0 ;
42639 bool val2 ;
42640 int ecode2 = 0 ;
42641 PyObject * obj0 = 0 ;
42642 PyObject * obj1 = 0 ;
42643 char * kwnames[] = {
42644 (char *) "self",(char *) "enable", NULL
42645 };
42646
42647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
42648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42649 if (!SWIG_IsOK(res1)) {
42650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42651 }
42652 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42653 if (obj1) {
42654 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42655 if (!SWIG_IsOK(ecode2)) {
42656 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
42657 }
42658 arg2 = static_cast< bool >(val2);
42659 }
42660 {
42661 PyThreadState* __tstate = wxPyBeginAllowThreads();
42662 (arg1)->Enable(arg2);
42663 wxPyEndAllowThreads(__tstate);
42664 if (PyErr_Occurred()) SWIG_fail;
42665 }
42666 resultobj = SWIG_Py_Void();
42667 return resultobj;
42668 fail:
42669 return NULL;
42670 }
42671
42672
42673 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42674 PyObject *resultobj = 0;
42675 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42676 bool result;
42677 void *argp1 = 0 ;
42678 int res1 = 0 ;
42679 PyObject *swig_obj[1] ;
42680
42681 if (!args) SWIG_fail;
42682 swig_obj[0] = args;
42683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42684 if (!SWIG_IsOK(res1)) {
42685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42686 }
42687 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42688 {
42689 PyThreadState* __tstate = wxPyBeginAllowThreads();
42690 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
42691 wxPyEndAllowThreads(__tstate);
42692 if (PyErr_Occurred()) SWIG_fail;
42693 }
42694 {
42695 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42696 }
42697 return resultobj;
42698 fail:
42699 return NULL;
42700 }
42701
42702
42703 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42704 PyObject *resultobj = 0;
42705 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42706 bool arg2 = (bool) true ;
42707 void *argp1 = 0 ;
42708 int res1 = 0 ;
42709 bool val2 ;
42710 int ecode2 = 0 ;
42711 PyObject * obj0 = 0 ;
42712 PyObject * obj1 = 0 ;
42713 char * kwnames[] = {
42714 (char *) "self",(char *) "check", NULL
42715 };
42716
42717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
42718 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42719 if (!SWIG_IsOK(res1)) {
42720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42721 }
42722 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42723 if (obj1) {
42724 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42725 if (!SWIG_IsOK(ecode2)) {
42726 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
42727 }
42728 arg2 = static_cast< bool >(val2);
42729 }
42730 {
42731 PyThreadState* __tstate = wxPyBeginAllowThreads();
42732 (arg1)->Check(arg2);
42733 wxPyEndAllowThreads(__tstate);
42734 if (PyErr_Occurred()) SWIG_fail;
42735 }
42736 resultobj = SWIG_Py_Void();
42737 return resultobj;
42738 fail:
42739 return NULL;
42740 }
42741
42742
42743 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42744 PyObject *resultobj = 0;
42745 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42746 bool result;
42747 void *argp1 = 0 ;
42748 int res1 = 0 ;
42749 PyObject *swig_obj[1] ;
42750
42751 if (!args) SWIG_fail;
42752 swig_obj[0] = args;
42753 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42754 if (!SWIG_IsOK(res1)) {
42755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42756 }
42757 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42758 {
42759 PyThreadState* __tstate = wxPyBeginAllowThreads();
42760 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
42761 wxPyEndAllowThreads(__tstate);
42762 if (PyErr_Occurred()) SWIG_fail;
42763 }
42764 {
42765 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42766 }
42767 return resultobj;
42768 fail:
42769 return NULL;
42770 }
42771
42772
42773 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42774 PyObject *resultobj = 0;
42775 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42776 void *argp1 = 0 ;
42777 int res1 = 0 ;
42778 PyObject *swig_obj[1] ;
42779
42780 if (!args) SWIG_fail;
42781 swig_obj[0] = args;
42782 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42783 if (!SWIG_IsOK(res1)) {
42784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42785 }
42786 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42787 {
42788 PyThreadState* __tstate = wxPyBeginAllowThreads();
42789 (arg1)->Toggle();
42790 wxPyEndAllowThreads(__tstate);
42791 if (PyErr_Occurred()) SWIG_fail;
42792 }
42793 resultobj = SWIG_Py_Void();
42794 return resultobj;
42795 fail:
42796 return NULL;
42797 }
42798
42799
42800 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42801 PyObject *resultobj = 0;
42802 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42803 wxString *arg2 = 0 ;
42804 void *argp1 = 0 ;
42805 int res1 = 0 ;
42806 bool temp2 = false ;
42807 PyObject * obj0 = 0 ;
42808 PyObject * obj1 = 0 ;
42809 char * kwnames[] = {
42810 (char *) "self",(char *) "str", NULL
42811 };
42812
42813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
42814 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42815 if (!SWIG_IsOK(res1)) {
42816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42817 }
42818 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42819 {
42820 arg2 = wxString_in_helper(obj1);
42821 if (arg2 == NULL) SWIG_fail;
42822 temp2 = true;
42823 }
42824 {
42825 PyThreadState* __tstate = wxPyBeginAllowThreads();
42826 (arg1)->SetHelp((wxString const &)*arg2);
42827 wxPyEndAllowThreads(__tstate);
42828 if (PyErr_Occurred()) SWIG_fail;
42829 }
42830 resultobj = SWIG_Py_Void();
42831 {
42832 if (temp2)
42833 delete arg2;
42834 }
42835 return resultobj;
42836 fail:
42837 {
42838 if (temp2)
42839 delete arg2;
42840 }
42841 return NULL;
42842 }
42843
42844
42845 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42846 PyObject *resultobj = 0;
42847 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42848 wxString *result = 0 ;
42849 void *argp1 = 0 ;
42850 int res1 = 0 ;
42851 PyObject *swig_obj[1] ;
42852
42853 if (!args) SWIG_fail;
42854 swig_obj[0] = args;
42855 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42856 if (!SWIG_IsOK(res1)) {
42857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42858 }
42859 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42860 {
42861 PyThreadState* __tstate = wxPyBeginAllowThreads();
42862 {
42863 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
42864 result = (wxString *) &_result_ref;
42865 }
42866 wxPyEndAllowThreads(__tstate);
42867 if (PyErr_Occurred()) SWIG_fail;
42868 }
42869 {
42870 #if wxUSE_UNICODE
42871 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
42872 #else
42873 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
42874 #endif
42875 }
42876 return resultobj;
42877 fail:
42878 return NULL;
42879 }
42880
42881
42882 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42883 PyObject *resultobj = 0;
42884 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42885 wxAcceleratorEntry *result = 0 ;
42886 void *argp1 = 0 ;
42887 int res1 = 0 ;
42888 PyObject *swig_obj[1] ;
42889
42890 if (!args) SWIG_fail;
42891 swig_obj[0] = args;
42892 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42893 if (!SWIG_IsOK(res1)) {
42894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42895 }
42896 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42897 {
42898 PyThreadState* __tstate = wxPyBeginAllowThreads();
42899 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
42900 wxPyEndAllowThreads(__tstate);
42901 if (PyErr_Occurred()) SWIG_fail;
42902 }
42903 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
42904 return resultobj;
42905 fail:
42906 return NULL;
42907 }
42908
42909
42910 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42911 PyObject *resultobj = 0;
42912 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42913 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
42914 void *argp1 = 0 ;
42915 int res1 = 0 ;
42916 void *argp2 = 0 ;
42917 int res2 = 0 ;
42918 PyObject * obj0 = 0 ;
42919 PyObject * obj1 = 0 ;
42920 char * kwnames[] = {
42921 (char *) "self",(char *) "accel", NULL
42922 };
42923
42924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
42925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42926 if (!SWIG_IsOK(res1)) {
42927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42928 }
42929 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42930 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
42931 if (!SWIG_IsOK(res2)) {
42932 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
42933 }
42934 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
42935 {
42936 PyThreadState* __tstate = wxPyBeginAllowThreads();
42937 (arg1)->SetAccel(arg2);
42938 wxPyEndAllowThreads(__tstate);
42939 if (PyErr_Occurred()) SWIG_fail;
42940 }
42941 resultobj = SWIG_Py_Void();
42942 return resultobj;
42943 fail:
42944 return NULL;
42945 }
42946
42947
42948 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42949 PyObject *resultobj = 0;
42950 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42951 wxBitmap *arg2 = 0 ;
42952 void *argp1 = 0 ;
42953 int res1 = 0 ;
42954 void *argp2 = 0 ;
42955 int res2 = 0 ;
42956 PyObject * obj0 = 0 ;
42957 PyObject * obj1 = 0 ;
42958 char * kwnames[] = {
42959 (char *) "self",(char *) "bitmap", NULL
42960 };
42961
42962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
42963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42964 if (!SWIG_IsOK(res1)) {
42965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42966 }
42967 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42968 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
42969 if (!SWIG_IsOK(res2)) {
42970 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
42971 }
42972 if (!argp2) {
42973 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
42974 }
42975 arg2 = reinterpret_cast< wxBitmap * >(argp2);
42976 {
42977 PyThreadState* __tstate = wxPyBeginAllowThreads();
42978 (arg1)->SetBitmap((wxBitmap const &)*arg2);
42979 wxPyEndAllowThreads(__tstate);
42980 if (PyErr_Occurred()) SWIG_fail;
42981 }
42982 resultobj = SWIG_Py_Void();
42983 return resultobj;
42984 fail:
42985 return NULL;
42986 }
42987
42988
42989 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42990 PyObject *resultobj = 0;
42991 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42992 wxBitmap *result = 0 ;
42993 void *argp1 = 0 ;
42994 int res1 = 0 ;
42995 PyObject *swig_obj[1] ;
42996
42997 if (!args) SWIG_fail;
42998 swig_obj[0] = args;
42999 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43000 if (!SWIG_IsOK(res1)) {
43001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43002 }
43003 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43004 {
43005 PyThreadState* __tstate = wxPyBeginAllowThreads();
43006 {
43007 wxBitmap const &_result_ref = (arg1)->GetBitmap();
43008 result = (wxBitmap *) &_result_ref;
43009 }
43010 wxPyEndAllowThreads(__tstate);
43011 if (PyErr_Occurred()) SWIG_fail;
43012 }
43013 {
43014 wxBitmap* resultptr = new wxBitmap(*result);
43015 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43016 }
43017 return resultobj;
43018 fail:
43019 return NULL;
43020 }
43021
43022
43023 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43024 PyObject *resultobj = 0;
43025 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43026 wxFont *arg2 = 0 ;
43027 void *argp1 = 0 ;
43028 int res1 = 0 ;
43029 void *argp2 = 0 ;
43030 int res2 = 0 ;
43031 PyObject * obj0 = 0 ;
43032 PyObject * obj1 = 0 ;
43033 char * kwnames[] = {
43034 (char *) "self",(char *) "font", NULL
43035 };
43036
43037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
43038 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43039 if (!SWIG_IsOK(res1)) {
43040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43041 }
43042 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43043 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
43044 if (!SWIG_IsOK(res2)) {
43045 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
43046 }
43047 if (!argp2) {
43048 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
43049 }
43050 arg2 = reinterpret_cast< wxFont * >(argp2);
43051 {
43052 PyThreadState* __tstate = wxPyBeginAllowThreads();
43053 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
43054 wxPyEndAllowThreads(__tstate);
43055 if (PyErr_Occurred()) SWIG_fail;
43056 }
43057 resultobj = SWIG_Py_Void();
43058 return resultobj;
43059 fail:
43060 return NULL;
43061 }
43062
43063
43064 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43065 PyObject *resultobj = 0;
43066 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43067 wxFont result;
43068 void *argp1 = 0 ;
43069 int res1 = 0 ;
43070 PyObject *swig_obj[1] ;
43071
43072 if (!args) SWIG_fail;
43073 swig_obj[0] = args;
43074 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43075 if (!SWIG_IsOK(res1)) {
43076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43077 }
43078 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43079 {
43080 PyThreadState* __tstate = wxPyBeginAllowThreads();
43081 result = wxMenuItem_GetFont(arg1);
43082 wxPyEndAllowThreads(__tstate);
43083 if (PyErr_Occurred()) SWIG_fail;
43084 }
43085 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
43086 return resultobj;
43087 fail:
43088 return NULL;
43089 }
43090
43091
43092 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43093 PyObject *resultobj = 0;
43094 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43095 wxColour *arg2 = 0 ;
43096 void *argp1 = 0 ;
43097 int res1 = 0 ;
43098 wxColour temp2 ;
43099 PyObject * obj0 = 0 ;
43100 PyObject * obj1 = 0 ;
43101 char * kwnames[] = {
43102 (char *) "self",(char *) "colText", NULL
43103 };
43104
43105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
43106 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43107 if (!SWIG_IsOK(res1)) {
43108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43109 }
43110 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43111 {
43112 arg2 = &temp2;
43113 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43114 }
43115 {
43116 PyThreadState* __tstate = wxPyBeginAllowThreads();
43117 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
43118 wxPyEndAllowThreads(__tstate);
43119 if (PyErr_Occurred()) SWIG_fail;
43120 }
43121 resultobj = SWIG_Py_Void();
43122 return resultobj;
43123 fail:
43124 return NULL;
43125 }
43126
43127
43128 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43129 PyObject *resultobj = 0;
43130 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43131 wxColour result;
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, 0 | 0 );
43139 if (!SWIG_IsOK(res1)) {
43140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43141 }
43142 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43143 {
43144 PyThreadState* __tstate = wxPyBeginAllowThreads();
43145 result = wxMenuItem_GetTextColour(arg1);
43146 wxPyEndAllowThreads(__tstate);
43147 if (PyErr_Occurred()) SWIG_fail;
43148 }
43149 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43150 return resultobj;
43151 fail:
43152 return NULL;
43153 }
43154
43155
43156 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43157 PyObject *resultobj = 0;
43158 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43159 wxColour *arg2 = 0 ;
43160 void *argp1 = 0 ;
43161 int res1 = 0 ;
43162 wxColour temp2 ;
43163 PyObject * obj0 = 0 ;
43164 PyObject * obj1 = 0 ;
43165 char * kwnames[] = {
43166 (char *) "self",(char *) "colBack", NULL
43167 };
43168
43169 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
43170 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43171 if (!SWIG_IsOK(res1)) {
43172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43173 }
43174 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43175 {
43176 arg2 = &temp2;
43177 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43178 }
43179 {
43180 PyThreadState* __tstate = wxPyBeginAllowThreads();
43181 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
43182 wxPyEndAllowThreads(__tstate);
43183 if (PyErr_Occurred()) SWIG_fail;
43184 }
43185 resultobj = SWIG_Py_Void();
43186 return resultobj;
43187 fail:
43188 return NULL;
43189 }
43190
43191
43192 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43193 PyObject *resultobj = 0;
43194 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43195 wxColour result;
43196 void *argp1 = 0 ;
43197 int res1 = 0 ;
43198 PyObject *swig_obj[1] ;
43199
43200 if (!args) SWIG_fail;
43201 swig_obj[0] = args;
43202 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43203 if (!SWIG_IsOK(res1)) {
43204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43205 }
43206 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43207 {
43208 PyThreadState* __tstate = wxPyBeginAllowThreads();
43209 result = wxMenuItem_GetBackgroundColour(arg1);
43210 wxPyEndAllowThreads(__tstate);
43211 if (PyErr_Occurred()) SWIG_fail;
43212 }
43213 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43214 return resultobj;
43215 fail:
43216 return NULL;
43217 }
43218
43219
43220 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43221 PyObject *resultobj = 0;
43222 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43223 wxBitmap *arg2 = 0 ;
43224 wxBitmap const &arg3_defvalue = wxNullBitmap ;
43225 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
43226 void *argp1 = 0 ;
43227 int res1 = 0 ;
43228 void *argp2 = 0 ;
43229 int res2 = 0 ;
43230 void *argp3 = 0 ;
43231 int res3 = 0 ;
43232 PyObject * obj0 = 0 ;
43233 PyObject * obj1 = 0 ;
43234 PyObject * obj2 = 0 ;
43235 char * kwnames[] = {
43236 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
43237 };
43238
43239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) 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_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43243 }
43244 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43245 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43246 if (!SWIG_IsOK(res2)) {
43247 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43248 }
43249 if (!argp2) {
43250 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43251 }
43252 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43253 if (obj2) {
43254 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
43255 if (!SWIG_IsOK(res3)) {
43256 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43257 }
43258 if (!argp3) {
43259 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43260 }
43261 arg3 = reinterpret_cast< wxBitmap * >(argp3);
43262 }
43263 {
43264 PyThreadState* __tstate = wxPyBeginAllowThreads();
43265 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
43266 wxPyEndAllowThreads(__tstate);
43267 if (PyErr_Occurred()) SWIG_fail;
43268 }
43269 resultobj = SWIG_Py_Void();
43270 return resultobj;
43271 fail:
43272 return NULL;
43273 }
43274
43275
43276 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43277 PyObject *resultobj = 0;
43278 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43279 wxBitmap *arg2 = 0 ;
43280 void *argp1 = 0 ;
43281 int res1 = 0 ;
43282 void *argp2 = 0 ;
43283 int res2 = 0 ;
43284 PyObject * obj0 = 0 ;
43285 PyObject * obj1 = 0 ;
43286 char * kwnames[] = {
43287 (char *) "self",(char *) "bmpDisabled", NULL
43288 };
43289
43290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43292 if (!SWIG_IsOK(res1)) {
43293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43294 }
43295 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43296 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43297 if (!SWIG_IsOK(res2)) {
43298 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43299 }
43300 if (!argp2) {
43301 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43302 }
43303 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43304 {
43305 PyThreadState* __tstate = wxPyBeginAllowThreads();
43306 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
43307 wxPyEndAllowThreads(__tstate);
43308 if (PyErr_Occurred()) SWIG_fail;
43309 }
43310 resultobj = SWIG_Py_Void();
43311 return resultobj;
43312 fail:
43313 return NULL;
43314 }
43315
43316
43317 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43318 PyObject *resultobj = 0;
43319 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43320 wxBitmap *result = 0 ;
43321 void *argp1 = 0 ;
43322 int res1 = 0 ;
43323 PyObject *swig_obj[1] ;
43324
43325 if (!args) SWIG_fail;
43326 swig_obj[0] = args;
43327 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43328 if (!SWIG_IsOK(res1)) {
43329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43330 }
43331 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43332 {
43333 PyThreadState* __tstate = wxPyBeginAllowThreads();
43334 {
43335 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
43336 result = (wxBitmap *) &_result_ref;
43337 }
43338 wxPyEndAllowThreads(__tstate);
43339 if (PyErr_Occurred()) SWIG_fail;
43340 }
43341 {
43342 wxBitmap* resultptr = new wxBitmap(*result);
43343 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43344 }
43345 return resultobj;
43346 fail:
43347 return NULL;
43348 }
43349
43350
43351 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43352 PyObject *resultobj = 0;
43353 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43354 int arg2 ;
43355 void *argp1 = 0 ;
43356 int res1 = 0 ;
43357 int val2 ;
43358 int ecode2 = 0 ;
43359 PyObject * obj0 = 0 ;
43360 PyObject * obj1 = 0 ;
43361 char * kwnames[] = {
43362 (char *) "self",(char *) "nWidth", NULL
43363 };
43364
43365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
43366 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43367 if (!SWIG_IsOK(res1)) {
43368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43369 }
43370 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43371 ecode2 = SWIG_AsVal_int(obj1, &val2);
43372 if (!SWIG_IsOK(ecode2)) {
43373 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
43374 }
43375 arg2 = static_cast< int >(val2);
43376 {
43377 PyThreadState* __tstate = wxPyBeginAllowThreads();
43378 wxMenuItem_SetMarginWidth(arg1,arg2);
43379 wxPyEndAllowThreads(__tstate);
43380 if (PyErr_Occurred()) SWIG_fail;
43381 }
43382 resultobj = SWIG_Py_Void();
43383 return resultobj;
43384 fail:
43385 return NULL;
43386 }
43387
43388
43389 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43390 PyObject *resultobj = 0;
43391 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43392 int result;
43393 void *argp1 = 0 ;
43394 int res1 = 0 ;
43395 PyObject *swig_obj[1] ;
43396
43397 if (!args) SWIG_fail;
43398 swig_obj[0] = args;
43399 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43400 if (!SWIG_IsOK(res1)) {
43401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43402 }
43403 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43404 {
43405 PyThreadState* __tstate = wxPyBeginAllowThreads();
43406 result = (int)wxMenuItem_GetMarginWidth(arg1);
43407 wxPyEndAllowThreads(__tstate);
43408 if (PyErr_Occurred()) SWIG_fail;
43409 }
43410 resultobj = SWIG_From_int(static_cast< int >(result));
43411 return resultobj;
43412 fail:
43413 return NULL;
43414 }
43415
43416
43417 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43418 PyObject *resultobj = 0;
43419 int result;
43420
43421 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
43422 {
43423 PyThreadState* __tstate = wxPyBeginAllowThreads();
43424 result = (int)wxMenuItem_GetDefaultMarginWidth();
43425 wxPyEndAllowThreads(__tstate);
43426 if (PyErr_Occurred()) SWIG_fail;
43427 }
43428 resultobj = SWIG_From_int(static_cast< int >(result));
43429 return resultobj;
43430 fail:
43431 return NULL;
43432 }
43433
43434
43435 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43436 PyObject *resultobj = 0;
43437 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43438 bool result;
43439 void *argp1 = 0 ;
43440 int res1 = 0 ;
43441 PyObject *swig_obj[1] ;
43442
43443 if (!args) SWIG_fail;
43444 swig_obj[0] = args;
43445 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43446 if (!SWIG_IsOK(res1)) {
43447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43448 }
43449 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43450 {
43451 PyThreadState* __tstate = wxPyBeginAllowThreads();
43452 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
43453 wxPyEndAllowThreads(__tstate);
43454 if (PyErr_Occurred()) SWIG_fail;
43455 }
43456 {
43457 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43458 }
43459 return resultobj;
43460 fail:
43461 return NULL;
43462 }
43463
43464
43465 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43466 PyObject *resultobj = 0;
43467 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43468 bool arg2 = (bool) true ;
43469 void *argp1 = 0 ;
43470 int res1 = 0 ;
43471 bool val2 ;
43472 int ecode2 = 0 ;
43473 PyObject * obj0 = 0 ;
43474 PyObject * obj1 = 0 ;
43475 char * kwnames[] = {
43476 (char *) "self",(char *) "ownerDrawn", NULL
43477 };
43478
43479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
43480 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43481 if (!SWIG_IsOK(res1)) {
43482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43483 }
43484 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43485 if (obj1) {
43486 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43487 if (!SWIG_IsOK(ecode2)) {
43488 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
43489 }
43490 arg2 = static_cast< bool >(val2);
43491 }
43492 {
43493 PyThreadState* __tstate = wxPyBeginAllowThreads();
43494 wxMenuItem_SetOwnerDrawn(arg1,arg2);
43495 wxPyEndAllowThreads(__tstate);
43496 if (PyErr_Occurred()) SWIG_fail;
43497 }
43498 resultobj = SWIG_Py_Void();
43499 return resultobj;
43500 fail:
43501 return NULL;
43502 }
43503
43504
43505 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43506 PyObject *resultobj = 0;
43507 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43508 void *argp1 = 0 ;
43509 int res1 = 0 ;
43510 PyObject *swig_obj[1] ;
43511
43512 if (!args) SWIG_fail;
43513 swig_obj[0] = args;
43514 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43515 if (!SWIG_IsOK(res1)) {
43516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43517 }
43518 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43519 {
43520 PyThreadState* __tstate = wxPyBeginAllowThreads();
43521 wxMenuItem_ResetOwnerDrawn(arg1);
43522 wxPyEndAllowThreads(__tstate);
43523 if (PyErr_Occurred()) SWIG_fail;
43524 }
43525 resultobj = SWIG_Py_Void();
43526 return resultobj;
43527 fail:
43528 return NULL;
43529 }
43530
43531
43532 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43533 PyObject *obj;
43534 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
43535 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
43536 return SWIG_Py_Void();
43537 }
43538
43539 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43540 return SWIG_Python_InitShadowInstance(args);
43541 }
43542
43543 SWIGINTERN int ControlNameStr_set(PyObject *) {
43544 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
43545 return 1;
43546 }
43547
43548
43549 SWIGINTERN PyObject *ControlNameStr_get(void) {
43550 PyObject *pyobj = 0;
43551
43552 {
43553 #if wxUSE_UNICODE
43554 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
43555 #else
43556 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
43557 #endif
43558 }
43559 return pyobj;
43560 }
43561
43562
43563 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43564 PyObject *resultobj = 0;
43565 wxWindow *arg1 = (wxWindow *) 0 ;
43566 int arg2 = (int) -1 ;
43567 wxPoint const &arg3_defvalue = wxDefaultPosition ;
43568 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
43569 wxSize const &arg4_defvalue = wxDefaultSize ;
43570 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
43571 long arg5 = (long) 0 ;
43572 wxValidator const &arg6_defvalue = wxDefaultValidator ;
43573 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
43574 wxString const &arg7_defvalue = wxPyControlNameStr ;
43575 wxString *arg7 = (wxString *) &arg7_defvalue ;
43576 wxControl *result = 0 ;
43577 void *argp1 = 0 ;
43578 int res1 = 0 ;
43579 int val2 ;
43580 int ecode2 = 0 ;
43581 wxPoint temp3 ;
43582 wxSize temp4 ;
43583 long val5 ;
43584 int ecode5 = 0 ;
43585 void *argp6 = 0 ;
43586 int res6 = 0 ;
43587 bool temp7 = false ;
43588 PyObject * obj0 = 0 ;
43589 PyObject * obj1 = 0 ;
43590 PyObject * obj2 = 0 ;
43591 PyObject * obj3 = 0 ;
43592 PyObject * obj4 = 0 ;
43593 PyObject * obj5 = 0 ;
43594 PyObject * obj6 = 0 ;
43595 char * kwnames[] = {
43596 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
43597 };
43598
43599 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
43600 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
43601 if (!SWIG_IsOK(res1)) {
43602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
43603 }
43604 arg1 = reinterpret_cast< wxWindow * >(argp1);
43605 if (obj1) {
43606 ecode2 = SWIG_AsVal_int(obj1, &val2);
43607 if (!SWIG_IsOK(ecode2)) {
43608 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
43609 }
43610 arg2 = static_cast< int >(val2);
43611 }
43612 if (obj2) {
43613 {
43614 arg3 = &temp3;
43615 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
43616 }
43617 }
43618 if (obj3) {
43619 {
43620 arg4 = &temp4;
43621 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
43622 }
43623 }
43624 if (obj4) {
43625 ecode5 = SWIG_AsVal_long(obj4, &val5);
43626 if (!SWIG_IsOK(ecode5)) {
43627 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
43628 }
43629 arg5 = static_cast< long >(val5);
43630 }
43631 if (obj5) {
43632 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
43633 if (!SWIG_IsOK(res6)) {
43634 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
43635 }
43636 if (!argp6) {
43637 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
43638 }
43639 arg6 = reinterpret_cast< wxValidator * >(argp6);
43640 }
43641 if (obj6) {
43642 {
43643 arg7 = wxString_in_helper(obj6);
43644 if (arg7 == NULL) SWIG_fail;
43645 temp7 = true;
43646 }
43647 }
43648 {
43649 if (!wxPyCheckForApp()) SWIG_fail;
43650 PyThreadState* __tstate = wxPyBeginAllowThreads();
43651 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
43652 wxPyEndAllowThreads(__tstate);
43653 if (PyErr_Occurred()) SWIG_fail;
43654 }
43655 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
43656 {
43657 if (temp7)
43658 delete arg7;
43659 }
43660 return resultobj;
43661 fail:
43662 {
43663 if (temp7)
43664 delete arg7;
43665 }
43666 return NULL;
43667 }
43668
43669
43670 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43671 PyObject *resultobj = 0;
43672 wxControl *result = 0 ;
43673
43674 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
43675 {
43676 if (!wxPyCheckForApp()) SWIG_fail;
43677 PyThreadState* __tstate = wxPyBeginAllowThreads();
43678 result = (wxControl *)new wxControl();
43679 wxPyEndAllowThreads(__tstate);
43680 if (PyErr_Occurred()) SWIG_fail;
43681 }
43682 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
43683 return resultobj;
43684 fail:
43685 return NULL;
43686 }
43687
43688
43689 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43690 PyObject *resultobj = 0;
43691 wxControl *arg1 = (wxControl *) 0 ;
43692 wxWindow *arg2 = (wxWindow *) 0 ;
43693 int arg3 = (int) -1 ;
43694 wxPoint const &arg4_defvalue = wxDefaultPosition ;
43695 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
43696 wxSize const &arg5_defvalue = wxDefaultSize ;
43697 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
43698 long arg6 = (long) 0 ;
43699 wxValidator const &arg7_defvalue = wxDefaultValidator ;
43700 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
43701 wxString const &arg8_defvalue = wxPyControlNameStr ;
43702 wxString *arg8 = (wxString *) &arg8_defvalue ;
43703 bool result;
43704 void *argp1 = 0 ;
43705 int res1 = 0 ;
43706 void *argp2 = 0 ;
43707 int res2 = 0 ;
43708 int val3 ;
43709 int ecode3 = 0 ;
43710 wxPoint temp4 ;
43711 wxSize temp5 ;
43712 long val6 ;
43713 int ecode6 = 0 ;
43714 void *argp7 = 0 ;
43715 int res7 = 0 ;
43716 bool temp8 = false ;
43717 PyObject * obj0 = 0 ;
43718 PyObject * obj1 = 0 ;
43719 PyObject * obj2 = 0 ;
43720 PyObject * obj3 = 0 ;
43721 PyObject * obj4 = 0 ;
43722 PyObject * obj5 = 0 ;
43723 PyObject * obj6 = 0 ;
43724 PyObject * obj7 = 0 ;
43725 char * kwnames[] = {
43726 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
43727 };
43728
43729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
43730 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
43731 if (!SWIG_IsOK(res1)) {
43732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
43733 }
43734 arg1 = reinterpret_cast< wxControl * >(argp1);
43735 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
43736 if (!SWIG_IsOK(res2)) {
43737 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
43738 }
43739 arg2 = reinterpret_cast< wxWindow * >(argp2);
43740 if (obj2) {
43741 ecode3 = SWIG_AsVal_int(obj2, &val3);
43742 if (!SWIG_IsOK(ecode3)) {
43743 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
43744 }
43745 arg3 = static_cast< int >(val3);
43746 }
43747 if (obj3) {
43748 {
43749 arg4 = &temp4;
43750 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
43751 }
43752 }
43753 if (obj4) {
43754 {
43755 arg5 = &temp5;
43756 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
43757 }
43758 }
43759 if (obj5) {
43760 ecode6 = SWIG_AsVal_long(obj5, &val6);
43761 if (!SWIG_IsOK(ecode6)) {
43762 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
43763 }
43764 arg6 = static_cast< long >(val6);
43765 }
43766 if (obj6) {
43767 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
43768 if (!SWIG_IsOK(res7)) {
43769 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
43770 }
43771 if (!argp7) {
43772 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
43773 }
43774 arg7 = reinterpret_cast< wxValidator * >(argp7);
43775 }
43776 if (obj7) {
43777 {
43778 arg8 = wxString_in_helper(obj7);
43779 if (arg8 == NULL) SWIG_fail;
43780 temp8 = true;
43781 }
43782 }
43783 {
43784 PyThreadState* __tstate = wxPyBeginAllowThreads();
43785 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
43786 wxPyEndAllowThreads(__tstate);
43787 if (PyErr_Occurred()) SWIG_fail;
43788 }
43789 {
43790 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43791 }
43792 {
43793 if (temp8)
43794 delete arg8;
43795 }
43796 return resultobj;
43797 fail:
43798 {
43799 if (temp8)
43800 delete arg8;
43801 }
43802 return NULL;
43803 }
43804
43805
43806 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43807 PyObject *resultobj = 0;
43808 wxControl *arg1 = (wxControl *) 0 ;
43809 wxCommandEvent *arg2 = 0 ;
43810 void *argp1 = 0 ;
43811 int res1 = 0 ;
43812 void *argp2 = 0 ;
43813 int res2 = 0 ;
43814 PyObject * obj0 = 0 ;
43815 PyObject * obj1 = 0 ;
43816 char * kwnames[] = {
43817 (char *) "self",(char *) "event", NULL
43818 };
43819
43820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
43821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
43822 if (!SWIG_IsOK(res1)) {
43823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
43824 }
43825 arg1 = reinterpret_cast< wxControl * >(argp1);
43826 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
43827 if (!SWIG_IsOK(res2)) {
43828 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
43829 }
43830 if (!argp2) {
43831 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
43832 }
43833 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
43834 {
43835 PyThreadState* __tstate = wxPyBeginAllowThreads();
43836 (arg1)->Command(*arg2);
43837 wxPyEndAllowThreads(__tstate);
43838 if (PyErr_Occurred()) SWIG_fail;
43839 }
43840 resultobj = SWIG_Py_Void();
43841 return resultobj;
43842 fail:
43843 return NULL;
43844 }
43845
43846
43847 SWIGINTERN PyObject *_wrap_Control_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43848 PyObject *resultobj = 0;
43849 wxControl *arg1 = (wxControl *) 0 ;
43850 wxString result;
43851 void *argp1 = 0 ;
43852 int res1 = 0 ;
43853 PyObject *swig_obj[1] ;
43854
43855 if (!args) SWIG_fail;
43856 swig_obj[0] = args;
43857 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
43858 if (!SWIG_IsOK(res1)) {
43859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabel" "', expected argument " "1"" of type '" "wxControl *""'");
43860 }
43861 arg1 = reinterpret_cast< wxControl * >(argp1);
43862 {
43863 PyThreadState* __tstate = wxPyBeginAllowThreads();
43864 result = (arg1)->GetLabel();
43865 wxPyEndAllowThreads(__tstate);
43866 if (PyErr_Occurred()) SWIG_fail;
43867 }
43868 {
43869 #if wxUSE_UNICODE
43870 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43871 #else
43872 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43873 #endif
43874 }
43875 return resultobj;
43876 fail:
43877 return NULL;
43878 }
43879
43880
43881 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43882 PyObject *resultobj = 0;
43883 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
43884 SwigValueWrapper<wxVisualAttributes > result;
43885 int val1 ;
43886 int ecode1 = 0 ;
43887 PyObject * obj0 = 0 ;
43888 char * kwnames[] = {
43889 (char *) "variant", NULL
43890 };
43891
43892 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
43893 if (obj0) {
43894 ecode1 = SWIG_AsVal_int(obj0, &val1);
43895 if (!SWIG_IsOK(ecode1)) {
43896 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
43897 }
43898 arg1 = static_cast< wxWindowVariant >(val1);
43899 }
43900 {
43901 if (!wxPyCheckForApp()) SWIG_fail;
43902 PyThreadState* __tstate = wxPyBeginAllowThreads();
43903 result = wxControl::GetClassDefaultAttributes(arg1);
43904 wxPyEndAllowThreads(__tstate);
43905 if (PyErr_Occurred()) SWIG_fail;
43906 }
43907 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
43908 return resultobj;
43909 fail:
43910 return NULL;
43911 }
43912
43913
43914 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43915 PyObject *obj;
43916 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
43917 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
43918 return SWIG_Py_Void();
43919 }
43920
43921 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43922 return SWIG_Python_InitShadowInstance(args);
43923 }
43924
43925 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43926 PyObject *resultobj = 0;
43927 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
43928 wxString *arg2 = 0 ;
43929 PyObject *arg3 = (PyObject *) NULL ;
43930 int result;
43931 void *argp1 = 0 ;
43932 int res1 = 0 ;
43933 bool temp2 = false ;
43934 PyObject * obj0 = 0 ;
43935 PyObject * obj1 = 0 ;
43936 PyObject * obj2 = 0 ;
43937 char * kwnames[] = {
43938 (char *) "self",(char *) "item",(char *) "clientData", NULL
43939 };
43940
43941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43942 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
43943 if (!SWIG_IsOK(res1)) {
43944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
43945 }
43946 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
43947 {
43948 arg2 = wxString_in_helper(obj1);
43949 if (arg2 == NULL) SWIG_fail;
43950 temp2 = true;
43951 }
43952 if (obj2) {
43953 arg3 = obj2;
43954 }
43955 {
43956 PyThreadState* __tstate = wxPyBeginAllowThreads();
43957 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
43958 wxPyEndAllowThreads(__tstate);
43959 if (PyErr_Occurred()) SWIG_fail;
43960 }
43961 resultobj = SWIG_From_int(static_cast< int >(result));
43962 {
43963 if (temp2)
43964 delete arg2;
43965 }
43966 return resultobj;
43967 fail:
43968 {
43969 if (temp2)
43970 delete arg2;
43971 }
43972 return NULL;
43973 }
43974
43975
43976 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43977 PyObject *resultobj = 0;
43978 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
43979 wxArrayString *arg2 = 0 ;
43980 void *argp1 = 0 ;
43981 int res1 = 0 ;
43982 bool temp2 = false ;
43983 PyObject * obj0 = 0 ;
43984 PyObject * obj1 = 0 ;
43985 char * kwnames[] = {
43986 (char *) "self",(char *) "strings", NULL
43987 };
43988
43989 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
43990 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
43991 if (!SWIG_IsOK(res1)) {
43992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
43993 }
43994 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
43995 {
43996 if (! PySequence_Check(obj1)) {
43997 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
43998 SWIG_fail;
43999 }
44000 arg2 = new wxArrayString;
44001 temp2 = true;
44002 int i, len=PySequence_Length(obj1);
44003 for (i=0; i<len; i++) {
44004 PyObject* item = PySequence_GetItem(obj1, i);
44005 wxString* s = wxString_in_helper(item);
44006 if (PyErr_Occurred()) SWIG_fail;
44007 arg2->Add(*s);
44008 delete s;
44009 Py_DECREF(item);
44010 }
44011 }
44012 {
44013 PyThreadState* __tstate = wxPyBeginAllowThreads();
44014 (arg1)->Append((wxArrayString const &)*arg2);
44015 wxPyEndAllowThreads(__tstate);
44016 if (PyErr_Occurred()) SWIG_fail;
44017 }
44018 resultobj = SWIG_Py_Void();
44019 {
44020 if (temp2) delete arg2;
44021 }
44022 return resultobj;
44023 fail:
44024 {
44025 if (temp2) delete arg2;
44026 }
44027 return NULL;
44028 }
44029
44030
44031 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44032 PyObject *resultobj = 0;
44033 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44034 wxString *arg2 = 0 ;
44035 unsigned int arg3 ;
44036 PyObject *arg4 = (PyObject *) NULL ;
44037 int result;
44038 void *argp1 = 0 ;
44039 int res1 = 0 ;
44040 bool temp2 = false ;
44041 unsigned int val3 ;
44042 int ecode3 = 0 ;
44043 PyObject * obj0 = 0 ;
44044 PyObject * obj1 = 0 ;
44045 PyObject * obj2 = 0 ;
44046 PyObject * obj3 = 0 ;
44047 char * kwnames[] = {
44048 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
44049 };
44050
44051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44052 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44053 if (!SWIG_IsOK(res1)) {
44054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44055 }
44056 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44057 {
44058 arg2 = wxString_in_helper(obj1);
44059 if (arg2 == NULL) SWIG_fail;
44060 temp2 = true;
44061 }
44062 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
44063 if (!SWIG_IsOK(ecode3)) {
44064 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "unsigned int""'");
44065 }
44066 arg3 = static_cast< unsigned int >(val3);
44067 if (obj3) {
44068 arg4 = obj3;
44069 }
44070 {
44071 PyThreadState* __tstate = wxPyBeginAllowThreads();
44072 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
44073 wxPyEndAllowThreads(__tstate);
44074 if (PyErr_Occurred()) SWIG_fail;
44075 }
44076 resultobj = SWIG_From_int(static_cast< int >(result));
44077 {
44078 if (temp2)
44079 delete arg2;
44080 }
44081 return resultobj;
44082 fail:
44083 {
44084 if (temp2)
44085 delete arg2;
44086 }
44087 return NULL;
44088 }
44089
44090
44091 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44092 PyObject *resultobj = 0;
44093 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44094 void *argp1 = 0 ;
44095 int res1 = 0 ;
44096 PyObject *swig_obj[1] ;
44097
44098 if (!args) SWIG_fail;
44099 swig_obj[0] = args;
44100 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44101 if (!SWIG_IsOK(res1)) {
44102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44103 }
44104 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44105 {
44106 PyThreadState* __tstate = wxPyBeginAllowThreads();
44107 (arg1)->Clear();
44108 wxPyEndAllowThreads(__tstate);
44109 if (PyErr_Occurred()) SWIG_fail;
44110 }
44111 resultobj = SWIG_Py_Void();
44112 return resultobj;
44113 fail:
44114 return NULL;
44115 }
44116
44117
44118 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44119 PyObject *resultobj = 0;
44120 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44121 unsigned int arg2 ;
44122 void *argp1 = 0 ;
44123 int res1 = 0 ;
44124 unsigned int val2 ;
44125 int ecode2 = 0 ;
44126 PyObject * obj0 = 0 ;
44127 PyObject * obj1 = 0 ;
44128 char * kwnames[] = {
44129 (char *) "self",(char *) "n", NULL
44130 };
44131
44132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
44133 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44134 if (!SWIG_IsOK(res1)) {
44135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44136 }
44137 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44138 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44139 if (!SWIG_IsOK(ecode2)) {
44140 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "unsigned int""'");
44141 }
44142 arg2 = static_cast< unsigned int >(val2);
44143 {
44144 PyThreadState* __tstate = wxPyBeginAllowThreads();
44145 (arg1)->Delete(arg2);
44146 wxPyEndAllowThreads(__tstate);
44147 if (PyErr_Occurred()) SWIG_fail;
44148 }
44149 resultobj = SWIG_Py_Void();
44150 return resultobj;
44151 fail:
44152 return NULL;
44153 }
44154
44155
44156 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44157 PyObject *resultobj = 0;
44158 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44159 unsigned int arg2 ;
44160 PyObject *result = 0 ;
44161 void *argp1 = 0 ;
44162 int res1 = 0 ;
44163 unsigned int val2 ;
44164 int ecode2 = 0 ;
44165 PyObject * obj0 = 0 ;
44166 PyObject * obj1 = 0 ;
44167 char * kwnames[] = {
44168 (char *) "self",(char *) "n", NULL
44169 };
44170
44171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
44172 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44173 if (!SWIG_IsOK(res1)) {
44174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44175 }
44176 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44177 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44178 if (!SWIG_IsOK(ecode2)) {
44179 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44180 }
44181 arg2 = static_cast< unsigned int >(val2);
44182 {
44183 PyThreadState* __tstate = wxPyBeginAllowThreads();
44184 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
44185 wxPyEndAllowThreads(__tstate);
44186 if (PyErr_Occurred()) SWIG_fail;
44187 }
44188 resultobj = result;
44189 return resultobj;
44190 fail:
44191 return NULL;
44192 }
44193
44194
44195 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44196 PyObject *resultobj = 0;
44197 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44198 unsigned int arg2 ;
44199 PyObject *arg3 = (PyObject *) 0 ;
44200 void *argp1 = 0 ;
44201 int res1 = 0 ;
44202 unsigned int val2 ;
44203 int ecode2 = 0 ;
44204 PyObject * obj0 = 0 ;
44205 PyObject * obj1 = 0 ;
44206 PyObject * obj2 = 0 ;
44207 char * kwnames[] = {
44208 (char *) "self",(char *) "n",(char *) "clientData", NULL
44209 };
44210
44211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44212 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44213 if (!SWIG_IsOK(res1)) {
44214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44215 }
44216 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44217 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44218 if (!SWIG_IsOK(ecode2)) {
44219 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44220 }
44221 arg2 = static_cast< unsigned int >(val2);
44222 arg3 = obj2;
44223 {
44224 PyThreadState* __tstate = wxPyBeginAllowThreads();
44225 wxItemContainer_SetClientData(arg1,arg2,arg3);
44226 wxPyEndAllowThreads(__tstate);
44227 if (PyErr_Occurred()) SWIG_fail;
44228 }
44229 resultobj = SWIG_Py_Void();
44230 return resultobj;
44231 fail:
44232 return NULL;
44233 }
44234
44235
44236 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44237 PyObject *resultobj = 0;
44238 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44239 unsigned int result;
44240 void *argp1 = 0 ;
44241 int res1 = 0 ;
44242 PyObject *swig_obj[1] ;
44243
44244 if (!args) SWIG_fail;
44245 swig_obj[0] = args;
44246 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44247 if (!SWIG_IsOK(res1)) {
44248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44249 }
44250 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44251 {
44252 PyThreadState* __tstate = wxPyBeginAllowThreads();
44253 result = (unsigned int)((wxItemContainer const *)arg1)->GetCount();
44254 wxPyEndAllowThreads(__tstate);
44255 if (PyErr_Occurred()) SWIG_fail;
44256 }
44257 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
44258 return resultobj;
44259 fail:
44260 return NULL;
44261 }
44262
44263
44264 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44265 PyObject *resultobj = 0;
44266 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44267 bool result;
44268 void *argp1 = 0 ;
44269 int res1 = 0 ;
44270 PyObject *swig_obj[1] ;
44271
44272 if (!args) SWIG_fail;
44273 swig_obj[0] = args;
44274 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44275 if (!SWIG_IsOK(res1)) {
44276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44277 }
44278 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44279 {
44280 PyThreadState* __tstate = wxPyBeginAllowThreads();
44281 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
44282 wxPyEndAllowThreads(__tstate);
44283 if (PyErr_Occurred()) SWIG_fail;
44284 }
44285 {
44286 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44287 }
44288 return resultobj;
44289 fail:
44290 return NULL;
44291 }
44292
44293
44294 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44295 PyObject *resultobj = 0;
44296 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44297 unsigned int arg2 ;
44298 wxString result;
44299 void *argp1 = 0 ;
44300 int res1 = 0 ;
44301 unsigned int val2 ;
44302 int ecode2 = 0 ;
44303 PyObject * obj0 = 0 ;
44304 PyObject * obj1 = 0 ;
44305 char * kwnames[] = {
44306 (char *) "self",(char *) "n", NULL
44307 };
44308
44309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
44310 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44311 if (!SWIG_IsOK(res1)) {
44312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44313 }
44314 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44315 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44316 if (!SWIG_IsOK(ecode2)) {
44317 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "unsigned int""'");
44318 }
44319 arg2 = static_cast< unsigned int >(val2);
44320 {
44321 PyThreadState* __tstate = wxPyBeginAllowThreads();
44322 result = ((wxItemContainer const *)arg1)->GetString(arg2);
44323 wxPyEndAllowThreads(__tstate);
44324 if (PyErr_Occurred()) SWIG_fail;
44325 }
44326 {
44327 #if wxUSE_UNICODE
44328 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44329 #else
44330 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44331 #endif
44332 }
44333 return resultobj;
44334 fail:
44335 return NULL;
44336 }
44337
44338
44339 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44340 PyObject *resultobj = 0;
44341 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44342 wxArrayString result;
44343 void *argp1 = 0 ;
44344 int res1 = 0 ;
44345 PyObject *swig_obj[1] ;
44346
44347 if (!args) SWIG_fail;
44348 swig_obj[0] = args;
44349 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44350 if (!SWIG_IsOK(res1)) {
44351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44352 }
44353 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44354 {
44355 PyThreadState* __tstate = wxPyBeginAllowThreads();
44356 result = ((wxItemContainer const *)arg1)->GetStrings();
44357 wxPyEndAllowThreads(__tstate);
44358 if (PyErr_Occurred()) SWIG_fail;
44359 }
44360 {
44361 resultobj = wxArrayString2PyList_helper(result);
44362 }
44363 return resultobj;
44364 fail:
44365 return NULL;
44366 }
44367
44368
44369 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44370 PyObject *resultobj = 0;
44371 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44372 unsigned int arg2 ;
44373 wxString *arg3 = 0 ;
44374 void *argp1 = 0 ;
44375 int res1 = 0 ;
44376 unsigned int val2 ;
44377 int ecode2 = 0 ;
44378 bool temp3 = false ;
44379 PyObject * obj0 = 0 ;
44380 PyObject * obj1 = 0 ;
44381 PyObject * obj2 = 0 ;
44382 char * kwnames[] = {
44383 (char *) "self",(char *) "n",(char *) "s", NULL
44384 };
44385
44386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44387 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44388 if (!SWIG_IsOK(res1)) {
44389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44390 }
44391 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44392 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44393 if (!SWIG_IsOK(ecode2)) {
44394 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "unsigned int""'");
44395 }
44396 arg2 = static_cast< unsigned int >(val2);
44397 {
44398 arg3 = wxString_in_helper(obj2);
44399 if (arg3 == NULL) SWIG_fail;
44400 temp3 = true;
44401 }
44402 {
44403 PyThreadState* __tstate = wxPyBeginAllowThreads();
44404 (arg1)->SetString(arg2,(wxString const &)*arg3);
44405 wxPyEndAllowThreads(__tstate);
44406 if (PyErr_Occurred()) SWIG_fail;
44407 }
44408 resultobj = SWIG_Py_Void();
44409 {
44410 if (temp3)
44411 delete arg3;
44412 }
44413 return resultobj;
44414 fail:
44415 {
44416 if (temp3)
44417 delete arg3;
44418 }
44419 return NULL;
44420 }
44421
44422
44423 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44424 PyObject *resultobj = 0;
44425 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44426 wxString *arg2 = 0 ;
44427 int result;
44428 void *argp1 = 0 ;
44429 int res1 = 0 ;
44430 bool temp2 = false ;
44431 PyObject * obj0 = 0 ;
44432 PyObject * obj1 = 0 ;
44433 char * kwnames[] = {
44434 (char *) "self",(char *) "s", NULL
44435 };
44436
44437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
44438 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44439 if (!SWIG_IsOK(res1)) {
44440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44441 }
44442 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44443 {
44444 arg2 = wxString_in_helper(obj1);
44445 if (arg2 == NULL) SWIG_fail;
44446 temp2 = true;
44447 }
44448 {
44449 PyThreadState* __tstate = wxPyBeginAllowThreads();
44450 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
44451 wxPyEndAllowThreads(__tstate);
44452 if (PyErr_Occurred()) SWIG_fail;
44453 }
44454 resultobj = SWIG_From_int(static_cast< int >(result));
44455 {
44456 if (temp2)
44457 delete arg2;
44458 }
44459 return resultobj;
44460 fail:
44461 {
44462 if (temp2)
44463 delete arg2;
44464 }
44465 return NULL;
44466 }
44467
44468
44469 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44470 PyObject *resultobj = 0;
44471 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44472 int arg2 ;
44473 void *argp1 = 0 ;
44474 int res1 = 0 ;
44475 int val2 ;
44476 int ecode2 = 0 ;
44477 PyObject * obj0 = 0 ;
44478 PyObject * obj1 = 0 ;
44479 char * kwnames[] = {
44480 (char *) "self",(char *) "n", NULL
44481 };
44482
44483 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
44484 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44485 if (!SWIG_IsOK(res1)) {
44486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44487 }
44488 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44489 ecode2 = SWIG_AsVal_int(obj1, &val2);
44490 if (!SWIG_IsOK(ecode2)) {
44491 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
44492 }
44493 arg2 = static_cast< int >(val2);
44494 {
44495 PyThreadState* __tstate = wxPyBeginAllowThreads();
44496 (arg1)->SetSelection(arg2);
44497 wxPyEndAllowThreads(__tstate);
44498 if (PyErr_Occurred()) SWIG_fail;
44499 }
44500 resultobj = SWIG_Py_Void();
44501 return resultobj;
44502 fail:
44503 return NULL;
44504 }
44505
44506
44507 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44508 PyObject *resultobj = 0;
44509 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44510 int result;
44511 void *argp1 = 0 ;
44512 int res1 = 0 ;
44513 PyObject *swig_obj[1] ;
44514
44515 if (!args) SWIG_fail;
44516 swig_obj[0] = args;
44517 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44518 if (!SWIG_IsOK(res1)) {
44519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44520 }
44521 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44522 {
44523 PyThreadState* __tstate = wxPyBeginAllowThreads();
44524 result = (int)((wxItemContainer const *)arg1)->GetSelection();
44525 wxPyEndAllowThreads(__tstate);
44526 if (PyErr_Occurred()) SWIG_fail;
44527 }
44528 resultobj = SWIG_From_int(static_cast< int >(result));
44529 return resultobj;
44530 fail:
44531 return NULL;
44532 }
44533
44534
44535 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44536 PyObject *resultobj = 0;
44537 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44538 wxString *arg2 = 0 ;
44539 bool result;
44540 void *argp1 = 0 ;
44541 int res1 = 0 ;
44542 bool temp2 = false ;
44543 PyObject * obj0 = 0 ;
44544 PyObject * obj1 = 0 ;
44545 char * kwnames[] = {
44546 (char *) "self",(char *) "s", NULL
44547 };
44548
44549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
44550 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44551 if (!SWIG_IsOK(res1)) {
44552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44553 }
44554 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44555 {
44556 arg2 = wxString_in_helper(obj1);
44557 if (arg2 == NULL) SWIG_fail;
44558 temp2 = true;
44559 }
44560 {
44561 PyThreadState* __tstate = wxPyBeginAllowThreads();
44562 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
44563 wxPyEndAllowThreads(__tstate);
44564 if (PyErr_Occurred()) SWIG_fail;
44565 }
44566 {
44567 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44568 }
44569 {
44570 if (temp2)
44571 delete arg2;
44572 }
44573 return resultobj;
44574 fail:
44575 {
44576 if (temp2)
44577 delete arg2;
44578 }
44579 return NULL;
44580 }
44581
44582
44583 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44584 PyObject *resultobj = 0;
44585 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44586 wxString result;
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_wxItemContainer, 0 | 0 );
44594 if (!SWIG_IsOK(res1)) {
44595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44596 }
44597 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44598 {
44599 PyThreadState* __tstate = wxPyBeginAllowThreads();
44600 result = ((wxItemContainer const *)arg1)->GetStringSelection();
44601 wxPyEndAllowThreads(__tstate);
44602 if (PyErr_Occurred()) SWIG_fail;
44603 }
44604 {
44605 #if wxUSE_UNICODE
44606 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44607 #else
44608 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44609 #endif
44610 }
44611 return resultobj;
44612 fail:
44613 return NULL;
44614 }
44615
44616
44617 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44618 PyObject *resultobj = 0;
44619 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44620 int arg2 ;
44621 void *argp1 = 0 ;
44622 int res1 = 0 ;
44623 int val2 ;
44624 int ecode2 = 0 ;
44625 PyObject * obj0 = 0 ;
44626 PyObject * obj1 = 0 ;
44627 char * kwnames[] = {
44628 (char *) "self",(char *) "n", NULL
44629 };
44630
44631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
44632 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44633 if (!SWIG_IsOK(res1)) {
44634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44635 }
44636 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44637 ecode2 = SWIG_AsVal_int(obj1, &val2);
44638 if (!SWIG_IsOK(ecode2)) {
44639 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
44640 }
44641 arg2 = static_cast< int >(val2);
44642 {
44643 PyThreadState* __tstate = wxPyBeginAllowThreads();
44644 (arg1)->Select(arg2);
44645 wxPyEndAllowThreads(__tstate);
44646 if (PyErr_Occurred()) SWIG_fail;
44647 }
44648 resultobj = SWIG_Py_Void();
44649 return resultobj;
44650 fail:
44651 return NULL;
44652 }
44653
44654
44655 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44656 PyObject *obj;
44657 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44658 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
44659 return SWIG_Py_Void();
44660 }
44661
44662 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44663 PyObject *obj;
44664 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44665 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
44666 return SWIG_Py_Void();
44667 }
44668
44669 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44670 PyObject *resultobj = 0;
44671 wxSizerItem *result = 0 ;
44672
44673 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
44674 {
44675 PyThreadState* __tstate = wxPyBeginAllowThreads();
44676 result = (wxSizerItem *)new wxSizerItem();
44677 wxPyEndAllowThreads(__tstate);
44678 if (PyErr_Occurred()) SWIG_fail;
44679 }
44680 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
44681 return resultobj;
44682 fail:
44683 return NULL;
44684 }
44685
44686
44687 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44688 PyObject *resultobj = 0;
44689 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44690 void *argp1 = 0 ;
44691 int res1 = 0 ;
44692 PyObject *swig_obj[1] ;
44693
44694 if (!args) SWIG_fail;
44695 swig_obj[0] = args;
44696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
44697 if (!SWIG_IsOK(res1)) {
44698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44699 }
44700 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44701 {
44702 PyThreadState* __tstate = wxPyBeginAllowThreads();
44703 delete arg1;
44704
44705 wxPyEndAllowThreads(__tstate);
44706 if (PyErr_Occurred()) SWIG_fail;
44707 }
44708 resultobj = SWIG_Py_Void();
44709 return resultobj;
44710 fail:
44711 return NULL;
44712 }
44713
44714
44715 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44716 PyObject *resultobj = 0;
44717 wxWindow *arg1 = (wxWindow *) 0 ;
44718 int arg2 ;
44719 int arg3 ;
44720 int arg4 ;
44721 PyObject *arg5 = (PyObject *) NULL ;
44722 wxSizerItem *result = 0 ;
44723 void *argp1 = 0 ;
44724 int res1 = 0 ;
44725 int val2 ;
44726 int ecode2 = 0 ;
44727 int val3 ;
44728 int ecode3 = 0 ;
44729 int val4 ;
44730 int ecode4 = 0 ;
44731 PyObject * obj0 = 0 ;
44732 PyObject * obj1 = 0 ;
44733 PyObject * obj2 = 0 ;
44734 PyObject * obj3 = 0 ;
44735 PyObject * obj4 = 0 ;
44736 char * kwnames[] = {
44737 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
44738 };
44739
44740 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
44741 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
44742 if (!SWIG_IsOK(res1)) {
44743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
44744 }
44745 arg1 = reinterpret_cast< wxWindow * >(argp1);
44746 ecode2 = SWIG_AsVal_int(obj1, &val2);
44747 if (!SWIG_IsOK(ecode2)) {
44748 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
44749 }
44750 arg2 = static_cast< int >(val2);
44751 ecode3 = SWIG_AsVal_int(obj2, &val3);
44752 if (!SWIG_IsOK(ecode3)) {
44753 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
44754 }
44755 arg3 = static_cast< int >(val3);
44756 ecode4 = SWIG_AsVal_int(obj3, &val4);
44757 if (!SWIG_IsOK(ecode4)) {
44758 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
44759 }
44760 arg4 = static_cast< int >(val4);
44761 if (obj4) {
44762 arg5 = obj4;
44763 }
44764 {
44765 PyThreadState* __tstate = wxPyBeginAllowThreads();
44766 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
44767 wxPyEndAllowThreads(__tstate);
44768 if (PyErr_Occurred()) SWIG_fail;
44769 }
44770 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
44771 return resultobj;
44772 fail:
44773 return NULL;
44774 }
44775
44776
44777 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44778 PyObject *resultobj = 0;
44779 int arg1 ;
44780 int arg2 ;
44781 int arg3 ;
44782 int arg4 ;
44783 int arg5 ;
44784 PyObject *arg6 = (PyObject *) NULL ;
44785 wxSizerItem *result = 0 ;
44786 int val1 ;
44787 int ecode1 = 0 ;
44788 int val2 ;
44789 int ecode2 = 0 ;
44790 int val3 ;
44791 int ecode3 = 0 ;
44792 int val4 ;
44793 int ecode4 = 0 ;
44794 int val5 ;
44795 int ecode5 = 0 ;
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 char * kwnames[] = {
44803 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
44804 };
44805
44806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
44807 ecode1 = SWIG_AsVal_int(obj0, &val1);
44808 if (!SWIG_IsOK(ecode1)) {
44809 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
44810 }
44811 arg1 = static_cast< int >(val1);
44812 ecode2 = SWIG_AsVal_int(obj1, &val2);
44813 if (!SWIG_IsOK(ecode2)) {
44814 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
44815 }
44816 arg2 = static_cast< int >(val2);
44817 ecode3 = SWIG_AsVal_int(obj2, &val3);
44818 if (!SWIG_IsOK(ecode3)) {
44819 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
44820 }
44821 arg3 = static_cast< int >(val3);
44822 ecode4 = SWIG_AsVal_int(obj3, &val4);
44823 if (!SWIG_IsOK(ecode4)) {
44824 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
44825 }
44826 arg4 = static_cast< int >(val4);
44827 ecode5 = SWIG_AsVal_int(obj4, &val5);
44828 if (!SWIG_IsOK(ecode5)) {
44829 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
44830 }
44831 arg5 = static_cast< int >(val5);
44832 if (obj5) {
44833 arg6 = obj5;
44834 }
44835 {
44836 PyThreadState* __tstate = wxPyBeginAllowThreads();
44837 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
44838 wxPyEndAllowThreads(__tstate);
44839 if (PyErr_Occurred()) SWIG_fail;
44840 }
44841 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
44842 return resultobj;
44843 fail:
44844 return NULL;
44845 }
44846
44847
44848 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44849 PyObject *resultobj = 0;
44850 wxSizer *arg1 = (wxSizer *) 0 ;
44851 int arg2 ;
44852 int arg3 ;
44853 int arg4 ;
44854 PyObject *arg5 = (PyObject *) NULL ;
44855 wxSizerItem *result = 0 ;
44856 int res1 = 0 ;
44857 int val2 ;
44858 int ecode2 = 0 ;
44859 int val3 ;
44860 int ecode3 = 0 ;
44861 int val4 ;
44862 int ecode4 = 0 ;
44863 PyObject * obj0 = 0 ;
44864 PyObject * obj1 = 0 ;
44865 PyObject * obj2 = 0 ;
44866 PyObject * obj3 = 0 ;
44867 PyObject * obj4 = 0 ;
44868 char * kwnames[] = {
44869 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
44870 };
44871
44872 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
44873 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
44874 if (!SWIG_IsOK(res1)) {
44875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
44876 }
44877 ecode2 = SWIG_AsVal_int(obj1, &val2);
44878 if (!SWIG_IsOK(ecode2)) {
44879 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
44880 }
44881 arg2 = static_cast< int >(val2);
44882 ecode3 = SWIG_AsVal_int(obj2, &val3);
44883 if (!SWIG_IsOK(ecode3)) {
44884 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
44885 }
44886 arg3 = static_cast< int >(val3);
44887 ecode4 = SWIG_AsVal_int(obj3, &val4);
44888 if (!SWIG_IsOK(ecode4)) {
44889 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
44890 }
44891 arg4 = static_cast< int >(val4);
44892 if (obj4) {
44893 arg5 = obj4;
44894 }
44895 {
44896 PyThreadState* __tstate = wxPyBeginAllowThreads();
44897 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
44898 wxPyEndAllowThreads(__tstate);
44899 if (PyErr_Occurred()) SWIG_fail;
44900 }
44901 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
44902 return resultobj;
44903 fail:
44904 return NULL;
44905 }
44906
44907
44908 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44909 PyObject *resultobj = 0;
44910 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44911 void *argp1 = 0 ;
44912 int res1 = 0 ;
44913 PyObject *swig_obj[1] ;
44914
44915 if (!args) SWIG_fail;
44916 swig_obj[0] = args;
44917 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44918 if (!SWIG_IsOK(res1)) {
44919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44920 }
44921 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44922 {
44923 PyThreadState* __tstate = wxPyBeginAllowThreads();
44924 (arg1)->DeleteWindows();
44925 wxPyEndAllowThreads(__tstate);
44926 if (PyErr_Occurred()) SWIG_fail;
44927 }
44928 resultobj = SWIG_Py_Void();
44929 return resultobj;
44930 fail:
44931 return NULL;
44932 }
44933
44934
44935 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44936 PyObject *resultobj = 0;
44937 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44938 void *argp1 = 0 ;
44939 int res1 = 0 ;
44940 PyObject *swig_obj[1] ;
44941
44942 if (!args) SWIG_fail;
44943 swig_obj[0] = args;
44944 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44945 if (!SWIG_IsOK(res1)) {
44946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44947 }
44948 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44949 {
44950 PyThreadState* __tstate = wxPyBeginAllowThreads();
44951 (arg1)->DetachSizer();
44952 wxPyEndAllowThreads(__tstate);
44953 if (PyErr_Occurred()) SWIG_fail;
44954 }
44955 resultobj = SWIG_Py_Void();
44956 return resultobj;
44957 fail:
44958 return NULL;
44959 }
44960
44961
44962 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44963 PyObject *resultobj = 0;
44964 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44965 wxSize result;
44966 void *argp1 = 0 ;
44967 int res1 = 0 ;
44968 PyObject *swig_obj[1] ;
44969
44970 if (!args) SWIG_fail;
44971 swig_obj[0] = args;
44972 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44973 if (!SWIG_IsOK(res1)) {
44974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44975 }
44976 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44977 {
44978 PyThreadState* __tstate = wxPyBeginAllowThreads();
44979 result = (arg1)->GetSize();
44980 wxPyEndAllowThreads(__tstate);
44981 if (PyErr_Occurred()) SWIG_fail;
44982 }
44983 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
44984 return resultobj;
44985 fail:
44986 return NULL;
44987 }
44988
44989
44990 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44991 PyObject *resultobj = 0;
44992 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44993 wxSize result;
44994 void *argp1 = 0 ;
44995 int res1 = 0 ;
44996 PyObject *swig_obj[1] ;
44997
44998 if (!args) SWIG_fail;
44999 swig_obj[0] = args;
45000 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45001 if (!SWIG_IsOK(res1)) {
45002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45003 }
45004 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45005 {
45006 PyThreadState* __tstate = wxPyBeginAllowThreads();
45007 result = (arg1)->CalcMin();
45008 wxPyEndAllowThreads(__tstate);
45009 if (PyErr_Occurred()) SWIG_fail;
45010 }
45011 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45012 return resultobj;
45013 fail:
45014 return NULL;
45015 }
45016
45017
45018 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45019 PyObject *resultobj = 0;
45020 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45021 wxPoint *arg2 = 0 ;
45022 wxSize *arg3 = 0 ;
45023 void *argp1 = 0 ;
45024 int res1 = 0 ;
45025 wxPoint temp2 ;
45026 wxSize temp3 ;
45027 PyObject * obj0 = 0 ;
45028 PyObject * obj1 = 0 ;
45029 PyObject * obj2 = 0 ;
45030 char * kwnames[] = {
45031 (char *) "self",(char *) "pos",(char *) "size", NULL
45032 };
45033
45034 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45035 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45036 if (!SWIG_IsOK(res1)) {
45037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45038 }
45039 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45040 {
45041 arg2 = &temp2;
45042 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
45043 }
45044 {
45045 arg3 = &temp3;
45046 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
45047 }
45048 {
45049 PyThreadState* __tstate = wxPyBeginAllowThreads();
45050 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
45051 wxPyEndAllowThreads(__tstate);
45052 if (PyErr_Occurred()) SWIG_fail;
45053 }
45054 resultobj = SWIG_Py_Void();
45055 return resultobj;
45056 fail:
45057 return NULL;
45058 }
45059
45060
45061 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45062 PyObject *resultobj = 0;
45063 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45064 wxSize result;
45065 void *argp1 = 0 ;
45066 int res1 = 0 ;
45067 PyObject *swig_obj[1] ;
45068
45069 if (!args) SWIG_fail;
45070 swig_obj[0] = args;
45071 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45072 if (!SWIG_IsOK(res1)) {
45073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45074 }
45075 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45076 {
45077 PyThreadState* __tstate = wxPyBeginAllowThreads();
45078 result = (arg1)->GetMinSize();
45079 wxPyEndAllowThreads(__tstate);
45080 if (PyErr_Occurred()) SWIG_fail;
45081 }
45082 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45083 return resultobj;
45084 fail:
45085 return NULL;
45086 }
45087
45088
45089 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45090 PyObject *resultobj = 0;
45091 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45092 wxSize result;
45093 void *argp1 = 0 ;
45094 int res1 = 0 ;
45095 PyObject *swig_obj[1] ;
45096
45097 if (!args) SWIG_fail;
45098 swig_obj[0] = args;
45099 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45100 if (!SWIG_IsOK(res1)) {
45101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
45102 }
45103 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45104 {
45105 PyThreadState* __tstate = wxPyBeginAllowThreads();
45106 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
45107 wxPyEndAllowThreads(__tstate);
45108 if (PyErr_Occurred()) SWIG_fail;
45109 }
45110 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45111 return resultobj;
45112 fail:
45113 return NULL;
45114 }
45115
45116
45117 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45118 PyObject *resultobj = 0;
45119 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45120 int arg2 ;
45121 int arg3 ;
45122 void *argp1 = 0 ;
45123 int res1 = 0 ;
45124 int val2 ;
45125 int ecode2 = 0 ;
45126 int val3 ;
45127 int ecode3 = 0 ;
45128 PyObject * obj0 = 0 ;
45129 PyObject * obj1 = 0 ;
45130 PyObject * obj2 = 0 ;
45131 char * kwnames[] = {
45132 (char *) "self",(char *) "x",(char *) "y", NULL
45133 };
45134
45135 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45136 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45137 if (!SWIG_IsOK(res1)) {
45138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45139 }
45140 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45141 ecode2 = SWIG_AsVal_int(obj1, &val2);
45142 if (!SWIG_IsOK(ecode2)) {
45143 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
45144 }
45145 arg2 = static_cast< int >(val2);
45146 ecode3 = SWIG_AsVal_int(obj2, &val3);
45147 if (!SWIG_IsOK(ecode3)) {
45148 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
45149 }
45150 arg3 = static_cast< int >(val3);
45151 {
45152 PyThreadState* __tstate = wxPyBeginAllowThreads();
45153 (arg1)->SetInitSize(arg2,arg3);
45154 wxPyEndAllowThreads(__tstate);
45155 if (PyErr_Occurred()) SWIG_fail;
45156 }
45157 resultobj = SWIG_Py_Void();
45158 return resultobj;
45159 fail:
45160 return NULL;
45161 }
45162
45163
45164 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45165 PyObject *resultobj = 0;
45166 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45167 int arg2 ;
45168 int arg3 ;
45169 void *argp1 = 0 ;
45170 int res1 = 0 ;
45171 int val2 ;
45172 int ecode2 = 0 ;
45173 int val3 ;
45174 int ecode3 = 0 ;
45175 PyObject * obj0 = 0 ;
45176 PyObject * obj1 = 0 ;
45177 PyObject * obj2 = 0 ;
45178 char * kwnames[] = {
45179 (char *) "self",(char *) "width",(char *) "height", NULL
45180 };
45181
45182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45183 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45184 if (!SWIG_IsOK(res1)) {
45185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45186 }
45187 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45188 ecode2 = SWIG_AsVal_int(obj1, &val2);
45189 if (!SWIG_IsOK(ecode2)) {
45190 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
45191 }
45192 arg2 = static_cast< int >(val2);
45193 ecode3 = SWIG_AsVal_int(obj2, &val3);
45194 if (!SWIG_IsOK(ecode3)) {
45195 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
45196 }
45197 arg3 = static_cast< int >(val3);
45198 {
45199 PyThreadState* __tstate = wxPyBeginAllowThreads();
45200 (arg1)->SetRatio(arg2,arg3);
45201 wxPyEndAllowThreads(__tstate);
45202 if (PyErr_Occurred()) SWIG_fail;
45203 }
45204 resultobj = SWIG_Py_Void();
45205 return resultobj;
45206 fail:
45207 return NULL;
45208 }
45209
45210
45211 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45212 PyObject *resultobj = 0;
45213 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45214 wxSize *arg2 = 0 ;
45215 void *argp1 = 0 ;
45216 int res1 = 0 ;
45217 wxSize temp2 ;
45218 PyObject * obj0 = 0 ;
45219 PyObject * obj1 = 0 ;
45220 char * kwnames[] = {
45221 (char *) "self",(char *) "size", NULL
45222 };
45223
45224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
45225 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45226 if (!SWIG_IsOK(res1)) {
45227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45228 }
45229 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45230 {
45231 arg2 = &temp2;
45232 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
45233 }
45234 {
45235 PyThreadState* __tstate = wxPyBeginAllowThreads();
45236 (arg1)->SetRatio((wxSize const &)*arg2);
45237 wxPyEndAllowThreads(__tstate);
45238 if (PyErr_Occurred()) SWIG_fail;
45239 }
45240 resultobj = SWIG_Py_Void();
45241 return resultobj;
45242 fail:
45243 return NULL;
45244 }
45245
45246
45247 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45248 PyObject *resultobj = 0;
45249 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45250 float arg2 ;
45251 void *argp1 = 0 ;
45252 int res1 = 0 ;
45253 float val2 ;
45254 int ecode2 = 0 ;
45255 PyObject * obj0 = 0 ;
45256 PyObject * obj1 = 0 ;
45257 char * kwnames[] = {
45258 (char *) "self",(char *) "ratio", NULL
45259 };
45260
45261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
45262 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45263 if (!SWIG_IsOK(res1)) {
45264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45265 }
45266 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45267 ecode2 = SWIG_AsVal_float(obj1, &val2);
45268 if (!SWIG_IsOK(ecode2)) {
45269 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
45270 }
45271 arg2 = static_cast< float >(val2);
45272 {
45273 PyThreadState* __tstate = wxPyBeginAllowThreads();
45274 (arg1)->SetRatio(arg2);
45275 wxPyEndAllowThreads(__tstate);
45276 if (PyErr_Occurred()) SWIG_fail;
45277 }
45278 resultobj = SWIG_Py_Void();
45279 return resultobj;
45280 fail:
45281 return NULL;
45282 }
45283
45284
45285 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45286 PyObject *resultobj = 0;
45287 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45288 float result;
45289 void *argp1 = 0 ;
45290 int res1 = 0 ;
45291 PyObject *swig_obj[1] ;
45292
45293 if (!args) SWIG_fail;
45294 swig_obj[0] = args;
45295 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45296 if (!SWIG_IsOK(res1)) {
45297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45298 }
45299 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45300 {
45301 PyThreadState* __tstate = wxPyBeginAllowThreads();
45302 result = (float)(arg1)->GetRatio();
45303 wxPyEndAllowThreads(__tstate);
45304 if (PyErr_Occurred()) SWIG_fail;
45305 }
45306 resultobj = SWIG_From_float(static_cast< float >(result));
45307 return resultobj;
45308 fail:
45309 return NULL;
45310 }
45311
45312
45313 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45314 PyObject *resultobj = 0;
45315 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45316 wxRect result;
45317 void *argp1 = 0 ;
45318 int res1 = 0 ;
45319 PyObject *swig_obj[1] ;
45320
45321 if (!args) SWIG_fail;
45322 swig_obj[0] = args;
45323 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45324 if (!SWIG_IsOK(res1)) {
45325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45326 }
45327 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45328 {
45329 PyThreadState* __tstate = wxPyBeginAllowThreads();
45330 result = (arg1)->GetRect();
45331 wxPyEndAllowThreads(__tstate);
45332 if (PyErr_Occurred()) SWIG_fail;
45333 }
45334 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
45335 return resultobj;
45336 fail:
45337 return NULL;
45338 }
45339
45340
45341 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45342 PyObject *resultobj = 0;
45343 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45344 bool result;
45345 void *argp1 = 0 ;
45346 int res1 = 0 ;
45347 PyObject *swig_obj[1] ;
45348
45349 if (!args) SWIG_fail;
45350 swig_obj[0] = args;
45351 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45352 if (!SWIG_IsOK(res1)) {
45353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45354 }
45355 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45356 {
45357 PyThreadState* __tstate = wxPyBeginAllowThreads();
45358 result = (bool)(arg1)->IsWindow();
45359 wxPyEndAllowThreads(__tstate);
45360 if (PyErr_Occurred()) SWIG_fail;
45361 }
45362 {
45363 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45364 }
45365 return resultobj;
45366 fail:
45367 return NULL;
45368 }
45369
45370
45371 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45372 PyObject *resultobj = 0;
45373 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45374 bool result;
45375 void *argp1 = 0 ;
45376 int res1 = 0 ;
45377 PyObject *swig_obj[1] ;
45378
45379 if (!args) SWIG_fail;
45380 swig_obj[0] = args;
45381 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45382 if (!SWIG_IsOK(res1)) {
45383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45384 }
45385 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45386 {
45387 PyThreadState* __tstate = wxPyBeginAllowThreads();
45388 result = (bool)(arg1)->IsSizer();
45389 wxPyEndAllowThreads(__tstate);
45390 if (PyErr_Occurred()) SWIG_fail;
45391 }
45392 {
45393 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45394 }
45395 return resultobj;
45396 fail:
45397 return NULL;
45398 }
45399
45400
45401 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45402 PyObject *resultobj = 0;
45403 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45404 bool result;
45405 void *argp1 = 0 ;
45406 int res1 = 0 ;
45407 PyObject *swig_obj[1] ;
45408
45409 if (!args) SWIG_fail;
45410 swig_obj[0] = args;
45411 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45412 if (!SWIG_IsOK(res1)) {
45413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45414 }
45415 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45416 {
45417 PyThreadState* __tstate = wxPyBeginAllowThreads();
45418 result = (bool)(arg1)->IsSpacer();
45419 wxPyEndAllowThreads(__tstate);
45420 if (PyErr_Occurred()) SWIG_fail;
45421 }
45422 {
45423 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45424 }
45425 return resultobj;
45426 fail:
45427 return NULL;
45428 }
45429
45430
45431 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45432 PyObject *resultobj = 0;
45433 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45434 int arg2 ;
45435 void *argp1 = 0 ;
45436 int res1 = 0 ;
45437 int val2 ;
45438 int ecode2 = 0 ;
45439 PyObject * obj0 = 0 ;
45440 PyObject * obj1 = 0 ;
45441 char * kwnames[] = {
45442 (char *) "self",(char *) "proportion", NULL
45443 };
45444
45445 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
45446 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45447 if (!SWIG_IsOK(res1)) {
45448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45449 }
45450 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45451 ecode2 = SWIG_AsVal_int(obj1, &val2);
45452 if (!SWIG_IsOK(ecode2)) {
45453 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
45454 }
45455 arg2 = static_cast< int >(val2);
45456 {
45457 PyThreadState* __tstate = wxPyBeginAllowThreads();
45458 (arg1)->SetProportion(arg2);
45459 wxPyEndAllowThreads(__tstate);
45460 if (PyErr_Occurred()) SWIG_fail;
45461 }
45462 resultobj = SWIG_Py_Void();
45463 return resultobj;
45464 fail:
45465 return NULL;
45466 }
45467
45468
45469 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45470 PyObject *resultobj = 0;
45471 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45472 int result;
45473 void *argp1 = 0 ;
45474 int res1 = 0 ;
45475 PyObject *swig_obj[1] ;
45476
45477 if (!args) SWIG_fail;
45478 swig_obj[0] = args;
45479 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45480 if (!SWIG_IsOK(res1)) {
45481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45482 }
45483 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45484 {
45485 PyThreadState* __tstate = wxPyBeginAllowThreads();
45486 result = (int)(arg1)->GetProportion();
45487 wxPyEndAllowThreads(__tstate);
45488 if (PyErr_Occurred()) SWIG_fail;
45489 }
45490 resultobj = SWIG_From_int(static_cast< int >(result));
45491 return resultobj;
45492 fail:
45493 return NULL;
45494 }
45495
45496
45497 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45498 PyObject *resultobj = 0;
45499 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45500 int arg2 ;
45501 void *argp1 = 0 ;
45502 int res1 = 0 ;
45503 int val2 ;
45504 int ecode2 = 0 ;
45505 PyObject * obj0 = 0 ;
45506 PyObject * obj1 = 0 ;
45507 char * kwnames[] = {
45508 (char *) "self",(char *) "flag", NULL
45509 };
45510
45511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
45512 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45513 if (!SWIG_IsOK(res1)) {
45514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45515 }
45516 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45517 ecode2 = SWIG_AsVal_int(obj1, &val2);
45518 if (!SWIG_IsOK(ecode2)) {
45519 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
45520 }
45521 arg2 = static_cast< int >(val2);
45522 {
45523 PyThreadState* __tstate = wxPyBeginAllowThreads();
45524 (arg1)->SetFlag(arg2);
45525 wxPyEndAllowThreads(__tstate);
45526 if (PyErr_Occurred()) SWIG_fail;
45527 }
45528 resultobj = SWIG_Py_Void();
45529 return resultobj;
45530 fail:
45531 return NULL;
45532 }
45533
45534
45535 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45536 PyObject *resultobj = 0;
45537 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45538 int result;
45539 void *argp1 = 0 ;
45540 int res1 = 0 ;
45541 PyObject *swig_obj[1] ;
45542
45543 if (!args) SWIG_fail;
45544 swig_obj[0] = args;
45545 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45546 if (!SWIG_IsOK(res1)) {
45547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45548 }
45549 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45550 {
45551 PyThreadState* __tstate = wxPyBeginAllowThreads();
45552 result = (int)(arg1)->GetFlag();
45553 wxPyEndAllowThreads(__tstate);
45554 if (PyErr_Occurred()) SWIG_fail;
45555 }
45556 resultobj = SWIG_From_int(static_cast< int >(result));
45557 return resultobj;
45558 fail:
45559 return NULL;
45560 }
45561
45562
45563 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45564 PyObject *resultobj = 0;
45565 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45566 int arg2 ;
45567 void *argp1 = 0 ;
45568 int res1 = 0 ;
45569 int val2 ;
45570 int ecode2 = 0 ;
45571 PyObject * obj0 = 0 ;
45572 PyObject * obj1 = 0 ;
45573 char * kwnames[] = {
45574 (char *) "self",(char *) "border", NULL
45575 };
45576
45577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
45578 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45579 if (!SWIG_IsOK(res1)) {
45580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45581 }
45582 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45583 ecode2 = SWIG_AsVal_int(obj1, &val2);
45584 if (!SWIG_IsOK(ecode2)) {
45585 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
45586 }
45587 arg2 = static_cast< int >(val2);
45588 {
45589 PyThreadState* __tstate = wxPyBeginAllowThreads();
45590 (arg1)->SetBorder(arg2);
45591 wxPyEndAllowThreads(__tstate);
45592 if (PyErr_Occurred()) SWIG_fail;
45593 }
45594 resultobj = SWIG_Py_Void();
45595 return resultobj;
45596 fail:
45597 return NULL;
45598 }
45599
45600
45601 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45602 PyObject *resultobj = 0;
45603 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45604 int result;
45605 void *argp1 = 0 ;
45606 int res1 = 0 ;
45607 PyObject *swig_obj[1] ;
45608
45609 if (!args) SWIG_fail;
45610 swig_obj[0] = args;
45611 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45612 if (!SWIG_IsOK(res1)) {
45613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45614 }
45615 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45616 {
45617 PyThreadState* __tstate = wxPyBeginAllowThreads();
45618 result = (int)(arg1)->GetBorder();
45619 wxPyEndAllowThreads(__tstate);
45620 if (PyErr_Occurred()) SWIG_fail;
45621 }
45622 resultobj = SWIG_From_int(static_cast< int >(result));
45623 return resultobj;
45624 fail:
45625 return NULL;
45626 }
45627
45628
45629 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45630 PyObject *resultobj = 0;
45631 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45632 wxWindow *result = 0 ;
45633 void *argp1 = 0 ;
45634 int res1 = 0 ;
45635 PyObject *swig_obj[1] ;
45636
45637 if (!args) SWIG_fail;
45638 swig_obj[0] = args;
45639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45640 if (!SWIG_IsOK(res1)) {
45641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45642 }
45643 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45644 {
45645 PyThreadState* __tstate = wxPyBeginAllowThreads();
45646 result = (wxWindow *)(arg1)->GetWindow();
45647 wxPyEndAllowThreads(__tstate);
45648 if (PyErr_Occurred()) SWIG_fail;
45649 }
45650 {
45651 resultobj = wxPyMake_wxObject(result, 0);
45652 }
45653 return resultobj;
45654 fail:
45655 return NULL;
45656 }
45657
45658
45659 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45660 PyObject *resultobj = 0;
45661 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45662 wxWindow *arg2 = (wxWindow *) 0 ;
45663 void *argp1 = 0 ;
45664 int res1 = 0 ;
45665 void *argp2 = 0 ;
45666 int res2 = 0 ;
45667 PyObject * obj0 = 0 ;
45668 PyObject * obj1 = 0 ;
45669 char * kwnames[] = {
45670 (char *) "self",(char *) "window", NULL
45671 };
45672
45673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
45674 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45675 if (!SWIG_IsOK(res1)) {
45676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45677 }
45678 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45679 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
45680 if (!SWIG_IsOK(res2)) {
45681 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
45682 }
45683 arg2 = reinterpret_cast< wxWindow * >(argp2);
45684 {
45685 PyThreadState* __tstate = wxPyBeginAllowThreads();
45686 (arg1)->SetWindow(arg2);
45687 wxPyEndAllowThreads(__tstate);
45688 if (PyErr_Occurred()) SWIG_fail;
45689 }
45690 resultobj = SWIG_Py_Void();
45691 return resultobj;
45692 fail:
45693 return NULL;
45694 }
45695
45696
45697 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45698 PyObject *resultobj = 0;
45699 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45700 wxSizer *result = 0 ;
45701 void *argp1 = 0 ;
45702 int res1 = 0 ;
45703 PyObject *swig_obj[1] ;
45704
45705 if (!args) SWIG_fail;
45706 swig_obj[0] = args;
45707 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45708 if (!SWIG_IsOK(res1)) {
45709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45710 }
45711 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45712 {
45713 PyThreadState* __tstate = wxPyBeginAllowThreads();
45714 result = (wxSizer *)(arg1)->GetSizer();
45715 wxPyEndAllowThreads(__tstate);
45716 if (PyErr_Occurred()) SWIG_fail;
45717 }
45718 {
45719 resultobj = wxPyMake_wxObject(result, (bool)0);
45720 }
45721 return resultobj;
45722 fail:
45723 return NULL;
45724 }
45725
45726
45727 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45728 PyObject *resultobj = 0;
45729 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45730 wxSizer *arg2 = (wxSizer *) 0 ;
45731 void *argp1 = 0 ;
45732 int res1 = 0 ;
45733 int res2 = 0 ;
45734 PyObject * obj0 = 0 ;
45735 PyObject * obj1 = 0 ;
45736 char * kwnames[] = {
45737 (char *) "self",(char *) "sizer", NULL
45738 };
45739
45740 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
45741 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45742 if (!SWIG_IsOK(res1)) {
45743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45744 }
45745 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45746 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
45747 if (!SWIG_IsOK(res2)) {
45748 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
45749 }
45750 {
45751 PyThreadState* __tstate = wxPyBeginAllowThreads();
45752 (arg1)->SetSizer(arg2);
45753 wxPyEndAllowThreads(__tstate);
45754 if (PyErr_Occurred()) SWIG_fail;
45755 }
45756 resultobj = SWIG_Py_Void();
45757 return resultobj;
45758 fail:
45759 return NULL;
45760 }
45761
45762
45763 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45764 PyObject *resultobj = 0;
45765 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45766 wxSize *result = 0 ;
45767 void *argp1 = 0 ;
45768 int res1 = 0 ;
45769 PyObject *swig_obj[1] ;
45770
45771 if (!args) SWIG_fail;
45772 swig_obj[0] = args;
45773 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45774 if (!SWIG_IsOK(res1)) {
45775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45776 }
45777 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45778 {
45779 PyThreadState* __tstate = wxPyBeginAllowThreads();
45780 {
45781 wxSize const &_result_ref = (arg1)->GetSpacer();
45782 result = (wxSize *) &_result_ref;
45783 }
45784 wxPyEndAllowThreads(__tstate);
45785 if (PyErr_Occurred()) SWIG_fail;
45786 }
45787 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
45788 return resultobj;
45789 fail:
45790 return NULL;
45791 }
45792
45793
45794 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45795 PyObject *resultobj = 0;
45796 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45797 wxSize *arg2 = 0 ;
45798 void *argp1 = 0 ;
45799 int res1 = 0 ;
45800 wxSize temp2 ;
45801 PyObject * obj0 = 0 ;
45802 PyObject * obj1 = 0 ;
45803 char * kwnames[] = {
45804 (char *) "self",(char *) "size", NULL
45805 };
45806
45807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
45808 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45809 if (!SWIG_IsOK(res1)) {
45810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45811 }
45812 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45813 {
45814 arg2 = &temp2;
45815 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
45816 }
45817 {
45818 PyThreadState* __tstate = wxPyBeginAllowThreads();
45819 (arg1)->SetSpacer((wxSize const &)*arg2);
45820 wxPyEndAllowThreads(__tstate);
45821 if (PyErr_Occurred()) SWIG_fail;
45822 }
45823 resultobj = SWIG_Py_Void();
45824 return resultobj;
45825 fail:
45826 return NULL;
45827 }
45828
45829
45830 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45831 PyObject *resultobj = 0;
45832 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45833 bool arg2 ;
45834 void *argp1 = 0 ;
45835 int res1 = 0 ;
45836 bool val2 ;
45837 int ecode2 = 0 ;
45838 PyObject * obj0 = 0 ;
45839 PyObject * obj1 = 0 ;
45840 char * kwnames[] = {
45841 (char *) "self",(char *) "show", NULL
45842 };
45843
45844 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
45845 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45846 if (!SWIG_IsOK(res1)) {
45847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45848 }
45849 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45850 ecode2 = SWIG_AsVal_bool(obj1, &val2);
45851 if (!SWIG_IsOK(ecode2)) {
45852 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
45853 }
45854 arg2 = static_cast< bool >(val2);
45855 {
45856 PyThreadState* __tstate = wxPyBeginAllowThreads();
45857 (arg1)->Show(arg2);
45858 wxPyEndAllowThreads(__tstate);
45859 if (PyErr_Occurred()) SWIG_fail;
45860 }
45861 resultobj = SWIG_Py_Void();
45862 return resultobj;
45863 fail:
45864 return NULL;
45865 }
45866
45867
45868 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45869 PyObject *resultobj = 0;
45870 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45871 bool result;
45872 void *argp1 = 0 ;
45873 int res1 = 0 ;
45874 PyObject *swig_obj[1] ;
45875
45876 if (!args) SWIG_fail;
45877 swig_obj[0] = args;
45878 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45879 if (!SWIG_IsOK(res1)) {
45880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45881 }
45882 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45883 {
45884 PyThreadState* __tstate = wxPyBeginAllowThreads();
45885 result = (bool)(arg1)->IsShown();
45886 wxPyEndAllowThreads(__tstate);
45887 if (PyErr_Occurred()) SWIG_fail;
45888 }
45889 {
45890 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45891 }
45892 return resultobj;
45893 fail:
45894 return NULL;
45895 }
45896
45897
45898 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45899 PyObject *resultobj = 0;
45900 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45901 wxPoint result;
45902 void *argp1 = 0 ;
45903 int res1 = 0 ;
45904 PyObject *swig_obj[1] ;
45905
45906 if (!args) SWIG_fail;
45907 swig_obj[0] = args;
45908 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45909 if (!SWIG_IsOK(res1)) {
45910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45911 }
45912 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45913 {
45914 PyThreadState* __tstate = wxPyBeginAllowThreads();
45915 result = (arg1)->GetPosition();
45916 wxPyEndAllowThreads(__tstate);
45917 if (PyErr_Occurred()) SWIG_fail;
45918 }
45919 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
45920 return resultobj;
45921 fail:
45922 return NULL;
45923 }
45924
45925
45926 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45927 PyObject *resultobj = 0;
45928 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45929 PyObject *result = 0 ;
45930 void *argp1 = 0 ;
45931 int res1 = 0 ;
45932 PyObject *swig_obj[1] ;
45933
45934 if (!args) SWIG_fail;
45935 swig_obj[0] = args;
45936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45937 if (!SWIG_IsOK(res1)) {
45938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45939 }
45940 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45941 {
45942 PyThreadState* __tstate = wxPyBeginAllowThreads();
45943 result = (PyObject *)wxSizerItem_GetUserData(arg1);
45944 wxPyEndAllowThreads(__tstate);
45945 if (PyErr_Occurred()) SWIG_fail;
45946 }
45947 resultobj = result;
45948 return resultobj;
45949 fail:
45950 return NULL;
45951 }
45952
45953
45954 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45955 PyObject *resultobj = 0;
45956 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45957 PyObject *arg2 = (PyObject *) 0 ;
45958 void *argp1 = 0 ;
45959 int res1 = 0 ;
45960 PyObject * obj0 = 0 ;
45961 PyObject * obj1 = 0 ;
45962 char * kwnames[] = {
45963 (char *) "self",(char *) "userData", NULL
45964 };
45965
45966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
45967 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45968 if (!SWIG_IsOK(res1)) {
45969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45970 }
45971 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45972 arg2 = obj1;
45973 {
45974 PyThreadState* __tstate = wxPyBeginAllowThreads();
45975 wxSizerItem_SetUserData(arg1,arg2);
45976 wxPyEndAllowThreads(__tstate);
45977 if (PyErr_Occurred()) SWIG_fail;
45978 }
45979 resultobj = SWIG_Py_Void();
45980 return resultobj;
45981 fail:
45982 return NULL;
45983 }
45984
45985
45986 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45987 PyObject *obj;
45988 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45989 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
45990 return SWIG_Py_Void();
45991 }
45992
45993 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45994 return SWIG_Python_InitShadowInstance(args);
45995 }
45996
45997 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45998 PyObject *resultobj = 0;
45999 wxSizer *arg1 = (wxSizer *) 0 ;
46000 void *argp1 = 0 ;
46001 int res1 = 0 ;
46002 PyObject *swig_obj[1] ;
46003
46004 if (!args) SWIG_fail;
46005 swig_obj[0] = args;
46006 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46007 if (!SWIG_IsOK(res1)) {
46008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
46009 }
46010 arg1 = reinterpret_cast< wxSizer * >(argp1);
46011 {
46012 PyThreadState* __tstate = wxPyBeginAllowThreads();
46013 delete arg1;
46014
46015 wxPyEndAllowThreads(__tstate);
46016 if (PyErr_Occurred()) SWIG_fail;
46017 }
46018 resultobj = SWIG_Py_Void();
46019 return resultobj;
46020 fail:
46021 return NULL;
46022 }
46023
46024
46025 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46026 PyObject *resultobj = 0;
46027 wxSizer *arg1 = (wxSizer *) 0 ;
46028 PyObject *arg2 = (PyObject *) 0 ;
46029 void *argp1 = 0 ;
46030 int res1 = 0 ;
46031 PyObject * obj0 = 0 ;
46032 PyObject * obj1 = 0 ;
46033 char * kwnames[] = {
46034 (char *) "self",(char *) "_self", NULL
46035 };
46036
46037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
46038 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46039 if (!SWIG_IsOK(res1)) {
46040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
46041 }
46042 arg1 = reinterpret_cast< wxSizer * >(argp1);
46043 arg2 = obj1;
46044 {
46045 PyThreadState* __tstate = wxPyBeginAllowThreads();
46046 wxSizer__setOORInfo(arg1,arg2);
46047 wxPyEndAllowThreads(__tstate);
46048 if (PyErr_Occurred()) SWIG_fail;
46049 }
46050 resultobj = SWIG_Py_Void();
46051 return resultobj;
46052 fail:
46053 return NULL;
46054 }
46055
46056
46057 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46058 PyObject *resultobj = 0;
46059 wxSizer *arg1 = (wxSizer *) 0 ;
46060 PyObject *arg2 = (PyObject *) 0 ;
46061 int arg3 = (int) 0 ;
46062 int arg4 = (int) 0 ;
46063 int arg5 = (int) 0 ;
46064 PyObject *arg6 = (PyObject *) NULL ;
46065 wxSizerItem *result = 0 ;
46066 void *argp1 = 0 ;
46067 int res1 = 0 ;
46068 int val3 ;
46069 int ecode3 = 0 ;
46070 int val4 ;
46071 int ecode4 = 0 ;
46072 int val5 ;
46073 int ecode5 = 0 ;
46074 PyObject * obj0 = 0 ;
46075 PyObject * obj1 = 0 ;
46076 PyObject * obj2 = 0 ;
46077 PyObject * obj3 = 0 ;
46078 PyObject * obj4 = 0 ;
46079 PyObject * obj5 = 0 ;
46080 char * kwnames[] = {
46081 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46082 };
46083
46084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46086 if (!SWIG_IsOK(res1)) {
46087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
46088 }
46089 arg1 = reinterpret_cast< wxSizer * >(argp1);
46090 arg2 = obj1;
46091 if (obj2) {
46092 ecode3 = SWIG_AsVal_int(obj2, &val3);
46093 if (!SWIG_IsOK(ecode3)) {
46094 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
46095 }
46096 arg3 = static_cast< int >(val3);
46097 }
46098 if (obj3) {
46099 ecode4 = SWIG_AsVal_int(obj3, &val4);
46100 if (!SWIG_IsOK(ecode4)) {
46101 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
46102 }
46103 arg4 = static_cast< int >(val4);
46104 }
46105 if (obj4) {
46106 ecode5 = SWIG_AsVal_int(obj4, &val5);
46107 if (!SWIG_IsOK(ecode5)) {
46108 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
46109 }
46110 arg5 = static_cast< int >(val5);
46111 }
46112 if (obj5) {
46113 arg6 = obj5;
46114 }
46115 {
46116 PyThreadState* __tstate = wxPyBeginAllowThreads();
46117 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
46118 wxPyEndAllowThreads(__tstate);
46119 if (PyErr_Occurred()) SWIG_fail;
46120 }
46121 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46122 return resultobj;
46123 fail:
46124 return NULL;
46125 }
46126
46127
46128 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46129 PyObject *resultobj = 0;
46130 wxSizer *arg1 = (wxSizer *) 0 ;
46131 int arg2 ;
46132 PyObject *arg3 = (PyObject *) 0 ;
46133 int arg4 = (int) 0 ;
46134 int arg5 = (int) 0 ;
46135 int arg6 = (int) 0 ;
46136 PyObject *arg7 = (PyObject *) NULL ;
46137 wxSizerItem *result = 0 ;
46138 void *argp1 = 0 ;
46139 int res1 = 0 ;
46140 int val2 ;
46141 int ecode2 = 0 ;
46142 int val4 ;
46143 int ecode4 = 0 ;
46144 int val5 ;
46145 int ecode5 = 0 ;
46146 int val6 ;
46147 int ecode6 = 0 ;
46148 PyObject * obj0 = 0 ;
46149 PyObject * obj1 = 0 ;
46150 PyObject * obj2 = 0 ;
46151 PyObject * obj3 = 0 ;
46152 PyObject * obj4 = 0 ;
46153 PyObject * obj5 = 0 ;
46154 PyObject * obj6 = 0 ;
46155 char * kwnames[] = {
46156 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46157 };
46158
46159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
46160 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46161 if (!SWIG_IsOK(res1)) {
46162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
46163 }
46164 arg1 = reinterpret_cast< wxSizer * >(argp1);
46165 ecode2 = SWIG_AsVal_int(obj1, &val2);
46166 if (!SWIG_IsOK(ecode2)) {
46167 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
46168 }
46169 arg2 = static_cast< int >(val2);
46170 arg3 = obj2;
46171 if (obj3) {
46172 ecode4 = SWIG_AsVal_int(obj3, &val4);
46173 if (!SWIG_IsOK(ecode4)) {
46174 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
46175 }
46176 arg4 = static_cast< int >(val4);
46177 }
46178 if (obj4) {
46179 ecode5 = SWIG_AsVal_int(obj4, &val5);
46180 if (!SWIG_IsOK(ecode5)) {
46181 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
46182 }
46183 arg5 = static_cast< int >(val5);
46184 }
46185 if (obj5) {
46186 ecode6 = SWIG_AsVal_int(obj5, &val6);
46187 if (!SWIG_IsOK(ecode6)) {
46188 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
46189 }
46190 arg6 = static_cast< int >(val6);
46191 }
46192 if (obj6) {
46193 arg7 = obj6;
46194 }
46195 {
46196 PyThreadState* __tstate = wxPyBeginAllowThreads();
46197 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
46198 wxPyEndAllowThreads(__tstate);
46199 if (PyErr_Occurred()) SWIG_fail;
46200 }
46201 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46202 return resultobj;
46203 fail:
46204 return NULL;
46205 }
46206
46207
46208 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46209 PyObject *resultobj = 0;
46210 wxSizer *arg1 = (wxSizer *) 0 ;
46211 PyObject *arg2 = (PyObject *) 0 ;
46212 int arg3 = (int) 0 ;
46213 int arg4 = (int) 0 ;
46214 int arg5 = (int) 0 ;
46215 PyObject *arg6 = (PyObject *) NULL ;
46216 wxSizerItem *result = 0 ;
46217 void *argp1 = 0 ;
46218 int res1 = 0 ;
46219 int val3 ;
46220 int ecode3 = 0 ;
46221 int val4 ;
46222 int ecode4 = 0 ;
46223 int val5 ;
46224 int ecode5 = 0 ;
46225 PyObject * obj0 = 0 ;
46226 PyObject * obj1 = 0 ;
46227 PyObject * obj2 = 0 ;
46228 PyObject * obj3 = 0 ;
46229 PyObject * obj4 = 0 ;
46230 PyObject * obj5 = 0 ;
46231 char * kwnames[] = {
46232 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46233 };
46234
46235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46236 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46237 if (!SWIG_IsOK(res1)) {
46238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
46239 }
46240 arg1 = reinterpret_cast< wxSizer * >(argp1);
46241 arg2 = obj1;
46242 if (obj2) {
46243 ecode3 = SWIG_AsVal_int(obj2, &val3);
46244 if (!SWIG_IsOK(ecode3)) {
46245 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
46246 }
46247 arg3 = static_cast< int >(val3);
46248 }
46249 if (obj3) {
46250 ecode4 = SWIG_AsVal_int(obj3, &val4);
46251 if (!SWIG_IsOK(ecode4)) {
46252 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
46253 }
46254 arg4 = static_cast< int >(val4);
46255 }
46256 if (obj4) {
46257 ecode5 = SWIG_AsVal_int(obj4, &val5);
46258 if (!SWIG_IsOK(ecode5)) {
46259 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
46260 }
46261 arg5 = static_cast< int >(val5);
46262 }
46263 if (obj5) {
46264 arg6 = obj5;
46265 }
46266 {
46267 PyThreadState* __tstate = wxPyBeginAllowThreads();
46268 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
46269 wxPyEndAllowThreads(__tstate);
46270 if (PyErr_Occurred()) SWIG_fail;
46271 }
46272 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46273 return resultobj;
46274 fail:
46275 return NULL;
46276 }
46277
46278
46279 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46280 PyObject *resultobj = 0;
46281 wxSizer *arg1 = (wxSizer *) 0 ;
46282 PyObject *arg2 = (PyObject *) 0 ;
46283 bool result;
46284 void *argp1 = 0 ;
46285 int res1 = 0 ;
46286 PyObject * obj0 = 0 ;
46287 PyObject * obj1 = 0 ;
46288 char * kwnames[] = {
46289 (char *) "self",(char *) "item", NULL
46290 };
46291
46292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
46293 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46294 if (!SWIG_IsOK(res1)) {
46295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
46296 }
46297 arg1 = reinterpret_cast< wxSizer * >(argp1);
46298 arg2 = obj1;
46299 {
46300 PyThreadState* __tstate = wxPyBeginAllowThreads();
46301 result = (bool)wxSizer_Remove(arg1,arg2);
46302 wxPyEndAllowThreads(__tstate);
46303 if (PyErr_Occurred()) SWIG_fail;
46304 }
46305 {
46306 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46307 }
46308 return resultobj;
46309 fail:
46310 return NULL;
46311 }
46312
46313
46314 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46315 PyObject *resultobj = 0;
46316 wxSizer *arg1 = (wxSizer *) 0 ;
46317 PyObject *arg2 = (PyObject *) 0 ;
46318 bool result;
46319 void *argp1 = 0 ;
46320 int res1 = 0 ;
46321 PyObject * obj0 = 0 ;
46322 PyObject * obj1 = 0 ;
46323 char * kwnames[] = {
46324 (char *) "self",(char *) "item", NULL
46325 };
46326
46327 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
46328 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46329 if (!SWIG_IsOK(res1)) {
46330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
46331 }
46332 arg1 = reinterpret_cast< wxSizer * >(argp1);
46333 arg2 = obj1;
46334 {
46335 PyThreadState* __tstate = wxPyBeginAllowThreads();
46336 result = (bool)wxSizer_Detach(arg1,arg2);
46337 wxPyEndAllowThreads(__tstate);
46338 if (PyErr_Occurred()) SWIG_fail;
46339 }
46340 {
46341 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46342 }
46343 return resultobj;
46344 fail:
46345 return NULL;
46346 }
46347
46348
46349 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46350 PyObject *resultobj = 0;
46351 wxSizer *arg1 = (wxSizer *) 0 ;
46352 PyObject *arg2 = (PyObject *) 0 ;
46353 wxSizerItem *result = 0 ;
46354 void *argp1 = 0 ;
46355 int res1 = 0 ;
46356 PyObject * obj0 = 0 ;
46357 PyObject * obj1 = 0 ;
46358 char * kwnames[] = {
46359 (char *) "self",(char *) "item", NULL
46360 };
46361
46362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
46363 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46364 if (!SWIG_IsOK(res1)) {
46365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46366 }
46367 arg1 = reinterpret_cast< wxSizer * >(argp1);
46368 arg2 = obj1;
46369 {
46370 PyThreadState* __tstate = wxPyBeginAllowThreads();
46371 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
46372 wxPyEndAllowThreads(__tstate);
46373 if (PyErr_Occurred()) SWIG_fail;
46374 }
46375 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46376 return resultobj;
46377 fail:
46378 return NULL;
46379 }
46380
46381
46382 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46383 PyObject *resultobj = 0;
46384 wxSizer *arg1 = (wxSizer *) 0 ;
46385 PyObject *arg2 = (PyObject *) 0 ;
46386 wxSize *arg3 = 0 ;
46387 void *argp1 = 0 ;
46388 int res1 = 0 ;
46389 wxSize temp3 ;
46390 PyObject * obj0 = 0 ;
46391 PyObject * obj1 = 0 ;
46392 PyObject * obj2 = 0 ;
46393 char * kwnames[] = {
46394 (char *) "self",(char *) "item",(char *) "size", NULL
46395 };
46396
46397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46398 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46399 if (!SWIG_IsOK(res1)) {
46400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46401 }
46402 arg1 = reinterpret_cast< wxSizer * >(argp1);
46403 arg2 = obj1;
46404 {
46405 arg3 = &temp3;
46406 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
46407 }
46408 {
46409 PyThreadState* __tstate = wxPyBeginAllowThreads();
46410 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
46411 wxPyEndAllowThreads(__tstate);
46412 if (PyErr_Occurred()) SWIG_fail;
46413 }
46414 resultobj = SWIG_Py_Void();
46415 return resultobj;
46416 fail:
46417 return NULL;
46418 }
46419
46420
46421 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46422 PyObject *resultobj = 0;
46423 wxSizer *arg1 = (wxSizer *) 0 ;
46424 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
46425 wxSizerItem *result = 0 ;
46426 void *argp1 = 0 ;
46427 int res1 = 0 ;
46428 int res2 = 0 ;
46429 PyObject * obj0 = 0 ;
46430 PyObject * obj1 = 0 ;
46431 char * kwnames[] = {
46432 (char *) "self",(char *) "item", NULL
46433 };
46434
46435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
46436 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46437 if (!SWIG_IsOK(res1)) {
46438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46439 }
46440 arg1 = reinterpret_cast< wxSizer * >(argp1);
46441 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46442 if (!SWIG_IsOK(res2)) {
46443 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
46444 }
46445 {
46446 PyThreadState* __tstate = wxPyBeginAllowThreads();
46447 result = (wxSizerItem *)(arg1)->Add(arg2);
46448 wxPyEndAllowThreads(__tstate);
46449 if (PyErr_Occurred()) SWIG_fail;
46450 }
46451 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46452 return resultobj;
46453 fail:
46454 return NULL;
46455 }
46456
46457
46458 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46459 PyObject *resultobj = 0;
46460 wxSizer *arg1 = (wxSizer *) 0 ;
46461 size_t arg2 ;
46462 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
46463 wxSizerItem *result = 0 ;
46464 void *argp1 = 0 ;
46465 int res1 = 0 ;
46466 size_t val2 ;
46467 int ecode2 = 0 ;
46468 int res3 = 0 ;
46469 PyObject * obj0 = 0 ;
46470 PyObject * obj1 = 0 ;
46471 PyObject * obj2 = 0 ;
46472 char * kwnames[] = {
46473 (char *) "self",(char *) "index",(char *) "item", NULL
46474 };
46475
46476 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46477 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46478 if (!SWIG_IsOK(res1)) {
46479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46480 }
46481 arg1 = reinterpret_cast< wxSizer * >(argp1);
46482 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
46483 if (!SWIG_IsOK(ecode2)) {
46484 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
46485 }
46486 arg2 = static_cast< size_t >(val2);
46487 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46488 if (!SWIG_IsOK(res3)) {
46489 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
46490 }
46491 {
46492 PyThreadState* __tstate = wxPyBeginAllowThreads();
46493 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
46494 wxPyEndAllowThreads(__tstate);
46495 if (PyErr_Occurred()) SWIG_fail;
46496 }
46497 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46498 return resultobj;
46499 fail:
46500 return NULL;
46501 }
46502
46503
46504 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46505 PyObject *resultobj = 0;
46506 wxSizer *arg1 = (wxSizer *) 0 ;
46507 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
46508 wxSizerItem *result = 0 ;
46509 void *argp1 = 0 ;
46510 int res1 = 0 ;
46511 int res2 = 0 ;
46512 PyObject * obj0 = 0 ;
46513 PyObject * obj1 = 0 ;
46514 char * kwnames[] = {
46515 (char *) "self",(char *) "item", NULL
46516 };
46517
46518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
46519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46520 if (!SWIG_IsOK(res1)) {
46521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46522 }
46523 arg1 = reinterpret_cast< wxSizer * >(argp1);
46524 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46525 if (!SWIG_IsOK(res2)) {
46526 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
46527 }
46528 {
46529 PyThreadState* __tstate = wxPyBeginAllowThreads();
46530 result = (wxSizerItem *)(arg1)->Prepend(arg2);
46531 wxPyEndAllowThreads(__tstate);
46532 if (PyErr_Occurred()) SWIG_fail;
46533 }
46534 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46535 return resultobj;
46536 fail:
46537 return NULL;
46538 }
46539
46540
46541 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46542 PyObject *resultobj = 0;
46543 wxSizer *arg1 = (wxSizer *) 0 ;
46544 int arg2 ;
46545 int arg3 ;
46546 int arg4 ;
46547 int arg5 ;
46548 void *argp1 = 0 ;
46549 int res1 = 0 ;
46550 int val2 ;
46551 int ecode2 = 0 ;
46552 int val3 ;
46553 int ecode3 = 0 ;
46554 int val4 ;
46555 int ecode4 = 0 ;
46556 int val5 ;
46557 int ecode5 = 0 ;
46558 PyObject * obj0 = 0 ;
46559 PyObject * obj1 = 0 ;
46560 PyObject * obj2 = 0 ;
46561 PyObject * obj3 = 0 ;
46562 PyObject * obj4 = 0 ;
46563 char * kwnames[] = {
46564 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
46565 };
46566
46567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
46568 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46569 if (!SWIG_IsOK(res1)) {
46570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
46571 }
46572 arg1 = reinterpret_cast< wxSizer * >(argp1);
46573 ecode2 = SWIG_AsVal_int(obj1, &val2);
46574 if (!SWIG_IsOK(ecode2)) {
46575 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
46576 }
46577 arg2 = static_cast< int >(val2);
46578 ecode3 = SWIG_AsVal_int(obj2, &val3);
46579 if (!SWIG_IsOK(ecode3)) {
46580 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
46581 }
46582 arg3 = static_cast< int >(val3);
46583 ecode4 = SWIG_AsVal_int(obj3, &val4);
46584 if (!SWIG_IsOK(ecode4)) {
46585 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
46586 }
46587 arg4 = static_cast< int >(val4);
46588 ecode5 = SWIG_AsVal_int(obj4, &val5);
46589 if (!SWIG_IsOK(ecode5)) {
46590 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
46591 }
46592 arg5 = static_cast< int >(val5);
46593 {
46594 PyThreadState* __tstate = wxPyBeginAllowThreads();
46595 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
46596 wxPyEndAllowThreads(__tstate);
46597 if (PyErr_Occurred()) SWIG_fail;
46598 }
46599 resultobj = SWIG_Py_Void();
46600 return resultobj;
46601 fail:
46602 return NULL;
46603 }
46604
46605
46606 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46607 PyObject *resultobj = 0;
46608 wxSizer *arg1 = (wxSizer *) 0 ;
46609 wxSize *arg2 = 0 ;
46610 void *argp1 = 0 ;
46611 int res1 = 0 ;
46612 wxSize temp2 ;
46613 PyObject * obj0 = 0 ;
46614 PyObject * obj1 = 0 ;
46615 char * kwnames[] = {
46616 (char *) "self",(char *) "size", NULL
46617 };
46618
46619 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
46620 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46621 if (!SWIG_IsOK(res1)) {
46622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46623 }
46624 arg1 = reinterpret_cast< wxSizer * >(argp1);
46625 {
46626 arg2 = &temp2;
46627 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46628 }
46629 {
46630 PyThreadState* __tstate = wxPyBeginAllowThreads();
46631 (arg1)->SetMinSize((wxSize const &)*arg2);
46632 wxPyEndAllowThreads(__tstate);
46633 if (PyErr_Occurred()) SWIG_fail;
46634 }
46635 resultobj = SWIG_Py_Void();
46636 return resultobj;
46637 fail:
46638 return NULL;
46639 }
46640
46641
46642 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46643 PyObject *resultobj = 0;
46644 wxSizer *arg1 = (wxSizer *) 0 ;
46645 wxSize result;
46646 void *argp1 = 0 ;
46647 int res1 = 0 ;
46648 PyObject *swig_obj[1] ;
46649
46650 if (!args) SWIG_fail;
46651 swig_obj[0] = args;
46652 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46653 if (!SWIG_IsOK(res1)) {
46654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46655 }
46656 arg1 = reinterpret_cast< wxSizer * >(argp1);
46657 {
46658 PyThreadState* __tstate = wxPyBeginAllowThreads();
46659 result = (arg1)->GetSize();
46660 wxPyEndAllowThreads(__tstate);
46661 if (PyErr_Occurred()) SWIG_fail;
46662 }
46663 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46664 return resultobj;
46665 fail:
46666 return NULL;
46667 }
46668
46669
46670 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46671 PyObject *resultobj = 0;
46672 wxSizer *arg1 = (wxSizer *) 0 ;
46673 wxPoint result;
46674 void *argp1 = 0 ;
46675 int res1 = 0 ;
46676 PyObject *swig_obj[1] ;
46677
46678 if (!args) SWIG_fail;
46679 swig_obj[0] = args;
46680 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46681 if (!SWIG_IsOK(res1)) {
46682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
46683 }
46684 arg1 = reinterpret_cast< wxSizer * >(argp1);
46685 {
46686 PyThreadState* __tstate = wxPyBeginAllowThreads();
46687 result = (arg1)->GetPosition();
46688 wxPyEndAllowThreads(__tstate);
46689 if (PyErr_Occurred()) SWIG_fail;
46690 }
46691 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
46692 return resultobj;
46693 fail:
46694 return NULL;
46695 }
46696
46697
46698 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46699 PyObject *resultobj = 0;
46700 wxSizer *arg1 = (wxSizer *) 0 ;
46701 wxSize result;
46702 void *argp1 = 0 ;
46703 int res1 = 0 ;
46704 PyObject *swig_obj[1] ;
46705
46706 if (!args) SWIG_fail;
46707 swig_obj[0] = args;
46708 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46709 if (!SWIG_IsOK(res1)) {
46710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46711 }
46712 arg1 = reinterpret_cast< wxSizer * >(argp1);
46713 {
46714 PyThreadState* __tstate = wxPyBeginAllowThreads();
46715 result = (arg1)->GetMinSize();
46716 wxPyEndAllowThreads(__tstate);
46717 if (PyErr_Occurred()) SWIG_fail;
46718 }
46719 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46720 return resultobj;
46721 fail:
46722 return NULL;
46723 }
46724
46725
46726 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46727 PyObject *resultobj = 0;
46728 wxSizer *arg1 = (wxSizer *) 0 ;
46729 void *argp1 = 0 ;
46730 int res1 = 0 ;
46731 PyObject *swig_obj[1] ;
46732
46733 if (!args) SWIG_fail;
46734 swig_obj[0] = args;
46735 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46736 if (!SWIG_IsOK(res1)) {
46737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
46738 }
46739 arg1 = reinterpret_cast< wxSizer * >(argp1);
46740 {
46741 PyThreadState* __tstate = wxPyBeginAllowThreads();
46742 (arg1)->RecalcSizes();
46743 wxPyEndAllowThreads(__tstate);
46744 if (PyErr_Occurred()) SWIG_fail;
46745 }
46746 resultobj = SWIG_Py_Void();
46747 return resultobj;
46748 fail:
46749 return NULL;
46750 }
46751
46752
46753 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46754 PyObject *resultobj = 0;
46755 wxSizer *arg1 = (wxSizer *) 0 ;
46756 wxSize result;
46757 void *argp1 = 0 ;
46758 int res1 = 0 ;
46759 PyObject *swig_obj[1] ;
46760
46761 if (!args) SWIG_fail;
46762 swig_obj[0] = args;
46763 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46764 if (!SWIG_IsOK(res1)) {
46765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
46766 }
46767 arg1 = reinterpret_cast< wxSizer * >(argp1);
46768 {
46769 PyThreadState* __tstate = wxPyBeginAllowThreads();
46770 result = (arg1)->CalcMin();
46771 wxPyEndAllowThreads(__tstate);
46772 if (PyErr_Occurred()) SWIG_fail;
46773 }
46774 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46775 return resultobj;
46776 fail:
46777 return NULL;
46778 }
46779
46780
46781 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46782 PyObject *resultobj = 0;
46783 wxSizer *arg1 = (wxSizer *) 0 ;
46784 void *argp1 = 0 ;
46785 int res1 = 0 ;
46786 PyObject *swig_obj[1] ;
46787
46788 if (!args) SWIG_fail;
46789 swig_obj[0] = args;
46790 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46791 if (!SWIG_IsOK(res1)) {
46792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
46793 }
46794 arg1 = reinterpret_cast< wxSizer * >(argp1);
46795 {
46796 PyThreadState* __tstate = wxPyBeginAllowThreads();
46797 (arg1)->Layout();
46798 wxPyEndAllowThreads(__tstate);
46799 if (PyErr_Occurred()) SWIG_fail;
46800 }
46801 resultobj = SWIG_Py_Void();
46802 return resultobj;
46803 fail:
46804 return NULL;
46805 }
46806
46807
46808 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46809 PyObject *resultobj = 0;
46810 wxSizer *arg1 = (wxSizer *) 0 ;
46811 wxWindow *arg2 = (wxWindow *) 0 ;
46812 wxSize result;
46813 void *argp1 = 0 ;
46814 int res1 = 0 ;
46815 void *argp2 = 0 ;
46816 int res2 = 0 ;
46817 PyObject * obj0 = 0 ;
46818 PyObject * obj1 = 0 ;
46819 char * kwnames[] = {
46820 (char *) "self",(char *) "window", NULL
46821 };
46822
46823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
46824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46825 if (!SWIG_IsOK(res1)) {
46826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
46827 }
46828 arg1 = reinterpret_cast< wxSizer * >(argp1);
46829 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46830 if (!SWIG_IsOK(res2)) {
46831 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
46832 }
46833 arg2 = reinterpret_cast< wxWindow * >(argp2);
46834 {
46835 PyThreadState* __tstate = wxPyBeginAllowThreads();
46836 result = (arg1)->Fit(arg2);
46837 wxPyEndAllowThreads(__tstate);
46838 if (PyErr_Occurred()) SWIG_fail;
46839 }
46840 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46841 return resultobj;
46842 fail:
46843 return NULL;
46844 }
46845
46846
46847 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46848 PyObject *resultobj = 0;
46849 wxSizer *arg1 = (wxSizer *) 0 ;
46850 wxWindow *arg2 = (wxWindow *) 0 ;
46851 void *argp1 = 0 ;
46852 int res1 = 0 ;
46853 void *argp2 = 0 ;
46854 int res2 = 0 ;
46855 PyObject * obj0 = 0 ;
46856 PyObject * obj1 = 0 ;
46857 char * kwnames[] = {
46858 (char *) "self",(char *) "window", NULL
46859 };
46860
46861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
46862 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46863 if (!SWIG_IsOK(res1)) {
46864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
46865 }
46866 arg1 = reinterpret_cast< wxSizer * >(argp1);
46867 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46868 if (!SWIG_IsOK(res2)) {
46869 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
46870 }
46871 arg2 = reinterpret_cast< wxWindow * >(argp2);
46872 {
46873 PyThreadState* __tstate = wxPyBeginAllowThreads();
46874 (arg1)->FitInside(arg2);
46875 wxPyEndAllowThreads(__tstate);
46876 if (PyErr_Occurred()) SWIG_fail;
46877 }
46878 resultobj = SWIG_Py_Void();
46879 return resultobj;
46880 fail:
46881 return NULL;
46882 }
46883
46884
46885 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46886 PyObject *resultobj = 0;
46887 wxSizer *arg1 = (wxSizer *) 0 ;
46888 wxWindow *arg2 = (wxWindow *) 0 ;
46889 void *argp1 = 0 ;
46890 int res1 = 0 ;
46891 void *argp2 = 0 ;
46892 int res2 = 0 ;
46893 PyObject * obj0 = 0 ;
46894 PyObject * obj1 = 0 ;
46895 char * kwnames[] = {
46896 (char *) "self",(char *) "window", NULL
46897 };
46898
46899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
46900 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46901 if (!SWIG_IsOK(res1)) {
46902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
46903 }
46904 arg1 = reinterpret_cast< wxSizer * >(argp1);
46905 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46906 if (!SWIG_IsOK(res2)) {
46907 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
46908 }
46909 arg2 = reinterpret_cast< wxWindow * >(argp2);
46910 {
46911 PyThreadState* __tstate = wxPyBeginAllowThreads();
46912 (arg1)->SetSizeHints(arg2);
46913 wxPyEndAllowThreads(__tstate);
46914 if (PyErr_Occurred()) SWIG_fail;
46915 }
46916 resultobj = SWIG_Py_Void();
46917 return resultobj;
46918 fail:
46919 return NULL;
46920 }
46921
46922
46923 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46924 PyObject *resultobj = 0;
46925 wxSizer *arg1 = (wxSizer *) 0 ;
46926 wxWindow *arg2 = (wxWindow *) 0 ;
46927 void *argp1 = 0 ;
46928 int res1 = 0 ;
46929 void *argp2 = 0 ;
46930 int res2 = 0 ;
46931 PyObject * obj0 = 0 ;
46932 PyObject * obj1 = 0 ;
46933 char * kwnames[] = {
46934 (char *) "self",(char *) "window", NULL
46935 };
46936
46937 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
46938 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46939 if (!SWIG_IsOK(res1)) {
46940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
46941 }
46942 arg1 = reinterpret_cast< wxSizer * >(argp1);
46943 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46944 if (!SWIG_IsOK(res2)) {
46945 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
46946 }
46947 arg2 = reinterpret_cast< wxWindow * >(argp2);
46948 {
46949 PyThreadState* __tstate = wxPyBeginAllowThreads();
46950 (arg1)->SetVirtualSizeHints(arg2);
46951 wxPyEndAllowThreads(__tstate);
46952 if (PyErr_Occurred()) SWIG_fail;
46953 }
46954 resultobj = SWIG_Py_Void();
46955 return resultobj;
46956 fail:
46957 return NULL;
46958 }
46959
46960
46961 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46962 PyObject *resultobj = 0;
46963 wxSizer *arg1 = (wxSizer *) 0 ;
46964 bool arg2 = (bool) false ;
46965 void *argp1 = 0 ;
46966 int res1 = 0 ;
46967 bool val2 ;
46968 int ecode2 = 0 ;
46969 PyObject * obj0 = 0 ;
46970 PyObject * obj1 = 0 ;
46971 char * kwnames[] = {
46972 (char *) "self",(char *) "deleteWindows", NULL
46973 };
46974
46975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
46976 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46977 if (!SWIG_IsOK(res1)) {
46978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
46979 }
46980 arg1 = reinterpret_cast< wxSizer * >(argp1);
46981 if (obj1) {
46982 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46983 if (!SWIG_IsOK(ecode2)) {
46984 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
46985 }
46986 arg2 = static_cast< bool >(val2);
46987 }
46988 {
46989 PyThreadState* __tstate = wxPyBeginAllowThreads();
46990 (arg1)->Clear(arg2);
46991 wxPyEndAllowThreads(__tstate);
46992 if (PyErr_Occurred()) SWIG_fail;
46993 }
46994 resultobj = SWIG_Py_Void();
46995 return resultobj;
46996 fail:
46997 return NULL;
46998 }
46999
47000
47001 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47002 PyObject *resultobj = 0;
47003 wxSizer *arg1 = (wxSizer *) 0 ;
47004 void *argp1 = 0 ;
47005 int res1 = 0 ;
47006 PyObject *swig_obj[1] ;
47007
47008 if (!args) SWIG_fail;
47009 swig_obj[0] = args;
47010 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47011 if (!SWIG_IsOK(res1)) {
47012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
47013 }
47014 arg1 = reinterpret_cast< wxSizer * >(argp1);
47015 {
47016 PyThreadState* __tstate = wxPyBeginAllowThreads();
47017 (arg1)->DeleteWindows();
47018 wxPyEndAllowThreads(__tstate);
47019 if (PyErr_Occurred()) SWIG_fail;
47020 }
47021 resultobj = SWIG_Py_Void();
47022 return resultobj;
47023 fail:
47024 return NULL;
47025 }
47026
47027
47028 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47029 PyObject *resultobj = 0;
47030 wxSizer *arg1 = (wxSizer *) 0 ;
47031 PyObject *result = 0 ;
47032 void *argp1 = 0 ;
47033 int res1 = 0 ;
47034 PyObject *swig_obj[1] ;
47035
47036 if (!args) SWIG_fail;
47037 swig_obj[0] = args;
47038 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47039 if (!SWIG_IsOK(res1)) {
47040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
47041 }
47042 arg1 = reinterpret_cast< wxSizer * >(argp1);
47043 {
47044 PyThreadState* __tstate = wxPyBeginAllowThreads();
47045 result = (PyObject *)wxSizer_GetChildren(arg1);
47046 wxPyEndAllowThreads(__tstate);
47047 if (PyErr_Occurred()) SWIG_fail;
47048 }
47049 resultobj = result;
47050 return resultobj;
47051 fail:
47052 return NULL;
47053 }
47054
47055
47056 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47057 PyObject *resultobj = 0;
47058 wxSizer *arg1 = (wxSizer *) 0 ;
47059 PyObject *arg2 = (PyObject *) 0 ;
47060 bool arg3 = (bool) true ;
47061 bool arg4 = (bool) false ;
47062 bool result;
47063 void *argp1 = 0 ;
47064 int res1 = 0 ;
47065 bool val3 ;
47066 int ecode3 = 0 ;
47067 bool val4 ;
47068 int ecode4 = 0 ;
47069 PyObject * obj0 = 0 ;
47070 PyObject * obj1 = 0 ;
47071 PyObject * obj2 = 0 ;
47072 PyObject * obj3 = 0 ;
47073 char * kwnames[] = {
47074 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
47075 };
47076
47077 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47078 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47079 if (!SWIG_IsOK(res1)) {
47080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
47081 }
47082 arg1 = reinterpret_cast< wxSizer * >(argp1);
47083 arg2 = obj1;
47084 if (obj2) {
47085 ecode3 = SWIG_AsVal_bool(obj2, &val3);
47086 if (!SWIG_IsOK(ecode3)) {
47087 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
47088 }
47089 arg3 = static_cast< bool >(val3);
47090 }
47091 if (obj3) {
47092 ecode4 = SWIG_AsVal_bool(obj3, &val4);
47093 if (!SWIG_IsOK(ecode4)) {
47094 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
47095 }
47096 arg4 = static_cast< bool >(val4);
47097 }
47098 {
47099 PyThreadState* __tstate = wxPyBeginAllowThreads();
47100 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
47101 wxPyEndAllowThreads(__tstate);
47102 if (PyErr_Occurred()) SWIG_fail;
47103 }
47104 {
47105 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47106 }
47107 return resultobj;
47108 fail:
47109 return NULL;
47110 }
47111
47112
47113 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47114 PyObject *resultobj = 0;
47115 wxSizer *arg1 = (wxSizer *) 0 ;
47116 PyObject *arg2 = (PyObject *) 0 ;
47117 bool result;
47118 void *argp1 = 0 ;
47119 int res1 = 0 ;
47120 PyObject * obj0 = 0 ;
47121 PyObject * obj1 = 0 ;
47122 char * kwnames[] = {
47123 (char *) "self",(char *) "item", NULL
47124 };
47125
47126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
47127 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47128 if (!SWIG_IsOK(res1)) {
47129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
47130 }
47131 arg1 = reinterpret_cast< wxSizer * >(argp1);
47132 arg2 = obj1;
47133 {
47134 PyThreadState* __tstate = wxPyBeginAllowThreads();
47135 result = (bool)wxSizer_IsShown(arg1,arg2);
47136 wxPyEndAllowThreads(__tstate);
47137 if (PyErr_Occurred()) SWIG_fail;
47138 }
47139 {
47140 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47141 }
47142 return resultobj;
47143 fail:
47144 return NULL;
47145 }
47146
47147
47148 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47149 PyObject *resultobj = 0;
47150 wxSizer *arg1 = (wxSizer *) 0 ;
47151 bool arg2 ;
47152 void *argp1 = 0 ;
47153 int res1 = 0 ;
47154 bool val2 ;
47155 int ecode2 = 0 ;
47156 PyObject * obj0 = 0 ;
47157 PyObject * obj1 = 0 ;
47158 char * kwnames[] = {
47159 (char *) "self",(char *) "show", NULL
47160 };
47161
47162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
47163 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47164 if (!SWIG_IsOK(res1)) {
47165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
47166 }
47167 arg1 = reinterpret_cast< wxSizer * >(argp1);
47168 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47169 if (!SWIG_IsOK(ecode2)) {
47170 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
47171 }
47172 arg2 = static_cast< bool >(val2);
47173 {
47174 PyThreadState* __tstate = wxPyBeginAllowThreads();
47175 (arg1)->ShowItems(arg2);
47176 wxPyEndAllowThreads(__tstate);
47177 if (PyErr_Occurred()) SWIG_fail;
47178 }
47179 resultobj = SWIG_Py_Void();
47180 return resultobj;
47181 fail:
47182 return NULL;
47183 }
47184
47185
47186 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47187 PyObject *obj;
47188 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47189 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
47190 return SWIG_Py_Void();
47191 }
47192
47193 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47194 PyObject *resultobj = 0;
47195 wxPySizer *result = 0 ;
47196
47197 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
47198 {
47199 PyThreadState* __tstate = wxPyBeginAllowThreads();
47200 result = (wxPySizer *)new wxPySizer();
47201 wxPyEndAllowThreads(__tstate);
47202 if (PyErr_Occurred()) SWIG_fail;
47203 }
47204 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
47205 return resultobj;
47206 fail:
47207 return NULL;
47208 }
47209
47210
47211 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47212 PyObject *resultobj = 0;
47213 wxPySizer *arg1 = (wxPySizer *) 0 ;
47214 PyObject *arg2 = (PyObject *) 0 ;
47215 PyObject *arg3 = (PyObject *) 0 ;
47216 void *argp1 = 0 ;
47217 int res1 = 0 ;
47218 PyObject * obj0 = 0 ;
47219 PyObject * obj1 = 0 ;
47220 PyObject * obj2 = 0 ;
47221 char * kwnames[] = {
47222 (char *) "self",(char *) "self",(char *) "_class", NULL
47223 };
47224
47225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47226 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
47227 if (!SWIG_IsOK(res1)) {
47228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
47229 }
47230 arg1 = reinterpret_cast< wxPySizer * >(argp1);
47231 arg2 = obj1;
47232 arg3 = obj2;
47233 {
47234 PyThreadState* __tstate = wxPyBeginAllowThreads();
47235 (arg1)->_setCallbackInfo(arg2,arg3);
47236 wxPyEndAllowThreads(__tstate);
47237 if (PyErr_Occurred()) SWIG_fail;
47238 }
47239 resultobj = SWIG_Py_Void();
47240 return resultobj;
47241 fail:
47242 return NULL;
47243 }
47244
47245
47246 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47247 PyObject *obj;
47248 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47249 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
47250 return SWIG_Py_Void();
47251 }
47252
47253 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47254 return SWIG_Python_InitShadowInstance(args);
47255 }
47256
47257 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47258 PyObject *resultobj = 0;
47259 int arg1 = (int) wxHORIZONTAL ;
47260 wxBoxSizer *result = 0 ;
47261 int val1 ;
47262 int ecode1 = 0 ;
47263 PyObject * obj0 = 0 ;
47264 char * kwnames[] = {
47265 (char *) "orient", NULL
47266 };
47267
47268 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
47269 if (obj0) {
47270 ecode1 = SWIG_AsVal_int(obj0, &val1);
47271 if (!SWIG_IsOK(ecode1)) {
47272 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
47273 }
47274 arg1 = static_cast< int >(val1);
47275 }
47276 {
47277 PyThreadState* __tstate = wxPyBeginAllowThreads();
47278 result = (wxBoxSizer *)new wxBoxSizer(arg1);
47279 wxPyEndAllowThreads(__tstate);
47280 if (PyErr_Occurred()) SWIG_fail;
47281 }
47282 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
47283 return resultobj;
47284 fail:
47285 return NULL;
47286 }
47287
47288
47289 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47290 PyObject *resultobj = 0;
47291 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47292 int result;
47293 void *argp1 = 0 ;
47294 int res1 = 0 ;
47295 PyObject *swig_obj[1] ;
47296
47297 if (!args) SWIG_fail;
47298 swig_obj[0] = args;
47299 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47300 if (!SWIG_IsOK(res1)) {
47301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47302 }
47303 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47304 {
47305 PyThreadState* __tstate = wxPyBeginAllowThreads();
47306 result = (int)(arg1)->GetOrientation();
47307 wxPyEndAllowThreads(__tstate);
47308 if (PyErr_Occurred()) SWIG_fail;
47309 }
47310 resultobj = SWIG_From_int(static_cast< int >(result));
47311 return resultobj;
47312 fail:
47313 return NULL;
47314 }
47315
47316
47317 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47318 PyObject *resultobj = 0;
47319 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47320 int arg2 ;
47321 void *argp1 = 0 ;
47322 int res1 = 0 ;
47323 int val2 ;
47324 int ecode2 = 0 ;
47325 PyObject * obj0 = 0 ;
47326 PyObject * obj1 = 0 ;
47327 char * kwnames[] = {
47328 (char *) "self",(char *) "orient", NULL
47329 };
47330
47331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
47332 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47333 if (!SWIG_IsOK(res1)) {
47334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47335 }
47336 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47337 ecode2 = SWIG_AsVal_int(obj1, &val2);
47338 if (!SWIG_IsOK(ecode2)) {
47339 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
47340 }
47341 arg2 = static_cast< int >(val2);
47342 {
47343 PyThreadState* __tstate = wxPyBeginAllowThreads();
47344 (arg1)->SetOrientation(arg2);
47345 wxPyEndAllowThreads(__tstate);
47346 if (PyErr_Occurred()) SWIG_fail;
47347 }
47348 resultobj = SWIG_Py_Void();
47349 return resultobj;
47350 fail:
47351 return NULL;
47352 }
47353
47354
47355 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47356 PyObject *obj;
47357 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47358 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
47359 return SWIG_Py_Void();
47360 }
47361
47362 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47363 return SWIG_Python_InitShadowInstance(args);
47364 }
47365
47366 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47367 PyObject *resultobj = 0;
47368 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
47369 int arg2 = (int) wxHORIZONTAL ;
47370 wxStaticBoxSizer *result = 0 ;
47371 void *argp1 = 0 ;
47372 int res1 = 0 ;
47373 int val2 ;
47374 int ecode2 = 0 ;
47375 PyObject * obj0 = 0 ;
47376 PyObject * obj1 = 0 ;
47377 char * kwnames[] = {
47378 (char *) "box",(char *) "orient", NULL
47379 };
47380
47381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
47382 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
47383 if (!SWIG_IsOK(res1)) {
47384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
47385 }
47386 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
47387 if (obj1) {
47388 ecode2 = SWIG_AsVal_int(obj1, &val2);
47389 if (!SWIG_IsOK(ecode2)) {
47390 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
47391 }
47392 arg2 = static_cast< int >(val2);
47393 }
47394 {
47395 PyThreadState* __tstate = wxPyBeginAllowThreads();
47396 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
47397 wxPyEndAllowThreads(__tstate);
47398 if (PyErr_Occurred()) SWIG_fail;
47399 }
47400 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
47401 return resultobj;
47402 fail:
47403 return NULL;
47404 }
47405
47406
47407 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47408 PyObject *resultobj = 0;
47409 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
47410 wxStaticBox *result = 0 ;
47411 void *argp1 = 0 ;
47412 int res1 = 0 ;
47413 PyObject *swig_obj[1] ;
47414
47415 if (!args) SWIG_fail;
47416 swig_obj[0] = args;
47417 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
47418 if (!SWIG_IsOK(res1)) {
47419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
47420 }
47421 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
47422 {
47423 PyThreadState* __tstate = wxPyBeginAllowThreads();
47424 result = (wxStaticBox *)(arg1)->GetStaticBox();
47425 wxPyEndAllowThreads(__tstate);
47426 if (PyErr_Occurred()) SWIG_fail;
47427 }
47428 {
47429 resultobj = wxPyMake_wxObject(result, (bool)0);
47430 }
47431 return resultobj;
47432 fail:
47433 return NULL;
47434 }
47435
47436
47437 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47438 PyObject *obj;
47439 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47440 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
47441 return SWIG_Py_Void();
47442 }
47443
47444 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47445 return SWIG_Python_InitShadowInstance(args);
47446 }
47447
47448 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47449 PyObject *resultobj = 0;
47450 int arg1 = (int) 1 ;
47451 int arg2 = (int) 0 ;
47452 int arg3 = (int) 0 ;
47453 int arg4 = (int) 0 ;
47454 wxGridSizer *result = 0 ;
47455 int val1 ;
47456 int ecode1 = 0 ;
47457 int val2 ;
47458 int ecode2 = 0 ;
47459 int val3 ;
47460 int ecode3 = 0 ;
47461 int val4 ;
47462 int ecode4 = 0 ;
47463 PyObject * obj0 = 0 ;
47464 PyObject * obj1 = 0 ;
47465 PyObject * obj2 = 0 ;
47466 PyObject * obj3 = 0 ;
47467 char * kwnames[] = {
47468 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
47469 };
47470
47471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47472 if (obj0) {
47473 ecode1 = SWIG_AsVal_int(obj0, &val1);
47474 if (!SWIG_IsOK(ecode1)) {
47475 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
47476 }
47477 arg1 = static_cast< int >(val1);
47478 }
47479 if (obj1) {
47480 ecode2 = SWIG_AsVal_int(obj1, &val2);
47481 if (!SWIG_IsOK(ecode2)) {
47482 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
47483 }
47484 arg2 = static_cast< int >(val2);
47485 }
47486 if (obj2) {
47487 ecode3 = SWIG_AsVal_int(obj2, &val3);
47488 if (!SWIG_IsOK(ecode3)) {
47489 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
47490 }
47491 arg3 = static_cast< int >(val3);
47492 }
47493 if (obj3) {
47494 ecode4 = SWIG_AsVal_int(obj3, &val4);
47495 if (!SWIG_IsOK(ecode4)) {
47496 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
47497 }
47498 arg4 = static_cast< int >(val4);
47499 }
47500 {
47501 PyThreadState* __tstate = wxPyBeginAllowThreads();
47502 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
47503 wxPyEndAllowThreads(__tstate);
47504 if (PyErr_Occurred()) SWIG_fail;
47505 }
47506 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
47507 return resultobj;
47508 fail:
47509 return NULL;
47510 }
47511
47512
47513 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47514 PyObject *resultobj = 0;
47515 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47516 int arg2 ;
47517 void *argp1 = 0 ;
47518 int res1 = 0 ;
47519 int val2 ;
47520 int ecode2 = 0 ;
47521 PyObject * obj0 = 0 ;
47522 PyObject * obj1 = 0 ;
47523 char * kwnames[] = {
47524 (char *) "self",(char *) "cols", NULL
47525 };
47526
47527 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
47528 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47529 if (!SWIG_IsOK(res1)) {
47530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47531 }
47532 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47533 ecode2 = SWIG_AsVal_int(obj1, &val2);
47534 if (!SWIG_IsOK(ecode2)) {
47535 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
47536 }
47537 arg2 = static_cast< int >(val2);
47538 {
47539 PyThreadState* __tstate = wxPyBeginAllowThreads();
47540 (arg1)->SetCols(arg2);
47541 wxPyEndAllowThreads(__tstate);
47542 if (PyErr_Occurred()) SWIG_fail;
47543 }
47544 resultobj = SWIG_Py_Void();
47545 return resultobj;
47546 fail:
47547 return NULL;
47548 }
47549
47550
47551 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47552 PyObject *resultobj = 0;
47553 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47554 int arg2 ;
47555 void *argp1 = 0 ;
47556 int res1 = 0 ;
47557 int val2 ;
47558 int ecode2 = 0 ;
47559 PyObject * obj0 = 0 ;
47560 PyObject * obj1 = 0 ;
47561 char * kwnames[] = {
47562 (char *) "self",(char *) "rows", NULL
47563 };
47564
47565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
47566 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47567 if (!SWIG_IsOK(res1)) {
47568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47569 }
47570 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47571 ecode2 = SWIG_AsVal_int(obj1, &val2);
47572 if (!SWIG_IsOK(ecode2)) {
47573 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
47574 }
47575 arg2 = static_cast< int >(val2);
47576 {
47577 PyThreadState* __tstate = wxPyBeginAllowThreads();
47578 (arg1)->SetRows(arg2);
47579 wxPyEndAllowThreads(__tstate);
47580 if (PyErr_Occurred()) SWIG_fail;
47581 }
47582 resultobj = SWIG_Py_Void();
47583 return resultobj;
47584 fail:
47585 return NULL;
47586 }
47587
47588
47589 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47590 PyObject *resultobj = 0;
47591 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47592 int arg2 ;
47593 void *argp1 = 0 ;
47594 int res1 = 0 ;
47595 int val2 ;
47596 int ecode2 = 0 ;
47597 PyObject * obj0 = 0 ;
47598 PyObject * obj1 = 0 ;
47599 char * kwnames[] = {
47600 (char *) "self",(char *) "gap", NULL
47601 };
47602
47603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
47604 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47605 if (!SWIG_IsOK(res1)) {
47606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47607 }
47608 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47609 ecode2 = SWIG_AsVal_int(obj1, &val2);
47610 if (!SWIG_IsOK(ecode2)) {
47611 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
47612 }
47613 arg2 = static_cast< int >(val2);
47614 {
47615 PyThreadState* __tstate = wxPyBeginAllowThreads();
47616 (arg1)->SetVGap(arg2);
47617 wxPyEndAllowThreads(__tstate);
47618 if (PyErr_Occurred()) SWIG_fail;
47619 }
47620 resultobj = SWIG_Py_Void();
47621 return resultobj;
47622 fail:
47623 return NULL;
47624 }
47625
47626
47627 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47628 PyObject *resultobj = 0;
47629 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47630 int arg2 ;
47631 void *argp1 = 0 ;
47632 int res1 = 0 ;
47633 int val2 ;
47634 int ecode2 = 0 ;
47635 PyObject * obj0 = 0 ;
47636 PyObject * obj1 = 0 ;
47637 char * kwnames[] = {
47638 (char *) "self",(char *) "gap", NULL
47639 };
47640
47641 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
47642 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47643 if (!SWIG_IsOK(res1)) {
47644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47645 }
47646 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47647 ecode2 = SWIG_AsVal_int(obj1, &val2);
47648 if (!SWIG_IsOK(ecode2)) {
47649 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
47650 }
47651 arg2 = static_cast< int >(val2);
47652 {
47653 PyThreadState* __tstate = wxPyBeginAllowThreads();
47654 (arg1)->SetHGap(arg2);
47655 wxPyEndAllowThreads(__tstate);
47656 if (PyErr_Occurred()) SWIG_fail;
47657 }
47658 resultobj = SWIG_Py_Void();
47659 return resultobj;
47660 fail:
47661 return NULL;
47662 }
47663
47664
47665 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47666 PyObject *resultobj = 0;
47667 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47668 int result;
47669 void *argp1 = 0 ;
47670 int res1 = 0 ;
47671 PyObject *swig_obj[1] ;
47672
47673 if (!args) SWIG_fail;
47674 swig_obj[0] = args;
47675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47676 if (!SWIG_IsOK(res1)) {
47677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47678 }
47679 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47680 {
47681 PyThreadState* __tstate = wxPyBeginAllowThreads();
47682 result = (int)(arg1)->GetCols();
47683 wxPyEndAllowThreads(__tstate);
47684 if (PyErr_Occurred()) SWIG_fail;
47685 }
47686 resultobj = SWIG_From_int(static_cast< int >(result));
47687 return resultobj;
47688 fail:
47689 return NULL;
47690 }
47691
47692
47693 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47694 PyObject *resultobj = 0;
47695 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47696 int result;
47697 void *argp1 = 0 ;
47698 int res1 = 0 ;
47699 PyObject *swig_obj[1] ;
47700
47701 if (!args) SWIG_fail;
47702 swig_obj[0] = args;
47703 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47704 if (!SWIG_IsOK(res1)) {
47705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47706 }
47707 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47708 {
47709 PyThreadState* __tstate = wxPyBeginAllowThreads();
47710 result = (int)(arg1)->GetRows();
47711 wxPyEndAllowThreads(__tstate);
47712 if (PyErr_Occurred()) SWIG_fail;
47713 }
47714 resultobj = SWIG_From_int(static_cast< int >(result));
47715 return resultobj;
47716 fail:
47717 return NULL;
47718 }
47719
47720
47721 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47722 PyObject *resultobj = 0;
47723 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47724 int result;
47725 void *argp1 = 0 ;
47726 int res1 = 0 ;
47727 PyObject *swig_obj[1] ;
47728
47729 if (!args) SWIG_fail;
47730 swig_obj[0] = args;
47731 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47732 if (!SWIG_IsOK(res1)) {
47733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47734 }
47735 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47736 {
47737 PyThreadState* __tstate = wxPyBeginAllowThreads();
47738 result = (int)(arg1)->GetVGap();
47739 wxPyEndAllowThreads(__tstate);
47740 if (PyErr_Occurred()) SWIG_fail;
47741 }
47742 resultobj = SWIG_From_int(static_cast< int >(result));
47743 return resultobj;
47744 fail:
47745 return NULL;
47746 }
47747
47748
47749 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47750 PyObject *resultobj = 0;
47751 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47752 int result;
47753 void *argp1 = 0 ;
47754 int res1 = 0 ;
47755 PyObject *swig_obj[1] ;
47756
47757 if (!args) SWIG_fail;
47758 swig_obj[0] = args;
47759 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47760 if (!SWIG_IsOK(res1)) {
47761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47762 }
47763 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47764 {
47765 PyThreadState* __tstate = wxPyBeginAllowThreads();
47766 result = (int)(arg1)->GetHGap();
47767 wxPyEndAllowThreads(__tstate);
47768 if (PyErr_Occurred()) SWIG_fail;
47769 }
47770 resultobj = SWIG_From_int(static_cast< int >(result));
47771 return resultobj;
47772 fail:
47773 return NULL;
47774 }
47775
47776
47777 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47778 PyObject *obj;
47779 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47780 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
47781 return SWIG_Py_Void();
47782 }
47783
47784 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47785 return SWIG_Python_InitShadowInstance(args);
47786 }
47787
47788 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47789 PyObject *resultobj = 0;
47790 int arg1 = (int) 1 ;
47791 int arg2 = (int) 0 ;
47792 int arg3 = (int) 0 ;
47793 int arg4 = (int) 0 ;
47794 wxFlexGridSizer *result = 0 ;
47795 int val1 ;
47796 int ecode1 = 0 ;
47797 int val2 ;
47798 int ecode2 = 0 ;
47799 int val3 ;
47800 int ecode3 = 0 ;
47801 int val4 ;
47802 int ecode4 = 0 ;
47803 PyObject * obj0 = 0 ;
47804 PyObject * obj1 = 0 ;
47805 PyObject * obj2 = 0 ;
47806 PyObject * obj3 = 0 ;
47807 char * kwnames[] = {
47808 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
47809 };
47810
47811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47812 if (obj0) {
47813 ecode1 = SWIG_AsVal_int(obj0, &val1);
47814 if (!SWIG_IsOK(ecode1)) {
47815 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
47816 }
47817 arg1 = static_cast< int >(val1);
47818 }
47819 if (obj1) {
47820 ecode2 = SWIG_AsVal_int(obj1, &val2);
47821 if (!SWIG_IsOK(ecode2)) {
47822 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
47823 }
47824 arg2 = static_cast< int >(val2);
47825 }
47826 if (obj2) {
47827 ecode3 = SWIG_AsVal_int(obj2, &val3);
47828 if (!SWIG_IsOK(ecode3)) {
47829 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
47830 }
47831 arg3 = static_cast< int >(val3);
47832 }
47833 if (obj3) {
47834 ecode4 = SWIG_AsVal_int(obj3, &val4);
47835 if (!SWIG_IsOK(ecode4)) {
47836 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
47837 }
47838 arg4 = static_cast< int >(val4);
47839 }
47840 {
47841 PyThreadState* __tstate = wxPyBeginAllowThreads();
47842 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
47843 wxPyEndAllowThreads(__tstate);
47844 if (PyErr_Occurred()) SWIG_fail;
47845 }
47846 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
47847 return resultobj;
47848 fail:
47849 return NULL;
47850 }
47851
47852
47853 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47854 PyObject *resultobj = 0;
47855 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47856 size_t arg2 ;
47857 int arg3 = (int) 0 ;
47858 void *argp1 = 0 ;
47859 int res1 = 0 ;
47860 size_t val2 ;
47861 int ecode2 = 0 ;
47862 int val3 ;
47863 int ecode3 = 0 ;
47864 PyObject * obj0 = 0 ;
47865 PyObject * obj1 = 0 ;
47866 PyObject * obj2 = 0 ;
47867 char * kwnames[] = {
47868 (char *) "self",(char *) "idx",(char *) "proportion", NULL
47869 };
47870
47871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47872 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47873 if (!SWIG_IsOK(res1)) {
47874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47875 }
47876 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47877 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47878 if (!SWIG_IsOK(ecode2)) {
47879 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
47880 }
47881 arg2 = static_cast< size_t >(val2);
47882 if (obj2) {
47883 ecode3 = SWIG_AsVal_int(obj2, &val3);
47884 if (!SWIG_IsOK(ecode3)) {
47885 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
47886 }
47887 arg3 = static_cast< int >(val3);
47888 }
47889 {
47890 PyThreadState* __tstate = wxPyBeginAllowThreads();
47891 (arg1)->AddGrowableRow(arg2,arg3);
47892 wxPyEndAllowThreads(__tstate);
47893 if (PyErr_Occurred()) SWIG_fail;
47894 }
47895 resultobj = SWIG_Py_Void();
47896 return resultobj;
47897 fail:
47898 return NULL;
47899 }
47900
47901
47902 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47903 PyObject *resultobj = 0;
47904 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47905 size_t arg2 ;
47906 void *argp1 = 0 ;
47907 int res1 = 0 ;
47908 size_t val2 ;
47909 int ecode2 = 0 ;
47910 PyObject * obj0 = 0 ;
47911 PyObject * obj1 = 0 ;
47912 char * kwnames[] = {
47913 (char *) "self",(char *) "idx", NULL
47914 };
47915
47916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
47917 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47918 if (!SWIG_IsOK(res1)) {
47919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47920 }
47921 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47922 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47923 if (!SWIG_IsOK(ecode2)) {
47924 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
47925 }
47926 arg2 = static_cast< size_t >(val2);
47927 {
47928 PyThreadState* __tstate = wxPyBeginAllowThreads();
47929 (arg1)->RemoveGrowableRow(arg2);
47930 wxPyEndAllowThreads(__tstate);
47931 if (PyErr_Occurred()) SWIG_fail;
47932 }
47933 resultobj = SWIG_Py_Void();
47934 return resultobj;
47935 fail:
47936 return NULL;
47937 }
47938
47939
47940 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47941 PyObject *resultobj = 0;
47942 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47943 size_t arg2 ;
47944 int arg3 = (int) 0 ;
47945 void *argp1 = 0 ;
47946 int res1 = 0 ;
47947 size_t val2 ;
47948 int ecode2 = 0 ;
47949 int val3 ;
47950 int ecode3 = 0 ;
47951 PyObject * obj0 = 0 ;
47952 PyObject * obj1 = 0 ;
47953 PyObject * obj2 = 0 ;
47954 char * kwnames[] = {
47955 (char *) "self",(char *) "idx",(char *) "proportion", NULL
47956 };
47957
47958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47959 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47960 if (!SWIG_IsOK(res1)) {
47961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47962 }
47963 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47964 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47965 if (!SWIG_IsOK(ecode2)) {
47966 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
47967 }
47968 arg2 = static_cast< size_t >(val2);
47969 if (obj2) {
47970 ecode3 = SWIG_AsVal_int(obj2, &val3);
47971 if (!SWIG_IsOK(ecode3)) {
47972 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
47973 }
47974 arg3 = static_cast< int >(val3);
47975 }
47976 {
47977 PyThreadState* __tstate = wxPyBeginAllowThreads();
47978 (arg1)->AddGrowableCol(arg2,arg3);
47979 wxPyEndAllowThreads(__tstate);
47980 if (PyErr_Occurred()) SWIG_fail;
47981 }
47982 resultobj = SWIG_Py_Void();
47983 return resultobj;
47984 fail:
47985 return NULL;
47986 }
47987
47988
47989 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47990 PyObject *resultobj = 0;
47991 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47992 size_t arg2 ;
47993 void *argp1 = 0 ;
47994 int res1 = 0 ;
47995 size_t val2 ;
47996 int ecode2 = 0 ;
47997 PyObject * obj0 = 0 ;
47998 PyObject * obj1 = 0 ;
47999 char * kwnames[] = {
48000 (char *) "self",(char *) "idx", NULL
48001 };
48002
48003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
48004 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48005 if (!SWIG_IsOK(res1)) {
48006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48007 }
48008 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48009 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48010 if (!SWIG_IsOK(ecode2)) {
48011 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
48012 }
48013 arg2 = static_cast< size_t >(val2);
48014 {
48015 PyThreadState* __tstate = wxPyBeginAllowThreads();
48016 (arg1)->RemoveGrowableCol(arg2);
48017 wxPyEndAllowThreads(__tstate);
48018 if (PyErr_Occurred()) SWIG_fail;
48019 }
48020 resultobj = SWIG_Py_Void();
48021 return resultobj;
48022 fail:
48023 return NULL;
48024 }
48025
48026
48027 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48028 PyObject *resultobj = 0;
48029 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48030 int arg2 ;
48031 void *argp1 = 0 ;
48032 int res1 = 0 ;
48033 int val2 ;
48034 int ecode2 = 0 ;
48035 PyObject * obj0 = 0 ;
48036 PyObject * obj1 = 0 ;
48037 char * kwnames[] = {
48038 (char *) "self",(char *) "direction", NULL
48039 };
48040
48041 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
48042 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48043 if (!SWIG_IsOK(res1)) {
48044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48045 }
48046 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48047 ecode2 = SWIG_AsVal_int(obj1, &val2);
48048 if (!SWIG_IsOK(ecode2)) {
48049 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
48050 }
48051 arg2 = static_cast< int >(val2);
48052 {
48053 PyThreadState* __tstate = wxPyBeginAllowThreads();
48054 (arg1)->SetFlexibleDirection(arg2);
48055 wxPyEndAllowThreads(__tstate);
48056 if (PyErr_Occurred()) SWIG_fail;
48057 }
48058 resultobj = SWIG_Py_Void();
48059 return resultobj;
48060 fail:
48061 return NULL;
48062 }
48063
48064
48065 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48066 PyObject *resultobj = 0;
48067 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48068 int result;
48069 void *argp1 = 0 ;
48070 int res1 = 0 ;
48071 PyObject *swig_obj[1] ;
48072
48073 if (!args) SWIG_fail;
48074 swig_obj[0] = args;
48075 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48076 if (!SWIG_IsOK(res1)) {
48077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48078 }
48079 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48080 {
48081 PyThreadState* __tstate = wxPyBeginAllowThreads();
48082 result = (int)(arg1)->GetFlexibleDirection();
48083 wxPyEndAllowThreads(__tstate);
48084 if (PyErr_Occurred()) SWIG_fail;
48085 }
48086 resultobj = SWIG_From_int(static_cast< int >(result));
48087 return resultobj;
48088 fail:
48089 return NULL;
48090 }
48091
48092
48093 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48094 PyObject *resultobj = 0;
48095 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48096 wxFlexSizerGrowMode arg2 ;
48097 void *argp1 = 0 ;
48098 int res1 = 0 ;
48099 int val2 ;
48100 int ecode2 = 0 ;
48101 PyObject * obj0 = 0 ;
48102 PyObject * obj1 = 0 ;
48103 char * kwnames[] = {
48104 (char *) "self",(char *) "mode", NULL
48105 };
48106
48107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
48108 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48109 if (!SWIG_IsOK(res1)) {
48110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48111 }
48112 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48113 ecode2 = SWIG_AsVal_int(obj1, &val2);
48114 if (!SWIG_IsOK(ecode2)) {
48115 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
48116 }
48117 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
48118 {
48119 PyThreadState* __tstate = wxPyBeginAllowThreads();
48120 (arg1)->SetNonFlexibleGrowMode(arg2);
48121 wxPyEndAllowThreads(__tstate);
48122 if (PyErr_Occurred()) SWIG_fail;
48123 }
48124 resultobj = SWIG_Py_Void();
48125 return resultobj;
48126 fail:
48127 return NULL;
48128 }
48129
48130
48131 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48132 PyObject *resultobj = 0;
48133 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48134 wxFlexSizerGrowMode result;
48135 void *argp1 = 0 ;
48136 int res1 = 0 ;
48137 PyObject *swig_obj[1] ;
48138
48139 if (!args) SWIG_fail;
48140 swig_obj[0] = args;
48141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48142 if (!SWIG_IsOK(res1)) {
48143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48144 }
48145 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48146 {
48147 PyThreadState* __tstate = wxPyBeginAllowThreads();
48148 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
48149 wxPyEndAllowThreads(__tstate);
48150 if (PyErr_Occurred()) SWIG_fail;
48151 }
48152 resultobj = SWIG_From_int(static_cast< int >(result));
48153 return resultobj;
48154 fail:
48155 return NULL;
48156 }
48157
48158
48159 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48160 PyObject *resultobj = 0;
48161 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48162 wxArrayInt *result = 0 ;
48163 void *argp1 = 0 ;
48164 int res1 = 0 ;
48165 PyObject *swig_obj[1] ;
48166
48167 if (!args) SWIG_fail;
48168 swig_obj[0] = args;
48169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48170 if (!SWIG_IsOK(res1)) {
48171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48172 }
48173 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48174 {
48175 PyThreadState* __tstate = wxPyBeginAllowThreads();
48176 {
48177 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
48178 result = (wxArrayInt *) &_result_ref;
48179 }
48180 wxPyEndAllowThreads(__tstate);
48181 if (PyErr_Occurred()) SWIG_fail;
48182 }
48183 {
48184 resultobj = PyList_New(0);
48185 size_t idx;
48186 for (idx = 0; idx < result->GetCount(); idx += 1) {
48187 PyObject* val = PyInt_FromLong( result->Item(idx) );
48188 PyList_Append(resultobj, val);
48189 Py_DECREF(val);
48190 }
48191 }
48192 return resultobj;
48193 fail:
48194 return NULL;
48195 }
48196
48197
48198 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48199 PyObject *resultobj = 0;
48200 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48201 wxArrayInt *result = 0 ;
48202 void *argp1 = 0 ;
48203 int res1 = 0 ;
48204 PyObject *swig_obj[1] ;
48205
48206 if (!args) SWIG_fail;
48207 swig_obj[0] = args;
48208 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48209 if (!SWIG_IsOK(res1)) {
48210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48211 }
48212 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48213 {
48214 PyThreadState* __tstate = wxPyBeginAllowThreads();
48215 {
48216 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
48217 result = (wxArrayInt *) &_result_ref;
48218 }
48219 wxPyEndAllowThreads(__tstate);
48220 if (PyErr_Occurred()) SWIG_fail;
48221 }
48222 {
48223 resultobj = PyList_New(0);
48224 size_t idx;
48225 for (idx = 0; idx < result->GetCount(); idx += 1) {
48226 PyObject* val = PyInt_FromLong( result->Item(idx) );
48227 PyList_Append(resultobj, val);
48228 Py_DECREF(val);
48229 }
48230 }
48231 return resultobj;
48232 fail:
48233 return NULL;
48234 }
48235
48236
48237 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48238 PyObject *obj;
48239 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48240 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
48241 return SWIG_Py_Void();
48242 }
48243
48244 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48245 return SWIG_Python_InitShadowInstance(args);
48246 }
48247
48248 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48249 PyObject *resultobj = 0;
48250 wxStdDialogButtonSizer *result = 0 ;
48251
48252 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
48253 {
48254 PyThreadState* __tstate = wxPyBeginAllowThreads();
48255 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
48256 wxPyEndAllowThreads(__tstate);
48257 if (PyErr_Occurred()) SWIG_fail;
48258 }
48259 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
48260 return resultobj;
48261 fail:
48262 return NULL;
48263 }
48264
48265
48266 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48267 PyObject *resultobj = 0;
48268 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48269 wxButton *arg2 = (wxButton *) 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 *) "button", NULL
48278 };
48279
48280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
48281 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48282 if (!SWIG_IsOK(res1)) {
48283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48284 }
48285 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48286 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48287 if (!SWIG_IsOK(res2)) {
48288 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
48289 }
48290 arg2 = reinterpret_cast< wxButton * >(argp2);
48291 {
48292 PyThreadState* __tstate = wxPyBeginAllowThreads();
48293 (arg1)->AddButton(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_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48305 PyObject *resultobj = 0;
48306 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48307 void *argp1 = 0 ;
48308 int res1 = 0 ;
48309 PyObject *swig_obj[1] ;
48310
48311 if (!args) SWIG_fail;
48312 swig_obj[0] = args;
48313 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48314 if (!SWIG_IsOK(res1)) {
48315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48316 }
48317 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48318 {
48319 PyThreadState* __tstate = wxPyBeginAllowThreads();
48320 (arg1)->Realize();
48321 wxPyEndAllowThreads(__tstate);
48322 if (PyErr_Occurred()) SWIG_fail;
48323 }
48324 resultobj = SWIG_Py_Void();
48325 return resultobj;
48326 fail:
48327 return NULL;
48328 }
48329
48330
48331 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48332 PyObject *resultobj = 0;
48333 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48334 wxButton *arg2 = (wxButton *) 0 ;
48335 void *argp1 = 0 ;
48336 int res1 = 0 ;
48337 void *argp2 = 0 ;
48338 int res2 = 0 ;
48339 PyObject * obj0 = 0 ;
48340 PyObject * obj1 = 0 ;
48341 char * kwnames[] = {
48342 (char *) "self",(char *) "button", NULL
48343 };
48344
48345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48346 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48347 if (!SWIG_IsOK(res1)) {
48348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48349 }
48350 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48351 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48352 if (!SWIG_IsOK(res2)) {
48353 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48354 }
48355 arg2 = reinterpret_cast< wxButton * >(argp2);
48356 {
48357 PyThreadState* __tstate = wxPyBeginAllowThreads();
48358 (arg1)->SetAffirmativeButton(arg2);
48359 wxPyEndAllowThreads(__tstate);
48360 if (PyErr_Occurred()) SWIG_fail;
48361 }
48362 resultobj = SWIG_Py_Void();
48363 return resultobj;
48364 fail:
48365 return NULL;
48366 }
48367
48368
48369 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48370 PyObject *resultobj = 0;
48371 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48372 wxButton *arg2 = (wxButton *) 0 ;
48373 void *argp1 = 0 ;
48374 int res1 = 0 ;
48375 void *argp2 = 0 ;
48376 int res2 = 0 ;
48377 PyObject * obj0 = 0 ;
48378 PyObject * obj1 = 0 ;
48379 char * kwnames[] = {
48380 (char *) "self",(char *) "button", NULL
48381 };
48382
48383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48384 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48385 if (!SWIG_IsOK(res1)) {
48386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48387 }
48388 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48389 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48390 if (!SWIG_IsOK(res2)) {
48391 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48392 }
48393 arg2 = reinterpret_cast< wxButton * >(argp2);
48394 {
48395 PyThreadState* __tstate = wxPyBeginAllowThreads();
48396 (arg1)->SetNegativeButton(arg2);
48397 wxPyEndAllowThreads(__tstate);
48398 if (PyErr_Occurred()) SWIG_fail;
48399 }
48400 resultobj = SWIG_Py_Void();
48401 return resultobj;
48402 fail:
48403 return NULL;
48404 }
48405
48406
48407 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48408 PyObject *resultobj = 0;
48409 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48410 wxButton *arg2 = (wxButton *) 0 ;
48411 void *argp1 = 0 ;
48412 int res1 = 0 ;
48413 void *argp2 = 0 ;
48414 int res2 = 0 ;
48415 PyObject * obj0 = 0 ;
48416 PyObject * obj1 = 0 ;
48417 char * kwnames[] = {
48418 (char *) "self",(char *) "button", NULL
48419 };
48420
48421 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
48422 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48423 if (!SWIG_IsOK(res1)) {
48424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48425 }
48426 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48427 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48428 if (!SWIG_IsOK(res2)) {
48429 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
48430 }
48431 arg2 = reinterpret_cast< wxButton * >(argp2);
48432 {
48433 PyThreadState* __tstate = wxPyBeginAllowThreads();
48434 (arg1)->SetCancelButton(arg2);
48435 wxPyEndAllowThreads(__tstate);
48436 if (PyErr_Occurred()) SWIG_fail;
48437 }
48438 resultobj = SWIG_Py_Void();
48439 return resultobj;
48440 fail:
48441 return NULL;
48442 }
48443
48444
48445 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48446 PyObject *resultobj = 0;
48447 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48448 wxButton *result = 0 ;
48449 void *argp1 = 0 ;
48450 int res1 = 0 ;
48451 PyObject *swig_obj[1] ;
48452
48453 if (!args) SWIG_fail;
48454 swig_obj[0] = args;
48455 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48456 if (!SWIG_IsOK(res1)) {
48457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48458 }
48459 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48460 {
48461 PyThreadState* __tstate = wxPyBeginAllowThreads();
48462 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
48463 wxPyEndAllowThreads(__tstate);
48464 if (PyErr_Occurred()) SWIG_fail;
48465 }
48466 {
48467 resultobj = wxPyMake_wxObject(result, (bool)0);
48468 }
48469 return resultobj;
48470 fail:
48471 return NULL;
48472 }
48473
48474
48475 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48476 PyObject *resultobj = 0;
48477 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48478 wxButton *result = 0 ;
48479 void *argp1 = 0 ;
48480 int res1 = 0 ;
48481 PyObject *swig_obj[1] ;
48482
48483 if (!args) SWIG_fail;
48484 swig_obj[0] = args;
48485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48486 if (!SWIG_IsOK(res1)) {
48487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48488 }
48489 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48490 {
48491 PyThreadState* __tstate = wxPyBeginAllowThreads();
48492 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
48493 wxPyEndAllowThreads(__tstate);
48494 if (PyErr_Occurred()) SWIG_fail;
48495 }
48496 {
48497 resultobj = wxPyMake_wxObject(result, (bool)0);
48498 }
48499 return resultobj;
48500 fail:
48501 return NULL;
48502 }
48503
48504
48505 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48506 PyObject *resultobj = 0;
48507 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48508 wxButton *result = 0 ;
48509 void *argp1 = 0 ;
48510 int res1 = 0 ;
48511 PyObject *swig_obj[1] ;
48512
48513 if (!args) SWIG_fail;
48514 swig_obj[0] = args;
48515 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48516 if (!SWIG_IsOK(res1)) {
48517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48518 }
48519 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48520 {
48521 PyThreadState* __tstate = wxPyBeginAllowThreads();
48522 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
48523 wxPyEndAllowThreads(__tstate);
48524 if (PyErr_Occurred()) SWIG_fail;
48525 }
48526 {
48527 resultobj = wxPyMake_wxObject(result, (bool)0);
48528 }
48529 return resultobj;
48530 fail:
48531 return NULL;
48532 }
48533
48534
48535 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48536 PyObject *resultobj = 0;
48537 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48538 wxButton *result = 0 ;
48539 void *argp1 = 0 ;
48540 int res1 = 0 ;
48541 PyObject *swig_obj[1] ;
48542
48543 if (!args) SWIG_fail;
48544 swig_obj[0] = args;
48545 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48546 if (!SWIG_IsOK(res1)) {
48547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48548 }
48549 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48550 {
48551 PyThreadState* __tstate = wxPyBeginAllowThreads();
48552 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
48553 wxPyEndAllowThreads(__tstate);
48554 if (PyErr_Occurred()) SWIG_fail;
48555 }
48556 {
48557 resultobj = wxPyMake_wxObject(result, (bool)0);
48558 }
48559 return resultobj;
48560 fail:
48561 return NULL;
48562 }
48563
48564
48565 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48566 PyObject *resultobj = 0;
48567 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48568 wxButton *result = 0 ;
48569 void *argp1 = 0 ;
48570 int res1 = 0 ;
48571 PyObject *swig_obj[1] ;
48572
48573 if (!args) SWIG_fail;
48574 swig_obj[0] = args;
48575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48576 if (!SWIG_IsOK(res1)) {
48577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48578 }
48579 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48580 {
48581 PyThreadState* __tstate = wxPyBeginAllowThreads();
48582 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
48583 wxPyEndAllowThreads(__tstate);
48584 if (PyErr_Occurred()) SWIG_fail;
48585 }
48586 {
48587 resultobj = wxPyMake_wxObject(result, (bool)0);
48588 }
48589 return resultobj;
48590 fail:
48591 return NULL;
48592 }
48593
48594
48595 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48596 PyObject *obj;
48597 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48598 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
48599 return SWIG_Py_Void();
48600 }
48601
48602 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48603 return SWIG_Python_InitShadowInstance(args);
48604 }
48605
48606 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48607 PyObject *resultobj = 0;
48608 int arg1 = (int) 0 ;
48609 int arg2 = (int) 0 ;
48610 wxGBPosition *result = 0 ;
48611 int val1 ;
48612 int ecode1 = 0 ;
48613 int val2 ;
48614 int ecode2 = 0 ;
48615 PyObject * obj0 = 0 ;
48616 PyObject * obj1 = 0 ;
48617 char * kwnames[] = {
48618 (char *) "row",(char *) "col", NULL
48619 };
48620
48621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
48622 if (obj0) {
48623 ecode1 = SWIG_AsVal_int(obj0, &val1);
48624 if (!SWIG_IsOK(ecode1)) {
48625 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
48626 }
48627 arg1 = static_cast< int >(val1);
48628 }
48629 if (obj1) {
48630 ecode2 = SWIG_AsVal_int(obj1, &val2);
48631 if (!SWIG_IsOK(ecode2)) {
48632 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
48633 }
48634 arg2 = static_cast< int >(val2);
48635 }
48636 {
48637 PyThreadState* __tstate = wxPyBeginAllowThreads();
48638 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
48639 wxPyEndAllowThreads(__tstate);
48640 if (PyErr_Occurred()) SWIG_fail;
48641 }
48642 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
48643 return resultobj;
48644 fail:
48645 return NULL;
48646 }
48647
48648
48649 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48650 PyObject *resultobj = 0;
48651 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48652 void *argp1 = 0 ;
48653 int res1 = 0 ;
48654 PyObject *swig_obj[1] ;
48655
48656 if (!args) SWIG_fail;
48657 swig_obj[0] = args;
48658 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
48659 if (!SWIG_IsOK(res1)) {
48660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48661 }
48662 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48663 {
48664 PyThreadState* __tstate = wxPyBeginAllowThreads();
48665 delete arg1;
48666
48667 wxPyEndAllowThreads(__tstate);
48668 if (PyErr_Occurred()) SWIG_fail;
48669 }
48670 resultobj = SWIG_Py_Void();
48671 return resultobj;
48672 fail:
48673 return NULL;
48674 }
48675
48676
48677 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48678 PyObject *resultobj = 0;
48679 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48680 int result;
48681 void *argp1 = 0 ;
48682 int res1 = 0 ;
48683 PyObject *swig_obj[1] ;
48684
48685 if (!args) SWIG_fail;
48686 swig_obj[0] = args;
48687 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48688 if (!SWIG_IsOK(res1)) {
48689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
48690 }
48691 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48692 {
48693 PyThreadState* __tstate = wxPyBeginAllowThreads();
48694 result = (int)((wxGBPosition const *)arg1)->GetRow();
48695 wxPyEndAllowThreads(__tstate);
48696 if (PyErr_Occurred()) SWIG_fail;
48697 }
48698 resultobj = SWIG_From_int(static_cast< int >(result));
48699 return resultobj;
48700 fail:
48701 return NULL;
48702 }
48703
48704
48705 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48706 PyObject *resultobj = 0;
48707 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48708 int result;
48709 void *argp1 = 0 ;
48710 int res1 = 0 ;
48711 PyObject *swig_obj[1] ;
48712
48713 if (!args) SWIG_fail;
48714 swig_obj[0] = args;
48715 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48716 if (!SWIG_IsOK(res1)) {
48717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
48718 }
48719 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48720 {
48721 PyThreadState* __tstate = wxPyBeginAllowThreads();
48722 result = (int)((wxGBPosition const *)arg1)->GetCol();
48723 wxPyEndAllowThreads(__tstate);
48724 if (PyErr_Occurred()) SWIG_fail;
48725 }
48726 resultobj = SWIG_From_int(static_cast< int >(result));
48727 return resultobj;
48728 fail:
48729 return NULL;
48730 }
48731
48732
48733 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48734 PyObject *resultobj = 0;
48735 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48736 int arg2 ;
48737 void *argp1 = 0 ;
48738 int res1 = 0 ;
48739 int val2 ;
48740 int ecode2 = 0 ;
48741 PyObject * obj0 = 0 ;
48742 PyObject * obj1 = 0 ;
48743 char * kwnames[] = {
48744 (char *) "self",(char *) "row", NULL
48745 };
48746
48747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
48748 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48749 if (!SWIG_IsOK(res1)) {
48750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48751 }
48752 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48753 ecode2 = SWIG_AsVal_int(obj1, &val2);
48754 if (!SWIG_IsOK(ecode2)) {
48755 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
48756 }
48757 arg2 = static_cast< int >(val2);
48758 {
48759 PyThreadState* __tstate = wxPyBeginAllowThreads();
48760 (arg1)->SetRow(arg2);
48761 wxPyEndAllowThreads(__tstate);
48762 if (PyErr_Occurred()) SWIG_fail;
48763 }
48764 resultobj = SWIG_Py_Void();
48765 return resultobj;
48766 fail:
48767 return NULL;
48768 }
48769
48770
48771 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48772 PyObject *resultobj = 0;
48773 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48774 int arg2 ;
48775 void *argp1 = 0 ;
48776 int res1 = 0 ;
48777 int val2 ;
48778 int ecode2 = 0 ;
48779 PyObject * obj0 = 0 ;
48780 PyObject * obj1 = 0 ;
48781 char * kwnames[] = {
48782 (char *) "self",(char *) "col", NULL
48783 };
48784
48785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
48786 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48787 if (!SWIG_IsOK(res1)) {
48788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48789 }
48790 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48791 ecode2 = SWIG_AsVal_int(obj1, &val2);
48792 if (!SWIG_IsOK(ecode2)) {
48793 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
48794 }
48795 arg2 = static_cast< int >(val2);
48796 {
48797 PyThreadState* __tstate = wxPyBeginAllowThreads();
48798 (arg1)->SetCol(arg2);
48799 wxPyEndAllowThreads(__tstate);
48800 if (PyErr_Occurred()) SWIG_fail;
48801 }
48802 resultobj = SWIG_Py_Void();
48803 return resultobj;
48804 fail:
48805 return NULL;
48806 }
48807
48808
48809 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48810 PyObject *resultobj = 0;
48811 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48812 PyObject *arg2 = (PyObject *) 0 ;
48813 bool result;
48814 void *argp1 = 0 ;
48815 int res1 = 0 ;
48816 PyObject * obj0 = 0 ;
48817 PyObject * obj1 = 0 ;
48818 char * kwnames[] = {
48819 (char *) "self",(char *) "other", NULL
48820 };
48821
48822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
48823 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48824 if (!SWIG_IsOK(res1)) {
48825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48826 }
48827 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48828 arg2 = obj1;
48829 {
48830 result = (bool)wxGBPosition___eq__(arg1,arg2);
48831 if (PyErr_Occurred()) SWIG_fail;
48832 }
48833 {
48834 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48835 }
48836 return resultobj;
48837 fail:
48838 return NULL;
48839 }
48840
48841
48842 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48843 PyObject *resultobj = 0;
48844 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48845 PyObject *arg2 = (PyObject *) 0 ;
48846 bool result;
48847 void *argp1 = 0 ;
48848 int res1 = 0 ;
48849 PyObject * obj0 = 0 ;
48850 PyObject * obj1 = 0 ;
48851 char * kwnames[] = {
48852 (char *) "self",(char *) "other", NULL
48853 };
48854
48855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
48856 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48857 if (!SWIG_IsOK(res1)) {
48858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48859 }
48860 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48861 arg2 = obj1;
48862 {
48863 result = (bool)wxGBPosition___ne__(arg1,arg2);
48864 if (PyErr_Occurred()) SWIG_fail;
48865 }
48866 {
48867 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48868 }
48869 return resultobj;
48870 fail:
48871 return NULL;
48872 }
48873
48874
48875 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48876 PyObject *resultobj = 0;
48877 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48878 int arg2 = (int) 0 ;
48879 int arg3 = (int) 0 ;
48880 void *argp1 = 0 ;
48881 int res1 = 0 ;
48882 int val2 ;
48883 int ecode2 = 0 ;
48884 int val3 ;
48885 int ecode3 = 0 ;
48886 PyObject * obj0 = 0 ;
48887 PyObject * obj1 = 0 ;
48888 PyObject * obj2 = 0 ;
48889 char * kwnames[] = {
48890 (char *) "self",(char *) "row",(char *) "col", NULL
48891 };
48892
48893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48895 if (!SWIG_IsOK(res1)) {
48896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48897 }
48898 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48899 if (obj1) {
48900 ecode2 = SWIG_AsVal_int(obj1, &val2);
48901 if (!SWIG_IsOK(ecode2)) {
48902 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
48903 }
48904 arg2 = static_cast< int >(val2);
48905 }
48906 if (obj2) {
48907 ecode3 = SWIG_AsVal_int(obj2, &val3);
48908 if (!SWIG_IsOK(ecode3)) {
48909 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
48910 }
48911 arg3 = static_cast< int >(val3);
48912 }
48913 {
48914 PyThreadState* __tstate = wxPyBeginAllowThreads();
48915 wxGBPosition_Set(arg1,arg2,arg3);
48916 wxPyEndAllowThreads(__tstate);
48917 if (PyErr_Occurred()) SWIG_fail;
48918 }
48919 resultobj = SWIG_Py_Void();
48920 return resultobj;
48921 fail:
48922 return NULL;
48923 }
48924
48925
48926 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48927 PyObject *resultobj = 0;
48928 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48929 PyObject *result = 0 ;
48930 void *argp1 = 0 ;
48931 int res1 = 0 ;
48932 PyObject *swig_obj[1] ;
48933
48934 if (!args) SWIG_fail;
48935 swig_obj[0] = args;
48936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48937 if (!SWIG_IsOK(res1)) {
48938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48939 }
48940 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48941 {
48942 PyThreadState* __tstate = wxPyBeginAllowThreads();
48943 result = (PyObject *)wxGBPosition_Get(arg1);
48944 wxPyEndAllowThreads(__tstate);
48945 if (PyErr_Occurred()) SWIG_fail;
48946 }
48947 resultobj = result;
48948 return resultobj;
48949 fail:
48950 return NULL;
48951 }
48952
48953
48954 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48955 PyObject *obj;
48956 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48957 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
48958 return SWIG_Py_Void();
48959 }
48960
48961 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48962 return SWIG_Python_InitShadowInstance(args);
48963 }
48964
48965 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48966 PyObject *resultobj = 0;
48967 int arg1 = (int) 1 ;
48968 int arg2 = (int) 1 ;
48969 wxGBSpan *result = 0 ;
48970 int val1 ;
48971 int ecode1 = 0 ;
48972 int val2 ;
48973 int ecode2 = 0 ;
48974 PyObject * obj0 = 0 ;
48975 PyObject * obj1 = 0 ;
48976 char * kwnames[] = {
48977 (char *) "rowspan",(char *) "colspan", NULL
48978 };
48979
48980 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
48981 if (obj0) {
48982 ecode1 = SWIG_AsVal_int(obj0, &val1);
48983 if (!SWIG_IsOK(ecode1)) {
48984 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
48985 }
48986 arg1 = static_cast< int >(val1);
48987 }
48988 if (obj1) {
48989 ecode2 = SWIG_AsVal_int(obj1, &val2);
48990 if (!SWIG_IsOK(ecode2)) {
48991 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
48992 }
48993 arg2 = static_cast< int >(val2);
48994 }
48995 {
48996 PyThreadState* __tstate = wxPyBeginAllowThreads();
48997 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
48998 wxPyEndAllowThreads(__tstate);
48999 if (PyErr_Occurred()) SWIG_fail;
49000 }
49001 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
49002 return resultobj;
49003 fail:
49004 return NULL;
49005 }
49006
49007
49008 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49009 PyObject *resultobj = 0;
49010 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49011 void *argp1 = 0 ;
49012 int res1 = 0 ;
49013 PyObject *swig_obj[1] ;
49014
49015 if (!args) SWIG_fail;
49016 swig_obj[0] = args;
49017 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
49018 if (!SWIG_IsOK(res1)) {
49019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49020 }
49021 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49022 {
49023 PyThreadState* __tstate = wxPyBeginAllowThreads();
49024 delete arg1;
49025
49026 wxPyEndAllowThreads(__tstate);
49027 if (PyErr_Occurred()) SWIG_fail;
49028 }
49029 resultobj = SWIG_Py_Void();
49030 return resultobj;
49031 fail:
49032 return NULL;
49033 }
49034
49035
49036 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49037 PyObject *resultobj = 0;
49038 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49039 int result;
49040 void *argp1 = 0 ;
49041 int res1 = 0 ;
49042 PyObject *swig_obj[1] ;
49043
49044 if (!args) SWIG_fail;
49045 swig_obj[0] = args;
49046 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49047 if (!SWIG_IsOK(res1)) {
49048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
49049 }
49050 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49051 {
49052 PyThreadState* __tstate = wxPyBeginAllowThreads();
49053 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
49054 wxPyEndAllowThreads(__tstate);
49055 if (PyErr_Occurred()) SWIG_fail;
49056 }
49057 resultobj = SWIG_From_int(static_cast< int >(result));
49058 return resultobj;
49059 fail:
49060 return NULL;
49061 }
49062
49063
49064 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49065 PyObject *resultobj = 0;
49066 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49067 int result;
49068 void *argp1 = 0 ;
49069 int res1 = 0 ;
49070 PyObject *swig_obj[1] ;
49071
49072 if (!args) SWIG_fail;
49073 swig_obj[0] = args;
49074 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49075 if (!SWIG_IsOK(res1)) {
49076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
49077 }
49078 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49079 {
49080 PyThreadState* __tstate = wxPyBeginAllowThreads();
49081 result = (int)((wxGBSpan const *)arg1)->GetColspan();
49082 wxPyEndAllowThreads(__tstate);
49083 if (PyErr_Occurred()) SWIG_fail;
49084 }
49085 resultobj = SWIG_From_int(static_cast< int >(result));
49086 return resultobj;
49087 fail:
49088 return NULL;
49089 }
49090
49091
49092 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49093 PyObject *resultobj = 0;
49094 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49095 int arg2 ;
49096 void *argp1 = 0 ;
49097 int res1 = 0 ;
49098 int val2 ;
49099 int ecode2 = 0 ;
49100 PyObject * obj0 = 0 ;
49101 PyObject * obj1 = 0 ;
49102 char * kwnames[] = {
49103 (char *) "self",(char *) "rowspan", NULL
49104 };
49105
49106 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
49107 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49108 if (!SWIG_IsOK(res1)) {
49109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49110 }
49111 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49112 ecode2 = SWIG_AsVal_int(obj1, &val2);
49113 if (!SWIG_IsOK(ecode2)) {
49114 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
49115 }
49116 arg2 = static_cast< int >(val2);
49117 {
49118 PyThreadState* __tstate = wxPyBeginAllowThreads();
49119 (arg1)->SetRowspan(arg2);
49120 wxPyEndAllowThreads(__tstate);
49121 if (PyErr_Occurred()) SWIG_fail;
49122 }
49123 resultobj = SWIG_Py_Void();
49124 return resultobj;
49125 fail:
49126 return NULL;
49127 }
49128
49129
49130 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49131 PyObject *resultobj = 0;
49132 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49133 int arg2 ;
49134 void *argp1 = 0 ;
49135 int res1 = 0 ;
49136 int val2 ;
49137 int ecode2 = 0 ;
49138 PyObject * obj0 = 0 ;
49139 PyObject * obj1 = 0 ;
49140 char * kwnames[] = {
49141 (char *) "self",(char *) "colspan", NULL
49142 };
49143
49144 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
49145 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49146 if (!SWIG_IsOK(res1)) {
49147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49148 }
49149 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49150 ecode2 = SWIG_AsVal_int(obj1, &val2);
49151 if (!SWIG_IsOK(ecode2)) {
49152 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
49153 }
49154 arg2 = static_cast< int >(val2);
49155 {
49156 PyThreadState* __tstate = wxPyBeginAllowThreads();
49157 (arg1)->SetColspan(arg2);
49158 wxPyEndAllowThreads(__tstate);
49159 if (PyErr_Occurred()) SWIG_fail;
49160 }
49161 resultobj = SWIG_Py_Void();
49162 return resultobj;
49163 fail:
49164 return NULL;
49165 }
49166
49167
49168 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49169 PyObject *resultobj = 0;
49170 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49171 PyObject *arg2 = (PyObject *) 0 ;
49172 bool result;
49173 void *argp1 = 0 ;
49174 int res1 = 0 ;
49175 PyObject * obj0 = 0 ;
49176 PyObject * obj1 = 0 ;
49177 char * kwnames[] = {
49178 (char *) "self",(char *) "other", NULL
49179 };
49180
49181 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
49182 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49183 if (!SWIG_IsOK(res1)) {
49184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49185 }
49186 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49187 arg2 = obj1;
49188 {
49189 result = (bool)wxGBSpan___eq__(arg1,arg2);
49190 if (PyErr_Occurred()) SWIG_fail;
49191 }
49192 {
49193 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49194 }
49195 return resultobj;
49196 fail:
49197 return NULL;
49198 }
49199
49200
49201 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49202 PyObject *resultobj = 0;
49203 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49204 PyObject *arg2 = (PyObject *) 0 ;
49205 bool result;
49206 void *argp1 = 0 ;
49207 int res1 = 0 ;
49208 PyObject * obj0 = 0 ;
49209 PyObject * obj1 = 0 ;
49210 char * kwnames[] = {
49211 (char *) "self",(char *) "other", NULL
49212 };
49213
49214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
49215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49216 if (!SWIG_IsOK(res1)) {
49217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49218 }
49219 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49220 arg2 = obj1;
49221 {
49222 result = (bool)wxGBSpan___ne__(arg1,arg2);
49223 if (PyErr_Occurred()) SWIG_fail;
49224 }
49225 {
49226 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49227 }
49228 return resultobj;
49229 fail:
49230 return NULL;
49231 }
49232
49233
49234 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49235 PyObject *resultobj = 0;
49236 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49237 int arg2 = (int) 1 ;
49238 int arg3 = (int) 1 ;
49239 void *argp1 = 0 ;
49240 int res1 = 0 ;
49241 int 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 *) "rowspan",(char *) "colspan", NULL
49250 };
49251
49252 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49253 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49254 if (!SWIG_IsOK(res1)) {
49255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49256 }
49257 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49258 if (obj1) {
49259 ecode2 = SWIG_AsVal_int(obj1, &val2);
49260 if (!SWIG_IsOK(ecode2)) {
49261 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
49262 }
49263 arg2 = static_cast< int >(val2);
49264 }
49265 if (obj2) {
49266 ecode3 = SWIG_AsVal_int(obj2, &val3);
49267 if (!SWIG_IsOK(ecode3)) {
49268 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
49269 }
49270 arg3 = static_cast< int >(val3);
49271 }
49272 {
49273 PyThreadState* __tstate = wxPyBeginAllowThreads();
49274 wxGBSpan_Set(arg1,arg2,arg3);
49275 wxPyEndAllowThreads(__tstate);
49276 if (PyErr_Occurred()) SWIG_fail;
49277 }
49278 resultobj = SWIG_Py_Void();
49279 return resultobj;
49280 fail:
49281 return NULL;
49282 }
49283
49284
49285 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49286 PyObject *resultobj = 0;
49287 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49288 PyObject *result = 0 ;
49289 void *argp1 = 0 ;
49290 int res1 = 0 ;
49291 PyObject *swig_obj[1] ;
49292
49293 if (!args) SWIG_fail;
49294 swig_obj[0] = args;
49295 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49296 if (!SWIG_IsOK(res1)) {
49297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49298 }
49299 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49300 {
49301 PyThreadState* __tstate = wxPyBeginAllowThreads();
49302 result = (PyObject *)wxGBSpan_Get(arg1);
49303 wxPyEndAllowThreads(__tstate);
49304 if (PyErr_Occurred()) SWIG_fail;
49305 }
49306 resultobj = result;
49307 return resultobj;
49308 fail:
49309 return NULL;
49310 }
49311
49312
49313 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49314 PyObject *obj;
49315 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49316 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
49317 return SWIG_Py_Void();
49318 }
49319
49320 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49321 return SWIG_Python_InitShadowInstance(args);
49322 }
49323
49324 SWIGINTERN int DefaultSpan_set(PyObject *) {
49325 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
49326 return 1;
49327 }
49328
49329
49330 SWIGINTERN PyObject *DefaultSpan_get(void) {
49331 PyObject *pyobj = 0;
49332
49333 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
49334 return pyobj;
49335 }
49336
49337
49338 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49339 PyObject *resultobj = 0;
49340 wxGBSizerItem *result = 0 ;
49341
49342 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
49343 {
49344 PyThreadState* __tstate = wxPyBeginAllowThreads();
49345 result = (wxGBSizerItem *)new wxGBSizerItem();
49346 wxPyEndAllowThreads(__tstate);
49347 if (PyErr_Occurred()) SWIG_fail;
49348 }
49349 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
49350 return resultobj;
49351 fail:
49352 return NULL;
49353 }
49354
49355
49356 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49357 PyObject *resultobj = 0;
49358 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49359 void *argp1 = 0 ;
49360 int res1 = 0 ;
49361 PyObject *swig_obj[1] ;
49362
49363 if (!args) SWIG_fail;
49364 swig_obj[0] = args;
49365 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
49366 if (!SWIG_IsOK(res1)) {
49367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49368 }
49369 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49370 {
49371 PyThreadState* __tstate = wxPyBeginAllowThreads();
49372 delete arg1;
49373
49374 wxPyEndAllowThreads(__tstate);
49375 if (PyErr_Occurred()) SWIG_fail;
49376 }
49377 resultobj = SWIG_Py_Void();
49378 return resultobj;
49379 fail:
49380 return NULL;
49381 }
49382
49383
49384 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49385 PyObject *resultobj = 0;
49386 wxWindow *arg1 = (wxWindow *) 0 ;
49387 wxGBPosition *arg2 = 0 ;
49388 wxGBSpan *arg3 = 0 ;
49389 int arg4 ;
49390 int arg5 ;
49391 PyObject *arg6 = (PyObject *) NULL ;
49392 wxGBSizerItem *result = 0 ;
49393 void *argp1 = 0 ;
49394 int res1 = 0 ;
49395 wxGBPosition temp2 ;
49396 wxGBSpan temp3 ;
49397 int val4 ;
49398 int ecode4 = 0 ;
49399 int val5 ;
49400 int ecode5 = 0 ;
49401 PyObject * obj0 = 0 ;
49402 PyObject * obj1 = 0 ;
49403 PyObject * obj2 = 0 ;
49404 PyObject * obj3 = 0 ;
49405 PyObject * obj4 = 0 ;
49406 PyObject * obj5 = 0 ;
49407 char * kwnames[] = {
49408 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49409 };
49410
49411 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49412 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
49413 if (!SWIG_IsOK(res1)) {
49414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
49415 }
49416 arg1 = reinterpret_cast< wxWindow * >(argp1);
49417 {
49418 arg2 = &temp2;
49419 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49420 }
49421 {
49422 arg3 = &temp3;
49423 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49424 }
49425 ecode4 = SWIG_AsVal_int(obj3, &val4);
49426 if (!SWIG_IsOK(ecode4)) {
49427 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
49428 }
49429 arg4 = static_cast< int >(val4);
49430 ecode5 = SWIG_AsVal_int(obj4, &val5);
49431 if (!SWIG_IsOK(ecode5)) {
49432 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
49433 }
49434 arg5 = static_cast< int >(val5);
49435 if (obj5) {
49436 arg6 = obj5;
49437 }
49438 {
49439 PyThreadState* __tstate = wxPyBeginAllowThreads();
49440 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
49441 wxPyEndAllowThreads(__tstate);
49442 if (PyErr_Occurred()) SWIG_fail;
49443 }
49444 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49445 return resultobj;
49446 fail:
49447 return NULL;
49448 }
49449
49450
49451 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49452 PyObject *resultobj = 0;
49453 wxSizer *arg1 = (wxSizer *) 0 ;
49454 wxGBPosition *arg2 = 0 ;
49455 wxGBSpan *arg3 = 0 ;
49456 int arg4 ;
49457 int arg5 ;
49458 PyObject *arg6 = (PyObject *) NULL ;
49459 wxGBSizerItem *result = 0 ;
49460 int res1 = 0 ;
49461 wxGBPosition temp2 ;
49462 wxGBSpan temp3 ;
49463 int val4 ;
49464 int ecode4 = 0 ;
49465 int val5 ;
49466 int ecode5 = 0 ;
49467 PyObject * obj0 = 0 ;
49468 PyObject * obj1 = 0 ;
49469 PyObject * obj2 = 0 ;
49470 PyObject * obj3 = 0 ;
49471 PyObject * obj4 = 0 ;
49472 PyObject * obj5 = 0 ;
49473 char * kwnames[] = {
49474 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49475 };
49476
49477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49478 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49479 if (!SWIG_IsOK(res1)) {
49480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
49481 }
49482 {
49483 arg2 = &temp2;
49484 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49485 }
49486 {
49487 arg3 = &temp3;
49488 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49489 }
49490 ecode4 = SWIG_AsVal_int(obj3, &val4);
49491 if (!SWIG_IsOK(ecode4)) {
49492 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
49493 }
49494 arg4 = static_cast< int >(val4);
49495 ecode5 = SWIG_AsVal_int(obj4, &val5);
49496 if (!SWIG_IsOK(ecode5)) {
49497 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
49498 }
49499 arg5 = static_cast< int >(val5);
49500 if (obj5) {
49501 arg6 = obj5;
49502 }
49503 {
49504 PyThreadState* __tstate = wxPyBeginAllowThreads();
49505 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
49506 wxPyEndAllowThreads(__tstate);
49507 if (PyErr_Occurred()) SWIG_fail;
49508 }
49509 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49510 return resultobj;
49511 fail:
49512 return NULL;
49513 }
49514
49515
49516 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49517 PyObject *resultobj = 0;
49518 int arg1 ;
49519 int arg2 ;
49520 wxGBPosition *arg3 = 0 ;
49521 wxGBSpan *arg4 = 0 ;
49522 int arg5 ;
49523 int arg6 ;
49524 PyObject *arg7 = (PyObject *) NULL ;
49525 wxGBSizerItem *result = 0 ;
49526 int val1 ;
49527 int ecode1 = 0 ;
49528 int val2 ;
49529 int ecode2 = 0 ;
49530 wxGBPosition temp3 ;
49531 wxGBSpan temp4 ;
49532 int val5 ;
49533 int ecode5 = 0 ;
49534 int val6 ;
49535 int ecode6 = 0 ;
49536 PyObject * obj0 = 0 ;
49537 PyObject * obj1 = 0 ;
49538 PyObject * obj2 = 0 ;
49539 PyObject * obj3 = 0 ;
49540 PyObject * obj4 = 0 ;
49541 PyObject * obj5 = 0 ;
49542 PyObject * obj6 = 0 ;
49543 char * kwnames[] = {
49544 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49545 };
49546
49547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
49548 ecode1 = SWIG_AsVal_int(obj0, &val1);
49549 if (!SWIG_IsOK(ecode1)) {
49550 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
49551 }
49552 arg1 = static_cast< int >(val1);
49553 ecode2 = SWIG_AsVal_int(obj1, &val2);
49554 if (!SWIG_IsOK(ecode2)) {
49555 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
49556 }
49557 arg2 = static_cast< int >(val2);
49558 {
49559 arg3 = &temp3;
49560 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
49561 }
49562 {
49563 arg4 = &temp4;
49564 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
49565 }
49566 ecode5 = SWIG_AsVal_int(obj4, &val5);
49567 if (!SWIG_IsOK(ecode5)) {
49568 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
49569 }
49570 arg5 = static_cast< int >(val5);
49571 ecode6 = SWIG_AsVal_int(obj5, &val6);
49572 if (!SWIG_IsOK(ecode6)) {
49573 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
49574 }
49575 arg6 = static_cast< int >(val6);
49576 if (obj6) {
49577 arg7 = obj6;
49578 }
49579 {
49580 PyThreadState* __tstate = wxPyBeginAllowThreads();
49581 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
49582 wxPyEndAllowThreads(__tstate);
49583 if (PyErr_Occurred()) SWIG_fail;
49584 }
49585 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49586 return resultobj;
49587 fail:
49588 return NULL;
49589 }
49590
49591
49592 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49593 PyObject *resultobj = 0;
49594 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49595 wxGBPosition result;
49596 void *argp1 = 0 ;
49597 int res1 = 0 ;
49598 PyObject *swig_obj[1] ;
49599
49600 if (!args) SWIG_fail;
49601 swig_obj[0] = args;
49602 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49603 if (!SWIG_IsOK(res1)) {
49604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49605 }
49606 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49607 {
49608 PyThreadState* __tstate = wxPyBeginAllowThreads();
49609 result = ((wxGBSizerItem const *)arg1)->GetPos();
49610 wxPyEndAllowThreads(__tstate);
49611 if (PyErr_Occurred()) SWIG_fail;
49612 }
49613 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
49614 return resultobj;
49615 fail:
49616 return NULL;
49617 }
49618
49619
49620 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49621 PyObject *resultobj = 0;
49622 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49623 wxGBSpan result;
49624 void *argp1 = 0 ;
49625 int res1 = 0 ;
49626 PyObject *swig_obj[1] ;
49627
49628 if (!args) SWIG_fail;
49629 swig_obj[0] = args;
49630 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49631 if (!SWIG_IsOK(res1)) {
49632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49633 }
49634 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49635 {
49636 PyThreadState* __tstate = wxPyBeginAllowThreads();
49637 result = ((wxGBSizerItem const *)arg1)->GetSpan();
49638 wxPyEndAllowThreads(__tstate);
49639 if (PyErr_Occurred()) SWIG_fail;
49640 }
49641 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
49642 return resultobj;
49643 fail:
49644 return NULL;
49645 }
49646
49647
49648 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49649 PyObject *resultobj = 0;
49650 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49651 wxGBPosition *arg2 = 0 ;
49652 bool result;
49653 void *argp1 = 0 ;
49654 int res1 = 0 ;
49655 wxGBPosition temp2 ;
49656 PyObject * obj0 = 0 ;
49657 PyObject * obj1 = 0 ;
49658 char * kwnames[] = {
49659 (char *) "self",(char *) "pos", NULL
49660 };
49661
49662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
49663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49664 if (!SWIG_IsOK(res1)) {
49665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49666 }
49667 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49668 {
49669 arg2 = &temp2;
49670 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49671 }
49672 {
49673 PyThreadState* __tstate = wxPyBeginAllowThreads();
49674 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
49675 wxPyEndAllowThreads(__tstate);
49676 if (PyErr_Occurred()) SWIG_fail;
49677 }
49678 {
49679 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49680 }
49681 return resultobj;
49682 fail:
49683 return NULL;
49684 }
49685
49686
49687 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49688 PyObject *resultobj = 0;
49689 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49690 wxGBSpan *arg2 = 0 ;
49691 bool result;
49692 void *argp1 = 0 ;
49693 int res1 = 0 ;
49694 wxGBSpan temp2 ;
49695 PyObject * obj0 = 0 ;
49696 PyObject * obj1 = 0 ;
49697 char * kwnames[] = {
49698 (char *) "self",(char *) "span", NULL
49699 };
49700
49701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
49702 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49703 if (!SWIG_IsOK(res1)) {
49704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49705 }
49706 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49707 {
49708 arg2 = &temp2;
49709 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
49710 }
49711 {
49712 PyThreadState* __tstate = wxPyBeginAllowThreads();
49713 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
49714 wxPyEndAllowThreads(__tstate);
49715 if (PyErr_Occurred()) SWIG_fail;
49716 }
49717 {
49718 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49719 }
49720 return resultobj;
49721 fail:
49722 return NULL;
49723 }
49724
49725
49726 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49727 PyObject *resultobj = 0;
49728 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49729 wxGBSizerItem *arg2 = 0 ;
49730 bool result;
49731 void *argp1 = 0 ;
49732 int res1 = 0 ;
49733 void *argp2 = 0 ;
49734 int res2 = 0 ;
49735 PyObject * obj0 = 0 ;
49736 PyObject * obj1 = 0 ;
49737 char * kwnames[] = {
49738 (char *) "self",(char *) "other", NULL
49739 };
49740
49741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
49742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49743 if (!SWIG_IsOK(res1)) {
49744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49745 }
49746 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49747 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
49748 if (!SWIG_IsOK(res2)) {
49749 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
49750 }
49751 if (!argp2) {
49752 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
49753 }
49754 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
49755 {
49756 PyThreadState* __tstate = wxPyBeginAllowThreads();
49757 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
49758 wxPyEndAllowThreads(__tstate);
49759 if (PyErr_Occurred()) SWIG_fail;
49760 }
49761 {
49762 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49763 }
49764 return resultobj;
49765 fail:
49766 return NULL;
49767 }
49768
49769
49770 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49771 PyObject *resultobj = 0;
49772 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49773 wxGBPosition *arg2 = 0 ;
49774 wxGBSpan *arg3 = 0 ;
49775 bool result;
49776 void *argp1 = 0 ;
49777 int res1 = 0 ;
49778 wxGBPosition temp2 ;
49779 wxGBSpan temp3 ;
49780 PyObject * obj0 = 0 ;
49781 PyObject * obj1 = 0 ;
49782 PyObject * obj2 = 0 ;
49783 char * kwnames[] = {
49784 (char *) "self",(char *) "pos",(char *) "span", NULL
49785 };
49786
49787 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49788 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49789 if (!SWIG_IsOK(res1)) {
49790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49791 }
49792 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49793 {
49794 arg2 = &temp2;
49795 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49796 }
49797 {
49798 arg3 = &temp3;
49799 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49800 }
49801 {
49802 PyThreadState* __tstate = wxPyBeginAllowThreads();
49803 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
49804 wxPyEndAllowThreads(__tstate);
49805 if (PyErr_Occurred()) SWIG_fail;
49806 }
49807 {
49808 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49809 }
49810 return resultobj;
49811 fail:
49812 return NULL;
49813 }
49814
49815
49816 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49817 PyObject *resultobj = 0;
49818 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49819 wxGBPosition result;
49820 void *argp1 = 0 ;
49821 int res1 = 0 ;
49822 PyObject *swig_obj[1] ;
49823
49824 if (!args) SWIG_fail;
49825 swig_obj[0] = args;
49826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49827 if (!SWIG_IsOK(res1)) {
49828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49829 }
49830 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49831 {
49832 PyThreadState* __tstate = wxPyBeginAllowThreads();
49833 result = wxGBSizerItem_GetEndPos(arg1);
49834 wxPyEndAllowThreads(__tstate);
49835 if (PyErr_Occurred()) SWIG_fail;
49836 }
49837 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
49838 return resultobj;
49839 fail:
49840 return NULL;
49841 }
49842
49843
49844 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49845 PyObject *resultobj = 0;
49846 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49847 wxGridBagSizer *result = 0 ;
49848 void *argp1 = 0 ;
49849 int res1 = 0 ;
49850 PyObject *swig_obj[1] ;
49851
49852 if (!args) SWIG_fail;
49853 swig_obj[0] = args;
49854 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49855 if (!SWIG_IsOK(res1)) {
49856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49857 }
49858 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49859 {
49860 PyThreadState* __tstate = wxPyBeginAllowThreads();
49861 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
49862 wxPyEndAllowThreads(__tstate);
49863 if (PyErr_Occurred()) SWIG_fail;
49864 }
49865 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49866 return resultobj;
49867 fail:
49868 return NULL;
49869 }
49870
49871
49872 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49873 PyObject *resultobj = 0;
49874 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49875 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
49876 void *argp1 = 0 ;
49877 int res1 = 0 ;
49878 void *argp2 = 0 ;
49879 int res2 = 0 ;
49880 PyObject * obj0 = 0 ;
49881 PyObject * obj1 = 0 ;
49882 char * kwnames[] = {
49883 (char *) "self",(char *) "sizer", NULL
49884 };
49885
49886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
49887 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49888 if (!SWIG_IsOK(res1)) {
49889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49890 }
49891 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49892 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49893 if (!SWIG_IsOK(res2)) {
49894 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
49895 }
49896 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
49897 {
49898 PyThreadState* __tstate = wxPyBeginAllowThreads();
49899 (arg1)->SetGBSizer(arg2);
49900 wxPyEndAllowThreads(__tstate);
49901 if (PyErr_Occurred()) SWIG_fail;
49902 }
49903 resultobj = SWIG_Py_Void();
49904 return resultobj;
49905 fail:
49906 return NULL;
49907 }
49908
49909
49910 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49911 PyObject *obj;
49912 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49913 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
49914 return SWIG_Py_Void();
49915 }
49916
49917 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49918 return SWIG_Python_InitShadowInstance(args);
49919 }
49920
49921 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49922 PyObject *resultobj = 0;
49923 int arg1 = (int) 0 ;
49924 int arg2 = (int) 0 ;
49925 wxGridBagSizer *result = 0 ;
49926 int val1 ;
49927 int ecode1 = 0 ;
49928 int val2 ;
49929 int ecode2 = 0 ;
49930 PyObject * obj0 = 0 ;
49931 PyObject * obj1 = 0 ;
49932 char * kwnames[] = {
49933 (char *) "vgap",(char *) "hgap", NULL
49934 };
49935
49936 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
49937 if (obj0) {
49938 ecode1 = SWIG_AsVal_int(obj0, &val1);
49939 if (!SWIG_IsOK(ecode1)) {
49940 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
49941 }
49942 arg1 = static_cast< int >(val1);
49943 }
49944 if (obj1) {
49945 ecode2 = SWIG_AsVal_int(obj1, &val2);
49946 if (!SWIG_IsOK(ecode2)) {
49947 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
49948 }
49949 arg2 = static_cast< int >(val2);
49950 }
49951 {
49952 PyThreadState* __tstate = wxPyBeginAllowThreads();
49953 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
49954 wxPyEndAllowThreads(__tstate);
49955 if (PyErr_Occurred()) SWIG_fail;
49956 }
49957 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
49958 return resultobj;
49959 fail:
49960 return NULL;
49961 }
49962
49963
49964 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49965 PyObject *resultobj = 0;
49966 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
49967 PyObject *arg2 = (PyObject *) 0 ;
49968 wxGBPosition *arg3 = 0 ;
49969 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
49970 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
49971 int arg5 = (int) 0 ;
49972 int arg6 = (int) 0 ;
49973 PyObject *arg7 = (PyObject *) NULL ;
49974 wxGBSizerItem *result = 0 ;
49975 void *argp1 = 0 ;
49976 int res1 = 0 ;
49977 wxGBPosition temp3 ;
49978 wxGBSpan temp4 ;
49979 int val5 ;
49980 int ecode5 = 0 ;
49981 int val6 ;
49982 int ecode6 = 0 ;
49983 PyObject * obj0 = 0 ;
49984 PyObject * obj1 = 0 ;
49985 PyObject * obj2 = 0 ;
49986 PyObject * obj3 = 0 ;
49987 PyObject * obj4 = 0 ;
49988 PyObject * obj5 = 0 ;
49989 PyObject * obj6 = 0 ;
49990 char * kwnames[] = {
49991 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49992 };
49993
49994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
49995 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49996 if (!SWIG_IsOK(res1)) {
49997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
49998 }
49999 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50000 arg2 = obj1;
50001 {
50002 arg3 = &temp3;
50003 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
50004 }
50005 if (obj3) {
50006 {
50007 arg4 = &temp4;
50008 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
50009 }
50010 }
50011 if (obj4) {
50012 ecode5 = SWIG_AsVal_int(obj4, &val5);
50013 if (!SWIG_IsOK(ecode5)) {
50014 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
50015 }
50016 arg5 = static_cast< int >(val5);
50017 }
50018 if (obj5) {
50019 ecode6 = SWIG_AsVal_int(obj5, &val6);
50020 if (!SWIG_IsOK(ecode6)) {
50021 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
50022 }
50023 arg6 = static_cast< int >(val6);
50024 }
50025 if (obj6) {
50026 arg7 = obj6;
50027 }
50028 {
50029 PyThreadState* __tstate = wxPyBeginAllowThreads();
50030 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
50031 wxPyEndAllowThreads(__tstate);
50032 if (PyErr_Occurred()) SWIG_fail;
50033 }
50034 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50035 return resultobj;
50036 fail:
50037 return NULL;
50038 }
50039
50040
50041 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50042 PyObject *resultobj = 0;
50043 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50044 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
50045 wxGBSizerItem *result = 0 ;
50046 void *argp1 = 0 ;
50047 int res1 = 0 ;
50048 int res2 = 0 ;
50049 PyObject * obj0 = 0 ;
50050 PyObject * obj1 = 0 ;
50051 char * kwnames[] = {
50052 (char *) "self",(char *) "item", NULL
50053 };
50054
50055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
50056 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50057 if (!SWIG_IsOK(res1)) {
50058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50059 }
50060 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50061 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
50062 if (!SWIG_IsOK(res2)) {
50063 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
50064 }
50065 {
50066 PyThreadState* __tstate = wxPyBeginAllowThreads();
50067 result = (wxGBSizerItem *)(arg1)->Add(arg2);
50068 wxPyEndAllowThreads(__tstate);
50069 if (PyErr_Occurred()) SWIG_fail;
50070 }
50071 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50072 return resultobj;
50073 fail:
50074 return NULL;
50075 }
50076
50077
50078 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50079 PyObject *resultobj = 0;
50080 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50081 int arg2 ;
50082 int arg3 ;
50083 wxSize result;
50084 void *argp1 = 0 ;
50085 int res1 = 0 ;
50086 int val2 ;
50087 int ecode2 = 0 ;
50088 int val3 ;
50089 int ecode3 = 0 ;
50090 PyObject * obj0 = 0 ;
50091 PyObject * obj1 = 0 ;
50092 PyObject * obj2 = 0 ;
50093 char * kwnames[] = {
50094 (char *) "self",(char *) "row",(char *) "col", NULL
50095 };
50096
50097 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50098 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50099 if (!SWIG_IsOK(res1)) {
50100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
50101 }
50102 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50103 ecode2 = SWIG_AsVal_int(obj1, &val2);
50104 if (!SWIG_IsOK(ecode2)) {
50105 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
50106 }
50107 arg2 = static_cast< int >(val2);
50108 ecode3 = SWIG_AsVal_int(obj2, &val3);
50109 if (!SWIG_IsOK(ecode3)) {
50110 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
50111 }
50112 arg3 = static_cast< int >(val3);
50113 {
50114 PyThreadState* __tstate = wxPyBeginAllowThreads();
50115 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
50116 wxPyEndAllowThreads(__tstate);
50117 if (PyErr_Occurred()) SWIG_fail;
50118 }
50119 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50120 return resultobj;
50121 fail:
50122 return NULL;
50123 }
50124
50125
50126 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50127 PyObject *resultobj = 0;
50128 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50129 wxSize result;
50130 void *argp1 = 0 ;
50131 int res1 = 0 ;
50132 PyObject *swig_obj[1] ;
50133
50134 if (!args) SWIG_fail;
50135 swig_obj[0] = args;
50136 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50137 if (!SWIG_IsOK(res1)) {
50138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
50139 }
50140 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50141 {
50142 PyThreadState* __tstate = wxPyBeginAllowThreads();
50143 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
50144 wxPyEndAllowThreads(__tstate);
50145 if (PyErr_Occurred()) SWIG_fail;
50146 }
50147 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50148 return resultobj;
50149 fail:
50150 return NULL;
50151 }
50152
50153
50154 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50155 PyObject *resultobj = 0;
50156 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50157 wxSize *arg2 = 0 ;
50158 void *argp1 = 0 ;
50159 int res1 = 0 ;
50160 wxSize temp2 ;
50161 PyObject * obj0 = 0 ;
50162 PyObject * obj1 = 0 ;
50163 char * kwnames[] = {
50164 (char *) "self",(char *) "sz", NULL
50165 };
50166
50167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
50168 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50169 if (!SWIG_IsOK(res1)) {
50170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50171 }
50172 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50173 {
50174 arg2 = &temp2;
50175 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50176 }
50177 {
50178 PyThreadState* __tstate = wxPyBeginAllowThreads();
50179 (arg1)->SetEmptyCellSize((wxSize const &)*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_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50191 PyObject *resultobj = 0;
50192 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50193 wxWindow *arg2 = (wxWindow *) 0 ;
50194 wxGBPosition result;
50195 void *argp1 = 0 ;
50196 int res1 = 0 ;
50197 void *argp2 = 0 ;
50198 int res2 = 0 ;
50199
50200 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50201 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50202 if (!SWIG_IsOK(res1)) {
50203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50204 }
50205 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50206 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50207 if (!SWIG_IsOK(res2)) {
50208 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50209 }
50210 arg2 = reinterpret_cast< wxWindow * >(argp2);
50211 {
50212 PyThreadState* __tstate = wxPyBeginAllowThreads();
50213 result = (arg1)->GetItemPosition(arg2);
50214 wxPyEndAllowThreads(__tstate);
50215 if (PyErr_Occurred()) SWIG_fail;
50216 }
50217 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50218 return resultobj;
50219 fail:
50220 return NULL;
50221 }
50222
50223
50224 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50225 PyObject *resultobj = 0;
50226 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50227 wxSizer *arg2 = (wxSizer *) 0 ;
50228 wxGBPosition result;
50229 void *argp1 = 0 ;
50230 int res1 = 0 ;
50231 void *argp2 = 0 ;
50232 int res2 = 0 ;
50233
50234 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50235 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50236 if (!SWIG_IsOK(res1)) {
50237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50238 }
50239 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50240 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50241 if (!SWIG_IsOK(res2)) {
50242 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50243 }
50244 arg2 = reinterpret_cast< wxSizer * >(argp2);
50245 {
50246 PyThreadState* __tstate = wxPyBeginAllowThreads();
50247 result = (arg1)->GetItemPosition(arg2);
50248 wxPyEndAllowThreads(__tstate);
50249 if (PyErr_Occurred()) SWIG_fail;
50250 }
50251 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50252 return resultobj;
50253 fail:
50254 return NULL;
50255 }
50256
50257
50258 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50259 PyObject *resultobj = 0;
50260 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50261 size_t arg2 ;
50262 wxGBPosition result;
50263 void *argp1 = 0 ;
50264 int res1 = 0 ;
50265 size_t val2 ;
50266 int ecode2 = 0 ;
50267
50268 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50269 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50270 if (!SWIG_IsOK(res1)) {
50271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50272 }
50273 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50274 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50275 if (!SWIG_IsOK(ecode2)) {
50276 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50277 }
50278 arg2 = static_cast< size_t >(val2);
50279 {
50280 PyThreadState* __tstate = wxPyBeginAllowThreads();
50281 result = (arg1)->GetItemPosition(arg2);
50282 wxPyEndAllowThreads(__tstate);
50283 if (PyErr_Occurred()) SWIG_fail;
50284 }
50285 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50286 return resultobj;
50287 fail:
50288 return NULL;
50289 }
50290
50291
50292 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
50293 int argc;
50294 PyObject *argv[3];
50295
50296 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
50297 --argc;
50298 if (argc == 2) {
50299 int _v = 0;
50300 {
50301 void *vptr = 0;
50302 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50303 _v = SWIG_CheckState(res);
50304 }
50305 if (!_v) goto check_1;
50306 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
50307 }
50308 check_1:
50309
50310 if (argc == 2) {
50311 int _v = 0;
50312 {
50313 void *vptr = 0;
50314 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50315 _v = SWIG_CheckState(res);
50316 }
50317 if (!_v) goto check_2;
50318 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
50319 }
50320 check_2:
50321
50322 if (argc == 2) {
50323 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
50324 }
50325
50326 fail:
50327 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
50328 return NULL;
50329 }
50330
50331
50332 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50333 PyObject *resultobj = 0;
50334 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50335 wxWindow *arg2 = (wxWindow *) 0 ;
50336 wxGBPosition *arg3 = 0 ;
50337 bool result;
50338 void *argp1 = 0 ;
50339 int res1 = 0 ;
50340 void *argp2 = 0 ;
50341 int res2 = 0 ;
50342 wxGBPosition temp3 ;
50343
50344 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50345 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50346 if (!SWIG_IsOK(res1)) {
50347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50348 }
50349 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50350 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50351 if (!SWIG_IsOK(res2)) {
50352 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50353 }
50354 arg2 = reinterpret_cast< wxWindow * >(argp2);
50355 {
50356 arg3 = &temp3;
50357 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50358 }
50359 {
50360 PyThreadState* __tstate = wxPyBeginAllowThreads();
50361 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50362 wxPyEndAllowThreads(__tstate);
50363 if (PyErr_Occurred()) SWIG_fail;
50364 }
50365 {
50366 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50367 }
50368 return resultobj;
50369 fail:
50370 return NULL;
50371 }
50372
50373
50374 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50375 PyObject *resultobj = 0;
50376 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50377 wxSizer *arg2 = (wxSizer *) 0 ;
50378 wxGBPosition *arg3 = 0 ;
50379 bool result;
50380 void *argp1 = 0 ;
50381 int res1 = 0 ;
50382 void *argp2 = 0 ;
50383 int res2 = 0 ;
50384 wxGBPosition temp3 ;
50385
50386 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50387 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50388 if (!SWIG_IsOK(res1)) {
50389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50390 }
50391 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50392 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50393 if (!SWIG_IsOK(res2)) {
50394 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50395 }
50396 arg2 = reinterpret_cast< wxSizer * >(argp2);
50397 {
50398 arg3 = &temp3;
50399 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50400 }
50401 {
50402 PyThreadState* __tstate = wxPyBeginAllowThreads();
50403 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50404 wxPyEndAllowThreads(__tstate);
50405 if (PyErr_Occurred()) SWIG_fail;
50406 }
50407 {
50408 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50409 }
50410 return resultobj;
50411 fail:
50412 return NULL;
50413 }
50414
50415
50416 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50417 PyObject *resultobj = 0;
50418 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50419 size_t arg2 ;
50420 wxGBPosition *arg3 = 0 ;
50421 bool result;
50422 void *argp1 = 0 ;
50423 int res1 = 0 ;
50424 size_t val2 ;
50425 int ecode2 = 0 ;
50426 wxGBPosition temp3 ;
50427
50428 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50429 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50430 if (!SWIG_IsOK(res1)) {
50431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50432 }
50433 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50434 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50435 if (!SWIG_IsOK(ecode2)) {
50436 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50437 }
50438 arg2 = static_cast< size_t >(val2);
50439 {
50440 arg3 = &temp3;
50441 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50442 }
50443 {
50444 PyThreadState* __tstate = wxPyBeginAllowThreads();
50445 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50446 wxPyEndAllowThreads(__tstate);
50447 if (PyErr_Occurred()) SWIG_fail;
50448 }
50449 {
50450 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50451 }
50452 return resultobj;
50453 fail:
50454 return NULL;
50455 }
50456
50457
50458 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
50459 int argc;
50460 PyObject *argv[4];
50461
50462 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
50463 --argc;
50464 if (argc == 3) {
50465 int _v = 0;
50466 {
50467 void *vptr = 0;
50468 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50469 _v = SWIG_CheckState(res);
50470 }
50471 if (!_v) goto check_1;
50472 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
50473 }
50474 check_1:
50475
50476 if (argc == 3) {
50477 int _v = 0;
50478 {
50479 void *vptr = 0;
50480 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50481 _v = SWIG_CheckState(res);
50482 }
50483 if (!_v) goto check_2;
50484 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
50485 }
50486 check_2:
50487
50488 if (argc == 3) {
50489 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
50490 }
50491
50492 fail:
50493 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
50494 return NULL;
50495 }
50496
50497
50498 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50499 PyObject *resultobj = 0;
50500 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50501 wxWindow *arg2 = (wxWindow *) 0 ;
50502 wxGBSpan result;
50503 void *argp1 = 0 ;
50504 int res1 = 0 ;
50505 void *argp2 = 0 ;
50506 int res2 = 0 ;
50507
50508 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50509 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50510 if (!SWIG_IsOK(res1)) {
50511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50512 }
50513 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50514 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50515 if (!SWIG_IsOK(res2)) {
50516 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
50517 }
50518 arg2 = reinterpret_cast< wxWindow * >(argp2);
50519 {
50520 PyThreadState* __tstate = wxPyBeginAllowThreads();
50521 result = (arg1)->GetItemSpan(arg2);
50522 wxPyEndAllowThreads(__tstate);
50523 if (PyErr_Occurred()) SWIG_fail;
50524 }
50525 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50526 return resultobj;
50527 fail:
50528 return NULL;
50529 }
50530
50531
50532 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50533 PyObject *resultobj = 0;
50534 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50535 wxSizer *arg2 = (wxSizer *) 0 ;
50536 wxGBSpan result;
50537 void *argp1 = 0 ;
50538 int res1 = 0 ;
50539 void *argp2 = 0 ;
50540 int res2 = 0 ;
50541
50542 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50543 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50544 if (!SWIG_IsOK(res1)) {
50545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50546 }
50547 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50548 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50549 if (!SWIG_IsOK(res2)) {
50550 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
50551 }
50552 arg2 = reinterpret_cast< wxSizer * >(argp2);
50553 {
50554 PyThreadState* __tstate = wxPyBeginAllowThreads();
50555 result = (arg1)->GetItemSpan(arg2);
50556 wxPyEndAllowThreads(__tstate);
50557 if (PyErr_Occurred()) SWIG_fail;
50558 }
50559 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50560 return resultobj;
50561 fail:
50562 return NULL;
50563 }
50564
50565
50566 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50567 PyObject *resultobj = 0;
50568 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50569 size_t arg2 ;
50570 wxGBSpan result;
50571 void *argp1 = 0 ;
50572 int res1 = 0 ;
50573 size_t val2 ;
50574 int ecode2 = 0 ;
50575
50576 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50577 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50578 if (!SWIG_IsOK(res1)) {
50579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50580 }
50581 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50582 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50583 if (!SWIG_IsOK(ecode2)) {
50584 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
50585 }
50586 arg2 = static_cast< size_t >(val2);
50587 {
50588 PyThreadState* __tstate = wxPyBeginAllowThreads();
50589 result = (arg1)->GetItemSpan(arg2);
50590 wxPyEndAllowThreads(__tstate);
50591 if (PyErr_Occurred()) SWIG_fail;
50592 }
50593 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50594 return resultobj;
50595 fail:
50596 return NULL;
50597 }
50598
50599
50600 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
50601 int argc;
50602 PyObject *argv[3];
50603
50604 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
50605 --argc;
50606 if (argc == 2) {
50607 int _v = 0;
50608 {
50609 void *vptr = 0;
50610 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50611 _v = SWIG_CheckState(res);
50612 }
50613 if (!_v) goto check_1;
50614 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
50615 }
50616 check_1:
50617
50618 if (argc == 2) {
50619 int _v = 0;
50620 {
50621 void *vptr = 0;
50622 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50623 _v = SWIG_CheckState(res);
50624 }
50625 if (!_v) goto check_2;
50626 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
50627 }
50628 check_2:
50629
50630 if (argc == 2) {
50631 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
50632 }
50633
50634 fail:
50635 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
50636 return NULL;
50637 }
50638
50639
50640 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50641 PyObject *resultobj = 0;
50642 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50643 wxWindow *arg2 = (wxWindow *) 0 ;
50644 wxGBSpan *arg3 = 0 ;
50645 bool result;
50646 void *argp1 = 0 ;
50647 int res1 = 0 ;
50648 void *argp2 = 0 ;
50649 int res2 = 0 ;
50650 wxGBSpan temp3 ;
50651
50652 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50653 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50654 if (!SWIG_IsOK(res1)) {
50655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50656 }
50657 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50658 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50659 if (!SWIG_IsOK(res2)) {
50660 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
50661 }
50662 arg2 = reinterpret_cast< wxWindow * >(argp2);
50663 {
50664 arg3 = &temp3;
50665 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50666 }
50667 {
50668 PyThreadState* __tstate = wxPyBeginAllowThreads();
50669 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50670 wxPyEndAllowThreads(__tstate);
50671 if (PyErr_Occurred()) SWIG_fail;
50672 }
50673 {
50674 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50675 }
50676 return resultobj;
50677 fail:
50678 return NULL;
50679 }
50680
50681
50682 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50683 PyObject *resultobj = 0;
50684 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50685 wxSizer *arg2 = (wxSizer *) 0 ;
50686 wxGBSpan *arg3 = 0 ;
50687 bool result;
50688 void *argp1 = 0 ;
50689 int res1 = 0 ;
50690 void *argp2 = 0 ;
50691 int res2 = 0 ;
50692 wxGBSpan temp3 ;
50693
50694 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50696 if (!SWIG_IsOK(res1)) {
50697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50698 }
50699 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50700 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50701 if (!SWIG_IsOK(res2)) {
50702 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
50703 }
50704 arg2 = reinterpret_cast< wxSizer * >(argp2);
50705 {
50706 arg3 = &temp3;
50707 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50708 }
50709 {
50710 PyThreadState* __tstate = wxPyBeginAllowThreads();
50711 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50712 wxPyEndAllowThreads(__tstate);
50713 if (PyErr_Occurred()) SWIG_fail;
50714 }
50715 {
50716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50717 }
50718 return resultobj;
50719 fail:
50720 return NULL;
50721 }
50722
50723
50724 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50725 PyObject *resultobj = 0;
50726 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50727 size_t arg2 ;
50728 wxGBSpan *arg3 = 0 ;
50729 bool result;
50730 void *argp1 = 0 ;
50731 int res1 = 0 ;
50732 size_t val2 ;
50733 int ecode2 = 0 ;
50734 wxGBSpan temp3 ;
50735
50736 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50737 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50738 if (!SWIG_IsOK(res1)) {
50739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50740 }
50741 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50742 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50743 if (!SWIG_IsOK(ecode2)) {
50744 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
50745 }
50746 arg2 = static_cast< size_t >(val2);
50747 {
50748 arg3 = &temp3;
50749 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50750 }
50751 {
50752 PyThreadState* __tstate = wxPyBeginAllowThreads();
50753 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50754 wxPyEndAllowThreads(__tstate);
50755 if (PyErr_Occurred()) SWIG_fail;
50756 }
50757 {
50758 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50759 }
50760 return resultobj;
50761 fail:
50762 return NULL;
50763 }
50764
50765
50766 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
50767 int argc;
50768 PyObject *argv[4];
50769
50770 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
50771 --argc;
50772 if (argc == 3) {
50773 int _v = 0;
50774 {
50775 void *vptr = 0;
50776 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50777 _v = SWIG_CheckState(res);
50778 }
50779 if (!_v) goto check_1;
50780 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
50781 }
50782 check_1:
50783
50784 if (argc == 3) {
50785 int _v = 0;
50786 {
50787 void *vptr = 0;
50788 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50789 _v = SWIG_CheckState(res);
50790 }
50791 if (!_v) goto check_2;
50792 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
50793 }
50794 check_2:
50795
50796 if (argc == 3) {
50797 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
50798 }
50799
50800 fail:
50801 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
50802 return NULL;
50803 }
50804
50805
50806 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50807 PyObject *resultobj = 0;
50808 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50809 wxWindow *arg2 = (wxWindow *) 0 ;
50810 wxGBSizerItem *result = 0 ;
50811 void *argp1 = 0 ;
50812 int res1 = 0 ;
50813 void *argp2 = 0 ;
50814 int res2 = 0 ;
50815
50816 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50817 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50818 if (!SWIG_IsOK(res1)) {
50819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50820 }
50821 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50822 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50823 if (!SWIG_IsOK(res2)) {
50824 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
50825 }
50826 arg2 = reinterpret_cast< wxWindow * >(argp2);
50827 {
50828 PyThreadState* __tstate = wxPyBeginAllowThreads();
50829 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
50830 wxPyEndAllowThreads(__tstate);
50831 if (PyErr_Occurred()) SWIG_fail;
50832 }
50833 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50834 return resultobj;
50835 fail:
50836 return NULL;
50837 }
50838
50839
50840 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50841 PyObject *resultobj = 0;
50842 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50843 wxSizer *arg2 = (wxSizer *) 0 ;
50844 wxGBSizerItem *result = 0 ;
50845 void *argp1 = 0 ;
50846 int res1 = 0 ;
50847 void *argp2 = 0 ;
50848 int res2 = 0 ;
50849
50850 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50851 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50852 if (!SWIG_IsOK(res1)) {
50853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50854 }
50855 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50856 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50857 if (!SWIG_IsOK(res2)) {
50858 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
50859 }
50860 arg2 = reinterpret_cast< wxSizer * >(argp2);
50861 {
50862 PyThreadState* __tstate = wxPyBeginAllowThreads();
50863 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
50864 wxPyEndAllowThreads(__tstate);
50865 if (PyErr_Occurred()) SWIG_fail;
50866 }
50867 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50868 return resultobj;
50869 fail:
50870 return NULL;
50871 }
50872
50873
50874 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
50875 int argc;
50876 PyObject *argv[3];
50877
50878 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
50879 --argc;
50880 if (argc == 2) {
50881 int _v = 0;
50882 {
50883 void *vptr = 0;
50884 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50885 _v = SWIG_CheckState(res);
50886 }
50887 if (!_v) goto check_1;
50888 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
50889 }
50890 check_1:
50891
50892 if (argc == 2) {
50893 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
50894 }
50895
50896 fail:
50897 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
50898 return NULL;
50899 }
50900
50901
50902 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50903 PyObject *resultobj = 0;
50904 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50905 wxGBPosition *arg2 = 0 ;
50906 wxGBSizerItem *result = 0 ;
50907 void *argp1 = 0 ;
50908 int res1 = 0 ;
50909 wxGBPosition temp2 ;
50910 PyObject * obj0 = 0 ;
50911 PyObject * obj1 = 0 ;
50912 char * kwnames[] = {
50913 (char *) "self",(char *) "pos", NULL
50914 };
50915
50916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
50917 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50918 if (!SWIG_IsOK(res1)) {
50919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50920 }
50921 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50922 {
50923 arg2 = &temp2;
50924 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50925 }
50926 {
50927 PyThreadState* __tstate = wxPyBeginAllowThreads();
50928 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
50929 wxPyEndAllowThreads(__tstate);
50930 if (PyErr_Occurred()) SWIG_fail;
50931 }
50932 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50933 return resultobj;
50934 fail:
50935 return NULL;
50936 }
50937
50938
50939 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50940 PyObject *resultobj = 0;
50941 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50942 wxPoint *arg2 = 0 ;
50943 wxGBSizerItem *result = 0 ;
50944 void *argp1 = 0 ;
50945 int res1 = 0 ;
50946 wxPoint temp2 ;
50947 PyObject * obj0 = 0 ;
50948 PyObject * obj1 = 0 ;
50949 char * kwnames[] = {
50950 (char *) "self",(char *) "pt", NULL
50951 };
50952
50953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
50954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50955 if (!SWIG_IsOK(res1)) {
50956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50957 }
50958 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50959 {
50960 arg2 = &temp2;
50961 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
50962 }
50963 {
50964 PyThreadState* __tstate = wxPyBeginAllowThreads();
50965 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
50966 wxPyEndAllowThreads(__tstate);
50967 if (PyErr_Occurred()) SWIG_fail;
50968 }
50969 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50970 return resultobj;
50971 fail:
50972 return NULL;
50973 }
50974
50975
50976 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50977 PyObject *resultobj = 0;
50978 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50979 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
50980 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
50981 bool result;
50982 void *argp1 = 0 ;
50983 int res1 = 0 ;
50984 void *argp2 = 0 ;
50985 int res2 = 0 ;
50986 void *argp3 = 0 ;
50987 int res3 = 0 ;
50988 PyObject * obj0 = 0 ;
50989 PyObject * obj1 = 0 ;
50990 PyObject * obj2 = 0 ;
50991 char * kwnames[] = {
50992 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
50993 };
50994
50995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50996 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50997 if (!SWIG_IsOK(res1)) {
50998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50999 }
51000 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51001 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51002 if (!SWIG_IsOK(res2)) {
51003 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
51004 }
51005 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
51006 if (obj2) {
51007 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51008 if (!SWIG_IsOK(res3)) {
51009 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
51010 }
51011 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
51012 }
51013 {
51014 PyThreadState* __tstate = wxPyBeginAllowThreads();
51015 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
51016 wxPyEndAllowThreads(__tstate);
51017 if (PyErr_Occurred()) SWIG_fail;
51018 }
51019 {
51020 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51021 }
51022 return resultobj;
51023 fail:
51024 return NULL;
51025 }
51026
51027
51028 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51029 PyObject *resultobj = 0;
51030 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51031 wxGBPosition *arg2 = 0 ;
51032 wxGBSpan *arg3 = 0 ;
51033 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
51034 bool result;
51035 void *argp1 = 0 ;
51036 int res1 = 0 ;
51037 wxGBPosition temp2 ;
51038 wxGBSpan temp3 ;
51039 void *argp4 = 0 ;
51040 int res4 = 0 ;
51041 PyObject * obj0 = 0 ;
51042 PyObject * obj1 = 0 ;
51043 PyObject * obj2 = 0 ;
51044 PyObject * obj3 = 0 ;
51045 char * kwnames[] = {
51046 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
51047 };
51048
51049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51050 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51051 if (!SWIG_IsOK(res1)) {
51052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51053 }
51054 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51055 {
51056 arg2 = &temp2;
51057 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51058 }
51059 {
51060 arg3 = &temp3;
51061 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
51062 }
51063 if (obj3) {
51064 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51065 if (!SWIG_IsOK(res4)) {
51066 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
51067 }
51068 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
51069 }
51070 {
51071 PyThreadState* __tstate = wxPyBeginAllowThreads();
51072 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
51073 wxPyEndAllowThreads(__tstate);
51074 if (PyErr_Occurred()) SWIG_fail;
51075 }
51076 {
51077 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51078 }
51079 return resultobj;
51080 fail:
51081 return NULL;
51082 }
51083
51084
51085 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51086 PyObject *obj;
51087 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51088 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
51089 return SWIG_Py_Void();
51090 }
51091
51092 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51093 return SWIG_Python_InitShadowInstance(args);
51094 }
51095
51096 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51097 PyObject *resultobj = 0;
51098 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51099 wxRelationship arg2 ;
51100 wxWindow *arg3 = (wxWindow *) 0 ;
51101 wxEdge arg4 ;
51102 int arg5 = (int) 0 ;
51103 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
51104 void *argp1 = 0 ;
51105 int res1 = 0 ;
51106 int val2 ;
51107 int ecode2 = 0 ;
51108 void *argp3 = 0 ;
51109 int res3 = 0 ;
51110 int val4 ;
51111 int ecode4 = 0 ;
51112 int val5 ;
51113 int ecode5 = 0 ;
51114 int val6 ;
51115 int ecode6 = 0 ;
51116 PyObject * obj0 = 0 ;
51117 PyObject * obj1 = 0 ;
51118 PyObject * obj2 = 0 ;
51119 PyObject * obj3 = 0 ;
51120 PyObject * obj4 = 0 ;
51121 PyObject * obj5 = 0 ;
51122 char * kwnames[] = {
51123 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
51124 };
51125
51126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
51127 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51128 if (!SWIG_IsOK(res1)) {
51129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51130 }
51131 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51132 ecode2 = SWIG_AsVal_int(obj1, &val2);
51133 if (!SWIG_IsOK(ecode2)) {
51134 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
51135 }
51136 arg2 = static_cast< wxRelationship >(val2);
51137 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
51138 if (!SWIG_IsOK(res3)) {
51139 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
51140 }
51141 arg3 = reinterpret_cast< wxWindow * >(argp3);
51142 ecode4 = SWIG_AsVal_int(obj3, &val4);
51143 if (!SWIG_IsOK(ecode4)) {
51144 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
51145 }
51146 arg4 = static_cast< wxEdge >(val4);
51147 if (obj4) {
51148 ecode5 = SWIG_AsVal_int(obj4, &val5);
51149 if (!SWIG_IsOK(ecode5)) {
51150 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
51151 }
51152 arg5 = static_cast< int >(val5);
51153 }
51154 if (obj5) {
51155 ecode6 = SWIG_AsVal_int(obj5, &val6);
51156 if (!SWIG_IsOK(ecode6)) {
51157 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
51158 }
51159 arg6 = static_cast< int >(val6);
51160 }
51161 {
51162 PyThreadState* __tstate = wxPyBeginAllowThreads();
51163 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
51164 wxPyEndAllowThreads(__tstate);
51165 if (PyErr_Occurred()) SWIG_fail;
51166 }
51167 resultobj = SWIG_Py_Void();
51168 return resultobj;
51169 fail:
51170 return NULL;
51171 }
51172
51173
51174 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51175 PyObject *resultobj = 0;
51176 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51177 wxWindow *arg2 = (wxWindow *) 0 ;
51178 int arg3 = (int) 0 ;
51179 void *argp1 = 0 ;
51180 int res1 = 0 ;
51181 void *argp2 = 0 ;
51182 int res2 = 0 ;
51183 int val3 ;
51184 int ecode3 = 0 ;
51185 PyObject * obj0 = 0 ;
51186 PyObject * obj1 = 0 ;
51187 PyObject * obj2 = 0 ;
51188 char * kwnames[] = {
51189 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51190 };
51191
51192 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51193 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51194 if (!SWIG_IsOK(res1)) {
51195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51196 }
51197 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51198 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51199 if (!SWIG_IsOK(res2)) {
51200 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51201 }
51202 arg2 = reinterpret_cast< wxWindow * >(argp2);
51203 if (obj2) {
51204 ecode3 = SWIG_AsVal_int(obj2, &val3);
51205 if (!SWIG_IsOK(ecode3)) {
51206 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
51207 }
51208 arg3 = static_cast< int >(val3);
51209 }
51210 {
51211 PyThreadState* __tstate = wxPyBeginAllowThreads();
51212 (arg1)->LeftOf(arg2,arg3);
51213 wxPyEndAllowThreads(__tstate);
51214 if (PyErr_Occurred()) SWIG_fail;
51215 }
51216 resultobj = SWIG_Py_Void();
51217 return resultobj;
51218 fail:
51219 return NULL;
51220 }
51221
51222
51223 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51224 PyObject *resultobj = 0;
51225 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51226 wxWindow *arg2 = (wxWindow *) 0 ;
51227 int arg3 = (int) 0 ;
51228 void *argp1 = 0 ;
51229 int res1 = 0 ;
51230 void *argp2 = 0 ;
51231 int res2 = 0 ;
51232 int val3 ;
51233 int ecode3 = 0 ;
51234 PyObject * obj0 = 0 ;
51235 PyObject * obj1 = 0 ;
51236 PyObject * obj2 = 0 ;
51237 char * kwnames[] = {
51238 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51239 };
51240
51241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51243 if (!SWIG_IsOK(res1)) {
51244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51245 }
51246 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51247 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51248 if (!SWIG_IsOK(res2)) {
51249 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51250 }
51251 arg2 = reinterpret_cast< wxWindow * >(argp2);
51252 if (obj2) {
51253 ecode3 = SWIG_AsVal_int(obj2, &val3);
51254 if (!SWIG_IsOK(ecode3)) {
51255 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
51256 }
51257 arg3 = static_cast< int >(val3);
51258 }
51259 {
51260 PyThreadState* __tstate = wxPyBeginAllowThreads();
51261 (arg1)->RightOf(arg2,arg3);
51262 wxPyEndAllowThreads(__tstate);
51263 if (PyErr_Occurred()) SWIG_fail;
51264 }
51265 resultobj = SWIG_Py_Void();
51266 return resultobj;
51267 fail:
51268 return NULL;
51269 }
51270
51271
51272 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51273 PyObject *resultobj = 0;
51274 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51275 wxWindow *arg2 = (wxWindow *) 0 ;
51276 int arg3 = (int) 0 ;
51277 void *argp1 = 0 ;
51278 int res1 = 0 ;
51279 void *argp2 = 0 ;
51280 int res2 = 0 ;
51281 int val3 ;
51282 int ecode3 = 0 ;
51283 PyObject * obj0 = 0 ;
51284 PyObject * obj1 = 0 ;
51285 PyObject * obj2 = 0 ;
51286 char * kwnames[] = {
51287 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51288 };
51289
51290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51292 if (!SWIG_IsOK(res1)) {
51293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51294 }
51295 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51296 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51297 if (!SWIG_IsOK(res2)) {
51298 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
51299 }
51300 arg2 = reinterpret_cast< wxWindow * >(argp2);
51301 if (obj2) {
51302 ecode3 = SWIG_AsVal_int(obj2, &val3);
51303 if (!SWIG_IsOK(ecode3)) {
51304 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
51305 }
51306 arg3 = static_cast< int >(val3);
51307 }
51308 {
51309 PyThreadState* __tstate = wxPyBeginAllowThreads();
51310 (arg1)->Above(arg2,arg3);
51311 wxPyEndAllowThreads(__tstate);
51312 if (PyErr_Occurred()) SWIG_fail;
51313 }
51314 resultobj = SWIG_Py_Void();
51315 return resultobj;
51316 fail:
51317 return NULL;
51318 }
51319
51320
51321 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51322 PyObject *resultobj = 0;
51323 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51324 wxWindow *arg2 = (wxWindow *) 0 ;
51325 int arg3 = (int) 0 ;
51326 void *argp1 = 0 ;
51327 int res1 = 0 ;
51328 void *argp2 = 0 ;
51329 int res2 = 0 ;
51330 int val3 ;
51331 int ecode3 = 0 ;
51332 PyObject * obj0 = 0 ;
51333 PyObject * obj1 = 0 ;
51334 PyObject * obj2 = 0 ;
51335 char * kwnames[] = {
51336 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51337 };
51338
51339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51340 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51341 if (!SWIG_IsOK(res1)) {
51342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51343 }
51344 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51345 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51346 if (!SWIG_IsOK(res2)) {
51347 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
51348 }
51349 arg2 = reinterpret_cast< wxWindow * >(argp2);
51350 if (obj2) {
51351 ecode3 = SWIG_AsVal_int(obj2, &val3);
51352 if (!SWIG_IsOK(ecode3)) {
51353 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
51354 }
51355 arg3 = static_cast< int >(val3);
51356 }
51357 {
51358 PyThreadState* __tstate = wxPyBeginAllowThreads();
51359 (arg1)->Below(arg2,arg3);
51360 wxPyEndAllowThreads(__tstate);
51361 if (PyErr_Occurred()) SWIG_fail;
51362 }
51363 resultobj = SWIG_Py_Void();
51364 return resultobj;
51365 fail:
51366 return NULL;
51367 }
51368
51369
51370 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51371 PyObject *resultobj = 0;
51372 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51373 wxWindow *arg2 = (wxWindow *) 0 ;
51374 wxEdge arg3 ;
51375 int arg4 = (int) 0 ;
51376 void *argp1 = 0 ;
51377 int res1 = 0 ;
51378 void *argp2 = 0 ;
51379 int res2 = 0 ;
51380 int val3 ;
51381 int ecode3 = 0 ;
51382 int val4 ;
51383 int ecode4 = 0 ;
51384 PyObject * obj0 = 0 ;
51385 PyObject * obj1 = 0 ;
51386 PyObject * obj2 = 0 ;
51387 PyObject * obj3 = 0 ;
51388 char * kwnames[] = {
51389 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
51390 };
51391
51392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51393 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51394 if (!SWIG_IsOK(res1)) {
51395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51396 }
51397 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51398 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51399 if (!SWIG_IsOK(res2)) {
51400 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
51401 }
51402 arg2 = reinterpret_cast< wxWindow * >(argp2);
51403 ecode3 = SWIG_AsVal_int(obj2, &val3);
51404 if (!SWIG_IsOK(ecode3)) {
51405 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
51406 }
51407 arg3 = static_cast< wxEdge >(val3);
51408 if (obj3) {
51409 ecode4 = SWIG_AsVal_int(obj3, &val4);
51410 if (!SWIG_IsOK(ecode4)) {
51411 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
51412 }
51413 arg4 = static_cast< int >(val4);
51414 }
51415 {
51416 PyThreadState* __tstate = wxPyBeginAllowThreads();
51417 (arg1)->SameAs(arg2,arg3,arg4);
51418 wxPyEndAllowThreads(__tstate);
51419 if (PyErr_Occurred()) SWIG_fail;
51420 }
51421 resultobj = SWIG_Py_Void();
51422 return resultobj;
51423 fail:
51424 return NULL;
51425 }
51426
51427
51428 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51429 PyObject *resultobj = 0;
51430 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51431 wxWindow *arg2 = (wxWindow *) 0 ;
51432 wxEdge arg3 ;
51433 int arg4 ;
51434 void *argp1 = 0 ;
51435 int res1 = 0 ;
51436 void *argp2 = 0 ;
51437 int res2 = 0 ;
51438 int val3 ;
51439 int ecode3 = 0 ;
51440 int val4 ;
51441 int ecode4 = 0 ;
51442 PyObject * obj0 = 0 ;
51443 PyObject * obj1 = 0 ;
51444 PyObject * obj2 = 0 ;
51445 PyObject * obj3 = 0 ;
51446 char * kwnames[] = {
51447 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
51448 };
51449
51450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51451 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51452 if (!SWIG_IsOK(res1)) {
51453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51454 }
51455 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51456 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51457 if (!SWIG_IsOK(res2)) {
51458 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51459 }
51460 arg2 = reinterpret_cast< wxWindow * >(argp2);
51461 ecode3 = SWIG_AsVal_int(obj2, &val3);
51462 if (!SWIG_IsOK(ecode3)) {
51463 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
51464 }
51465 arg3 = static_cast< wxEdge >(val3);
51466 ecode4 = SWIG_AsVal_int(obj3, &val4);
51467 if (!SWIG_IsOK(ecode4)) {
51468 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
51469 }
51470 arg4 = static_cast< int >(val4);
51471 {
51472 PyThreadState* __tstate = wxPyBeginAllowThreads();
51473 (arg1)->PercentOf(arg2,arg3,arg4);
51474 wxPyEndAllowThreads(__tstate);
51475 if (PyErr_Occurred()) SWIG_fail;
51476 }
51477 resultobj = SWIG_Py_Void();
51478 return resultobj;
51479 fail:
51480 return NULL;
51481 }
51482
51483
51484 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51485 PyObject *resultobj = 0;
51486 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51487 int arg2 ;
51488 void *argp1 = 0 ;
51489 int res1 = 0 ;
51490 int val2 ;
51491 int ecode2 = 0 ;
51492 PyObject * obj0 = 0 ;
51493 PyObject * obj1 = 0 ;
51494 char * kwnames[] = {
51495 (char *) "self",(char *) "val", NULL
51496 };
51497
51498 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
51499 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51500 if (!SWIG_IsOK(res1)) {
51501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51502 }
51503 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51504 ecode2 = SWIG_AsVal_int(obj1, &val2);
51505 if (!SWIG_IsOK(ecode2)) {
51506 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
51507 }
51508 arg2 = static_cast< int >(val2);
51509 {
51510 PyThreadState* __tstate = wxPyBeginAllowThreads();
51511 (arg1)->Absolute(arg2);
51512 wxPyEndAllowThreads(__tstate);
51513 if (PyErr_Occurred()) SWIG_fail;
51514 }
51515 resultobj = SWIG_Py_Void();
51516 return resultobj;
51517 fail:
51518 return NULL;
51519 }
51520
51521
51522 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51523 PyObject *resultobj = 0;
51524 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51525 void *argp1 = 0 ;
51526 int res1 = 0 ;
51527 PyObject *swig_obj[1] ;
51528
51529 if (!args) SWIG_fail;
51530 swig_obj[0] = args;
51531 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51532 if (!SWIG_IsOK(res1)) {
51533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51534 }
51535 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51536 {
51537 PyThreadState* __tstate = wxPyBeginAllowThreads();
51538 (arg1)->Unconstrained();
51539 wxPyEndAllowThreads(__tstate);
51540 if (PyErr_Occurred()) SWIG_fail;
51541 }
51542 resultobj = SWIG_Py_Void();
51543 return resultobj;
51544 fail:
51545 return NULL;
51546 }
51547
51548
51549 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51550 PyObject *resultobj = 0;
51551 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51552 void *argp1 = 0 ;
51553 int res1 = 0 ;
51554 PyObject *swig_obj[1] ;
51555
51556 if (!args) SWIG_fail;
51557 swig_obj[0] = args;
51558 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51559 if (!SWIG_IsOK(res1)) {
51560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51561 }
51562 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51563 {
51564 PyThreadState* __tstate = wxPyBeginAllowThreads();
51565 (arg1)->AsIs();
51566 wxPyEndAllowThreads(__tstate);
51567 if (PyErr_Occurred()) SWIG_fail;
51568 }
51569 resultobj = SWIG_Py_Void();
51570 return resultobj;
51571 fail:
51572 return NULL;
51573 }
51574
51575
51576 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51577 PyObject *resultobj = 0;
51578 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51579 wxWindow *result = 0 ;
51580 void *argp1 = 0 ;
51581 int res1 = 0 ;
51582 PyObject *swig_obj[1] ;
51583
51584 if (!args) SWIG_fail;
51585 swig_obj[0] = args;
51586 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51587 if (!SWIG_IsOK(res1)) {
51588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51589 }
51590 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51591 {
51592 PyThreadState* __tstate = wxPyBeginAllowThreads();
51593 result = (wxWindow *)(arg1)->GetOtherWindow();
51594 wxPyEndAllowThreads(__tstate);
51595 if (PyErr_Occurred()) SWIG_fail;
51596 }
51597 {
51598 resultobj = wxPyMake_wxObject(result, 0);
51599 }
51600 return resultobj;
51601 fail:
51602 return NULL;
51603 }
51604
51605
51606 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51607 PyObject *resultobj = 0;
51608 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51609 wxEdge result;
51610 void *argp1 = 0 ;
51611 int res1 = 0 ;
51612 PyObject *swig_obj[1] ;
51613
51614 if (!args) SWIG_fail;
51615 swig_obj[0] = args;
51616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51617 if (!SWIG_IsOK(res1)) {
51618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51619 }
51620 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51621 {
51622 PyThreadState* __tstate = wxPyBeginAllowThreads();
51623 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
51624 wxPyEndAllowThreads(__tstate);
51625 if (PyErr_Occurred()) SWIG_fail;
51626 }
51627 resultobj = SWIG_From_int(static_cast< int >(result));
51628 return resultobj;
51629 fail:
51630 return NULL;
51631 }
51632
51633
51634 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51635 PyObject *resultobj = 0;
51636 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51637 wxEdge arg2 ;
51638 void *argp1 = 0 ;
51639 int res1 = 0 ;
51640 int val2 ;
51641 int ecode2 = 0 ;
51642 PyObject * obj0 = 0 ;
51643 PyObject * obj1 = 0 ;
51644 char * kwnames[] = {
51645 (char *) "self",(char *) "which", NULL
51646 };
51647
51648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
51649 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51650 if (!SWIG_IsOK(res1)) {
51651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51652 }
51653 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51654 ecode2 = SWIG_AsVal_int(obj1, &val2);
51655 if (!SWIG_IsOK(ecode2)) {
51656 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
51657 }
51658 arg2 = static_cast< wxEdge >(val2);
51659 {
51660 PyThreadState* __tstate = wxPyBeginAllowThreads();
51661 (arg1)->SetEdge(arg2);
51662 wxPyEndAllowThreads(__tstate);
51663 if (PyErr_Occurred()) SWIG_fail;
51664 }
51665 resultobj = SWIG_Py_Void();
51666 return resultobj;
51667 fail:
51668 return NULL;
51669 }
51670
51671
51672 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51673 PyObject *resultobj = 0;
51674 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51675 int arg2 ;
51676 void *argp1 = 0 ;
51677 int res1 = 0 ;
51678 int val2 ;
51679 int ecode2 = 0 ;
51680 PyObject * obj0 = 0 ;
51681 PyObject * obj1 = 0 ;
51682 char * kwnames[] = {
51683 (char *) "self",(char *) "v", NULL
51684 };
51685
51686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
51687 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51688 if (!SWIG_IsOK(res1)) {
51689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51690 }
51691 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51692 ecode2 = SWIG_AsVal_int(obj1, &val2);
51693 if (!SWIG_IsOK(ecode2)) {
51694 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
51695 }
51696 arg2 = static_cast< int >(val2);
51697 {
51698 PyThreadState* __tstate = wxPyBeginAllowThreads();
51699 (arg1)->SetValue(arg2);
51700 wxPyEndAllowThreads(__tstate);
51701 if (PyErr_Occurred()) SWIG_fail;
51702 }
51703 resultobj = SWIG_Py_Void();
51704 return resultobj;
51705 fail:
51706 return NULL;
51707 }
51708
51709
51710 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51711 PyObject *resultobj = 0;
51712 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51713 int result;
51714 void *argp1 = 0 ;
51715 int res1 = 0 ;
51716 PyObject *swig_obj[1] ;
51717
51718 if (!args) SWIG_fail;
51719 swig_obj[0] = args;
51720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51721 if (!SWIG_IsOK(res1)) {
51722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51723 }
51724 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51725 {
51726 PyThreadState* __tstate = wxPyBeginAllowThreads();
51727 result = (int)(arg1)->GetMargin();
51728 wxPyEndAllowThreads(__tstate);
51729 if (PyErr_Occurred()) SWIG_fail;
51730 }
51731 resultobj = SWIG_From_int(static_cast< int >(result));
51732 return resultobj;
51733 fail:
51734 return NULL;
51735 }
51736
51737
51738 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51739 PyObject *resultobj = 0;
51740 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51741 int arg2 ;
51742 void *argp1 = 0 ;
51743 int res1 = 0 ;
51744 int val2 ;
51745 int ecode2 = 0 ;
51746 PyObject * obj0 = 0 ;
51747 PyObject * obj1 = 0 ;
51748 char * kwnames[] = {
51749 (char *) "self",(char *) "m", NULL
51750 };
51751
51752 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
51753 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51754 if (!SWIG_IsOK(res1)) {
51755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51756 }
51757 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51758 ecode2 = SWIG_AsVal_int(obj1, &val2);
51759 if (!SWIG_IsOK(ecode2)) {
51760 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
51761 }
51762 arg2 = static_cast< int >(val2);
51763 {
51764 PyThreadState* __tstate = wxPyBeginAllowThreads();
51765 (arg1)->SetMargin(arg2);
51766 wxPyEndAllowThreads(__tstate);
51767 if (PyErr_Occurred()) SWIG_fail;
51768 }
51769 resultobj = SWIG_Py_Void();
51770 return resultobj;
51771 fail:
51772 return NULL;
51773 }
51774
51775
51776 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51777 PyObject *resultobj = 0;
51778 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51779 int result;
51780 void *argp1 = 0 ;
51781 int res1 = 0 ;
51782 PyObject *swig_obj[1] ;
51783
51784 if (!args) SWIG_fail;
51785 swig_obj[0] = args;
51786 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51787 if (!SWIG_IsOK(res1)) {
51788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51789 }
51790 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51791 {
51792 PyThreadState* __tstate = wxPyBeginAllowThreads();
51793 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
51794 wxPyEndAllowThreads(__tstate);
51795 if (PyErr_Occurred()) SWIG_fail;
51796 }
51797 resultobj = SWIG_From_int(static_cast< int >(result));
51798 return resultobj;
51799 fail:
51800 return NULL;
51801 }
51802
51803
51804 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51805 PyObject *resultobj = 0;
51806 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51807 int result;
51808 void *argp1 = 0 ;
51809 int res1 = 0 ;
51810 PyObject *swig_obj[1] ;
51811
51812 if (!args) SWIG_fail;
51813 swig_obj[0] = args;
51814 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51815 if (!SWIG_IsOK(res1)) {
51816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51817 }
51818 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51819 {
51820 PyThreadState* __tstate = wxPyBeginAllowThreads();
51821 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
51822 wxPyEndAllowThreads(__tstate);
51823 if (PyErr_Occurred()) SWIG_fail;
51824 }
51825 resultobj = SWIG_From_int(static_cast< int >(result));
51826 return resultobj;
51827 fail:
51828 return NULL;
51829 }
51830
51831
51832 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51833 PyObject *resultobj = 0;
51834 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51835 int result;
51836 void *argp1 = 0 ;
51837 int res1 = 0 ;
51838 PyObject *swig_obj[1] ;
51839
51840 if (!args) SWIG_fail;
51841 swig_obj[0] = args;
51842 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51843 if (!SWIG_IsOK(res1)) {
51844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51845 }
51846 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51847 {
51848 PyThreadState* __tstate = wxPyBeginAllowThreads();
51849 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
51850 wxPyEndAllowThreads(__tstate);
51851 if (PyErr_Occurred()) SWIG_fail;
51852 }
51853 resultobj = SWIG_From_int(static_cast< int >(result));
51854 return resultobj;
51855 fail:
51856 return NULL;
51857 }
51858
51859
51860 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51861 PyObject *resultobj = 0;
51862 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51863 bool result;
51864 void *argp1 = 0 ;
51865 int res1 = 0 ;
51866 PyObject *swig_obj[1] ;
51867
51868 if (!args) SWIG_fail;
51869 swig_obj[0] = args;
51870 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51871 if (!SWIG_IsOK(res1)) {
51872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51873 }
51874 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51875 {
51876 PyThreadState* __tstate = wxPyBeginAllowThreads();
51877 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
51878 wxPyEndAllowThreads(__tstate);
51879 if (PyErr_Occurred()) SWIG_fail;
51880 }
51881 {
51882 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51883 }
51884 return resultobj;
51885 fail:
51886 return NULL;
51887 }
51888
51889
51890 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51891 PyObject *resultobj = 0;
51892 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51893 bool arg2 ;
51894 void *argp1 = 0 ;
51895 int res1 = 0 ;
51896 bool val2 ;
51897 int ecode2 = 0 ;
51898 PyObject * obj0 = 0 ;
51899 PyObject * obj1 = 0 ;
51900 char * kwnames[] = {
51901 (char *) "self",(char *) "d", NULL
51902 };
51903
51904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
51905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51906 if (!SWIG_IsOK(res1)) {
51907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51908 }
51909 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51910 ecode2 = SWIG_AsVal_bool(obj1, &val2);
51911 if (!SWIG_IsOK(ecode2)) {
51912 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
51913 }
51914 arg2 = static_cast< bool >(val2);
51915 {
51916 PyThreadState* __tstate = wxPyBeginAllowThreads();
51917 (arg1)->SetDone(arg2);
51918 wxPyEndAllowThreads(__tstate);
51919 if (PyErr_Occurred()) SWIG_fail;
51920 }
51921 resultobj = SWIG_Py_Void();
51922 return resultobj;
51923 fail:
51924 return NULL;
51925 }
51926
51927
51928 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51929 PyObject *resultobj = 0;
51930 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51931 wxRelationship result;
51932 void *argp1 = 0 ;
51933 int res1 = 0 ;
51934 PyObject *swig_obj[1] ;
51935
51936 if (!args) SWIG_fail;
51937 swig_obj[0] = args;
51938 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51939 if (!SWIG_IsOK(res1)) {
51940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51941 }
51942 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51943 {
51944 PyThreadState* __tstate = wxPyBeginAllowThreads();
51945 result = (wxRelationship)(arg1)->GetRelationship();
51946 wxPyEndAllowThreads(__tstate);
51947 if (PyErr_Occurred()) SWIG_fail;
51948 }
51949 resultobj = SWIG_From_int(static_cast< int >(result));
51950 return resultobj;
51951 fail:
51952 return NULL;
51953 }
51954
51955
51956 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51957 PyObject *resultobj = 0;
51958 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51959 wxRelationship arg2 ;
51960 void *argp1 = 0 ;
51961 int res1 = 0 ;
51962 int val2 ;
51963 int ecode2 = 0 ;
51964 PyObject * obj0 = 0 ;
51965 PyObject * obj1 = 0 ;
51966 char * kwnames[] = {
51967 (char *) "self",(char *) "r", NULL
51968 };
51969
51970 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
51971 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51972 if (!SWIG_IsOK(res1)) {
51973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51974 }
51975 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51976 ecode2 = SWIG_AsVal_int(obj1, &val2);
51977 if (!SWIG_IsOK(ecode2)) {
51978 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
51979 }
51980 arg2 = static_cast< wxRelationship >(val2);
51981 {
51982 PyThreadState* __tstate = wxPyBeginAllowThreads();
51983 (arg1)->SetRelationship(arg2);
51984 wxPyEndAllowThreads(__tstate);
51985 if (PyErr_Occurred()) SWIG_fail;
51986 }
51987 resultobj = SWIG_Py_Void();
51988 return resultobj;
51989 fail:
51990 return NULL;
51991 }
51992
51993
51994 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51995 PyObject *resultobj = 0;
51996 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51997 wxWindow *arg2 = (wxWindow *) 0 ;
51998 bool result;
51999 void *argp1 = 0 ;
52000 int res1 = 0 ;
52001 void *argp2 = 0 ;
52002 int res2 = 0 ;
52003 PyObject * obj0 = 0 ;
52004 PyObject * obj1 = 0 ;
52005 char * kwnames[] = {
52006 (char *) "self",(char *) "otherW", NULL
52007 };
52008
52009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
52010 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52011 if (!SWIG_IsOK(res1)) {
52012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52013 }
52014 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52015 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52016 if (!SWIG_IsOK(res2)) {
52017 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
52018 }
52019 arg2 = reinterpret_cast< wxWindow * >(argp2);
52020 {
52021 PyThreadState* __tstate = wxPyBeginAllowThreads();
52022 result = (bool)(arg1)->ResetIfWin(arg2);
52023 wxPyEndAllowThreads(__tstate);
52024 if (PyErr_Occurred()) SWIG_fail;
52025 }
52026 {
52027 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52028 }
52029 return resultobj;
52030 fail:
52031 return NULL;
52032 }
52033
52034
52035 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52036 PyObject *resultobj = 0;
52037 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52038 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
52039 wxWindow *arg3 = (wxWindow *) 0 ;
52040 bool result;
52041 void *argp1 = 0 ;
52042 int res1 = 0 ;
52043 void *argp2 = 0 ;
52044 int res2 = 0 ;
52045 void *argp3 = 0 ;
52046 int res3 = 0 ;
52047 PyObject * obj0 = 0 ;
52048 PyObject * obj1 = 0 ;
52049 PyObject * obj2 = 0 ;
52050 char * kwnames[] = {
52051 (char *) "self",(char *) "constraints",(char *) "win", NULL
52052 };
52053
52054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52055 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52056 if (!SWIG_IsOK(res1)) {
52057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52058 }
52059 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52060 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52061 if (!SWIG_IsOK(res2)) {
52062 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
52063 }
52064 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
52065 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52066 if (!SWIG_IsOK(res3)) {
52067 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
52068 }
52069 arg3 = reinterpret_cast< wxWindow * >(argp3);
52070 {
52071 PyThreadState* __tstate = wxPyBeginAllowThreads();
52072 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
52073 wxPyEndAllowThreads(__tstate);
52074 if (PyErr_Occurred()) SWIG_fail;
52075 }
52076 {
52077 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52078 }
52079 return resultobj;
52080 fail:
52081 return NULL;
52082 }
52083
52084
52085 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52086 PyObject *resultobj = 0;
52087 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52088 wxEdge arg2 ;
52089 wxWindow *arg3 = (wxWindow *) 0 ;
52090 wxWindow *arg4 = (wxWindow *) 0 ;
52091 int result;
52092 void *argp1 = 0 ;
52093 int res1 = 0 ;
52094 int val2 ;
52095 int ecode2 = 0 ;
52096 void *argp3 = 0 ;
52097 int res3 = 0 ;
52098 void *argp4 = 0 ;
52099 int res4 = 0 ;
52100 PyObject * obj0 = 0 ;
52101 PyObject * obj1 = 0 ;
52102 PyObject * obj2 = 0 ;
52103 PyObject * obj3 = 0 ;
52104 char * kwnames[] = {
52105 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
52106 };
52107
52108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52110 if (!SWIG_IsOK(res1)) {
52111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52112 }
52113 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52114 ecode2 = SWIG_AsVal_int(obj1, &val2);
52115 if (!SWIG_IsOK(ecode2)) {
52116 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
52117 }
52118 arg2 = static_cast< wxEdge >(val2);
52119 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52120 if (!SWIG_IsOK(res3)) {
52121 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
52122 }
52123 arg3 = reinterpret_cast< wxWindow * >(argp3);
52124 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
52125 if (!SWIG_IsOK(res4)) {
52126 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
52127 }
52128 arg4 = reinterpret_cast< wxWindow * >(argp4);
52129 {
52130 PyThreadState* __tstate = wxPyBeginAllowThreads();
52131 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
52132 wxPyEndAllowThreads(__tstate);
52133 if (PyErr_Occurred()) SWIG_fail;
52134 }
52135 resultobj = SWIG_From_int(static_cast< int >(result));
52136 return resultobj;
52137 fail:
52138 return NULL;
52139 }
52140
52141
52142 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52143 PyObject *obj;
52144 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52145 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
52146 return SWIG_Py_Void();
52147 }
52148
52149 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52150 PyObject *resultobj = 0;
52151 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52152 wxIndividualLayoutConstraint *result = 0 ;
52153 void *argp1 = 0 ;
52154 int res1 = 0 ;
52155 PyObject *swig_obj[1] ;
52156
52157 if (!args) SWIG_fail;
52158 swig_obj[0] = args;
52159 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52160 if (!SWIG_IsOK(res1)) {
52161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52162 }
52163 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52164 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
52165 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52166 return resultobj;
52167 fail:
52168 return NULL;
52169 }
52170
52171
52172 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52173 PyObject *resultobj = 0;
52174 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52175 wxIndividualLayoutConstraint *result = 0 ;
52176 void *argp1 = 0 ;
52177 int res1 = 0 ;
52178 PyObject *swig_obj[1] ;
52179
52180 if (!args) SWIG_fail;
52181 swig_obj[0] = args;
52182 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52183 if (!SWIG_IsOK(res1)) {
52184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52185 }
52186 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52187 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
52188 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52189 return resultobj;
52190 fail:
52191 return NULL;
52192 }
52193
52194
52195 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52196 PyObject *resultobj = 0;
52197 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52198 wxIndividualLayoutConstraint *result = 0 ;
52199 void *argp1 = 0 ;
52200 int res1 = 0 ;
52201 PyObject *swig_obj[1] ;
52202
52203 if (!args) SWIG_fail;
52204 swig_obj[0] = args;
52205 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52206 if (!SWIG_IsOK(res1)) {
52207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52208 }
52209 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52210 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
52211 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52212 return resultobj;
52213 fail:
52214 return NULL;
52215 }
52216
52217
52218 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52219 PyObject *resultobj = 0;
52220 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52221 wxIndividualLayoutConstraint *result = 0 ;
52222 void *argp1 = 0 ;
52223 int res1 = 0 ;
52224 PyObject *swig_obj[1] ;
52225
52226 if (!args) SWIG_fail;
52227 swig_obj[0] = args;
52228 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52229 if (!SWIG_IsOK(res1)) {
52230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52231 }
52232 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52233 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
52234 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52235 return resultobj;
52236 fail:
52237 return NULL;
52238 }
52239
52240
52241 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52242 PyObject *resultobj = 0;
52243 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52244 wxIndividualLayoutConstraint *result = 0 ;
52245 void *argp1 = 0 ;
52246 int res1 = 0 ;
52247 PyObject *swig_obj[1] ;
52248
52249 if (!args) SWIG_fail;
52250 swig_obj[0] = args;
52251 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52252 if (!SWIG_IsOK(res1)) {
52253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52254 }
52255 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52256 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
52257 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52258 return resultobj;
52259 fail:
52260 return NULL;
52261 }
52262
52263
52264 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52265 PyObject *resultobj = 0;
52266 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52267 wxIndividualLayoutConstraint *result = 0 ;
52268 void *argp1 = 0 ;
52269 int res1 = 0 ;
52270 PyObject *swig_obj[1] ;
52271
52272 if (!args) SWIG_fail;
52273 swig_obj[0] = args;
52274 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52275 if (!SWIG_IsOK(res1)) {
52276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52277 }
52278 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52279 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
52280 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52281 return resultobj;
52282 fail:
52283 return NULL;
52284 }
52285
52286
52287 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52288 PyObject *resultobj = 0;
52289 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52290 wxIndividualLayoutConstraint *result = 0 ;
52291 void *argp1 = 0 ;
52292 int res1 = 0 ;
52293 PyObject *swig_obj[1] ;
52294
52295 if (!args) SWIG_fail;
52296 swig_obj[0] = args;
52297 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52298 if (!SWIG_IsOK(res1)) {
52299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52300 }
52301 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52302 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
52303 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52304 return resultobj;
52305 fail:
52306 return NULL;
52307 }
52308
52309
52310 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52311 PyObject *resultobj = 0;
52312 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52313 wxIndividualLayoutConstraint *result = 0 ;
52314 void *argp1 = 0 ;
52315 int res1 = 0 ;
52316 PyObject *swig_obj[1] ;
52317
52318 if (!args) SWIG_fail;
52319 swig_obj[0] = args;
52320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52321 if (!SWIG_IsOK(res1)) {
52322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52323 }
52324 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52325 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
52326 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52327 return resultobj;
52328 fail:
52329 return NULL;
52330 }
52331
52332
52333 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52334 PyObject *resultobj = 0;
52335 wxLayoutConstraints *result = 0 ;
52336
52337 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
52338 {
52339 PyThreadState* __tstate = wxPyBeginAllowThreads();
52340 result = (wxLayoutConstraints *)new wxLayoutConstraints();
52341 wxPyEndAllowThreads(__tstate);
52342 if (PyErr_Occurred()) SWIG_fail;
52343 }
52344 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
52345 return resultobj;
52346 fail:
52347 return NULL;
52348 }
52349
52350
52351 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52352 PyObject *resultobj = 0;
52353 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52354 void *argp1 = 0 ;
52355 int res1 = 0 ;
52356 PyObject *swig_obj[1] ;
52357
52358 if (!args) SWIG_fail;
52359 swig_obj[0] = args;
52360 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
52361 if (!SWIG_IsOK(res1)) {
52362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52363 }
52364 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52365 {
52366 PyThreadState* __tstate = wxPyBeginAllowThreads();
52367 delete arg1;
52368
52369 wxPyEndAllowThreads(__tstate);
52370 if (PyErr_Occurred()) SWIG_fail;
52371 }
52372 resultobj = SWIG_Py_Void();
52373 return resultobj;
52374 fail:
52375 return NULL;
52376 }
52377
52378
52379 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52380 PyObject *resultobj = 0;
52381 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52382 wxWindow *arg2 = (wxWindow *) 0 ;
52383 int *arg3 = (int *) 0 ;
52384 bool result;
52385 void *argp1 = 0 ;
52386 int res1 = 0 ;
52387 void *argp2 = 0 ;
52388 int res2 = 0 ;
52389 int temp3 ;
52390 int res3 = SWIG_TMPOBJ ;
52391 PyObject * obj0 = 0 ;
52392 PyObject * obj1 = 0 ;
52393 char * kwnames[] = {
52394 (char *) "self",(char *) "win", NULL
52395 };
52396
52397 arg3 = &temp3;
52398 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
52399 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52400 if (!SWIG_IsOK(res1)) {
52401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52402 }
52403 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52404 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52405 if (!SWIG_IsOK(res2)) {
52406 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
52407 }
52408 arg2 = reinterpret_cast< wxWindow * >(argp2);
52409 {
52410 PyThreadState* __tstate = wxPyBeginAllowThreads();
52411 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
52412 wxPyEndAllowThreads(__tstate);
52413 if (PyErr_Occurred()) SWIG_fail;
52414 }
52415 {
52416 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52417 }
52418 if (SWIG_IsTmpObj(res3)) {
52419 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
52420 } else {
52421 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
52422 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
52423 }
52424 return resultobj;
52425 fail:
52426 return NULL;
52427 }
52428
52429
52430 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52431 PyObject *resultobj = 0;
52432 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52433 bool result;
52434 void *argp1 = 0 ;
52435 int res1 = 0 ;
52436 PyObject *swig_obj[1] ;
52437
52438 if (!args) SWIG_fail;
52439 swig_obj[0] = args;
52440 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52441 if (!SWIG_IsOK(res1)) {
52442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
52443 }
52444 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52445 {
52446 PyThreadState* __tstate = wxPyBeginAllowThreads();
52447 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
52448 wxPyEndAllowThreads(__tstate);
52449 if (PyErr_Occurred()) SWIG_fail;
52450 }
52451 {
52452 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52453 }
52454 return resultobj;
52455 fail:
52456 return NULL;
52457 }
52458
52459
52460 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52461 PyObject *obj;
52462 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52463 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
52464 return SWIG_Py_Void();
52465 }
52466
52467 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52468 return SWIG_Python_InitShadowInstance(args);
52469 }
52470
52471 static PyMethodDef SwigMethods[] = {
52472 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
52473 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
52474 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
52475 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
52476 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
52477 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
52478 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
52479 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
52480 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
52481 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
52482 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52483 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52484 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52485 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52486 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
52487 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
52488 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52489 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
52490 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
52491 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
52492 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
52493 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
52494 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
52495 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
52496 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
52497 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
52498 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
52499 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
52500 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
52501 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
52502 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
52503 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
52504 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52505 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52506 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52507 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52508 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52509 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
52510 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
52511 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
52512 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
52513 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
52514 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
52515 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
52516 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
52517 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
52518 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52519 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52520 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52521 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52522 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52523 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
52524 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52525 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
52526 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
52527 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
52528 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
52529 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
52530 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
52531 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
52532 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
52533 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
52534 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
52535 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
52536 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
52537 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
52538 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
52539 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
52540 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
52541 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
52542 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52543 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
52544 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
52545 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
52546 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
52547 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
52548 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
52549 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
52550 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
52551 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
52552 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
52553 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
52554 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
52555 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
52556 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
52557 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
52558 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
52559 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
52560 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
52561 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
52562 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
52563 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
52564 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52565 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52566 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52567 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52568 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
52569 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
52570 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
52571 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
52572 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
52573 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
52574 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
52575 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
52576 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
52577 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
52578 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
52579 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
52580 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52581 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
52582 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
52583 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
52584 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
52585 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
52586 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
52587 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
52588 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
52589 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
52590 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
52591 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
52592 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
52593 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
52594 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
52595 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
52596 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
52597 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
52598 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
52599 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52600 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
52601 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
52602 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
52603 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52604 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52605 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
52606 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
52607 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
52608 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
52609 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52610 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
52611 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
52612 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
52613 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
52614 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
52615 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
52616 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
52617 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
52618 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
52619 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
52620 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
52621 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
52622 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
52623 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
52624 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
52625 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
52626 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
52627 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
52628 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
52629 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
52630 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
52631 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
52632 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
52633 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
52634 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
52635 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
52636 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
52637 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
52638 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
52639 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
52640 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
52641 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
52642 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
52643 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
52644 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
52645 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
52646 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
52647 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
52648 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
52649 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52650 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52651 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52652 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
52653 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
52654 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
52655 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
52656 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
52657 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
52658 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
52659 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
52660 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
52661 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
52662 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
52663 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
52664 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52665 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52666 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
52667 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52668 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
52669 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
52670 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
52671 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
52672 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
52673 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
52674 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52675 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52676 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
52677 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
52678 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
52679 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52680 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52681 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52682 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
52683 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
52684 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
52685 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
52686 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52687 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
52688 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
52689 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
52690 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52691 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52692 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52693 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
52694 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
52695 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
52696 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
52697 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
52698 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
52699 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
52700 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
52701 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
52702 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
52703 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
52704 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
52705 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
52706 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
52707 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
52708 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
52709 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
52710 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
52711 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
52712 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
52713 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
52714 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
52715 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
52716 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
52717 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
52718 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
52719 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
52720 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
52721 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
52722 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
52723 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
52724 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
52725 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
52726 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
52727 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
52728 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
52729 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
52730 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
52731 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
52732 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
52733 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
52734 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
52735 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
52736 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
52737 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
52738 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
52739 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
52740 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
52741 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
52742 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52743 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
52744 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52745 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
52746 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
52747 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
52748 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
52749 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
52750 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
52751 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
52752 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
52753 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
52754 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
52755 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
52756 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52757 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52758 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
52759 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
52760 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
52761 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
52762 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
52763 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52764 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
52765 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
52766 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
52767 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
52768 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
52769 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
52770 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
52771 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
52772 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
52773 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
52774 { (char *)"Image_Ok", (PyCFunction)_wrap_Image_Ok, METH_O, NULL},
52775 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
52776 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
52777 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
52778 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
52779 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
52780 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
52781 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
52782 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
52783 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
52784 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
52785 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
52786 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
52787 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
52788 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
52789 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
52790 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
52791 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
52792 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
52793 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
52794 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
52795 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
52796 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
52797 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
52798 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
52799 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
52800 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
52801 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
52802 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
52803 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
52804 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
52805 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
52806 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
52807 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
52808 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
52809 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
52810 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52811 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52812 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52813 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
52814 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
52815 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52816 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52817 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
52818 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
52819 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
52820 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
52821 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
52822 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
52823 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
52824 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
52825 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
52826 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
52827 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
52828 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
52829 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
52830 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
52831 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
52832 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
52833 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
52834 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
52835 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
52836 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
52837 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
52838 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
52839 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
52840 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
52841 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
52842 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
52843 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
52844 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
52845 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
52846 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
52847 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
52848 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
52849 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
52850 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
52851 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
52852 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
52853 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
52854 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
52855 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
52856 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
52857 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
52858 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
52859 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
52860 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52861 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52862 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
52863 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
52864 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52865 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52866 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
52867 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
52868 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
52869 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
52870 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
52871 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
52872 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
52873 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
52874 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
52875 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
52876 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
52877 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
52878 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
52879 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
52880 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
52881 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
52882 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
52883 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
52884 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
52885 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
52886 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
52887 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
52888 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
52889 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
52890 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
52891 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
52892 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
52893 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
52894 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
52895 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
52896 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
52897 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
52898 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52899 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
52900 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
52901 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
52902 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
52903 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
52904 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
52905 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
52906 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
52907 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
52908 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
52909 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
52910 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
52911 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
52912 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
52913 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52914 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
52915 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
52916 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
52917 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
52918 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
52919 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52920 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
52921 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
52922 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
52923 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52924 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
52925 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
52926 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52927 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
52928 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
52929 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
52930 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52931 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
52932 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
52933 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52934 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
52935 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
52936 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
52937 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
52938 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
52939 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
52940 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
52941 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
52942 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
52943 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
52944 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
52945 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
52946 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
52947 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
52948 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
52949 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
52950 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
52951 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
52952 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
52953 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
52954 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
52955 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
52956 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
52957 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
52958 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
52959 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
52960 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
52961 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
52962 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
52963 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
52964 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52965 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
52966 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
52967 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
52968 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
52969 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
52970 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
52971 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
52972 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
52973 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
52974 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
52975 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
52976 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
52977 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
52978 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
52979 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
52980 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
52981 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
52982 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
52983 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
52984 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
52985 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
52986 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
52987 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
52988 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
52989 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
52990 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
52991 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
52992 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
52993 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
52994 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
52995 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
52996 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
52997 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52998 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
52999 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
53000 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
53001 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
53002 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
53003 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
53004 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
53005 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53006 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
53007 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
53008 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
53009 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
53010 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
53011 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
53012 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
53013 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
53014 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
53015 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
53016 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
53017 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
53018 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
53019 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
53020 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
53021 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
53022 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
53023 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
53024 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
53025 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
53026 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
53027 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
53028 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
53029 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
53030 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
53031 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
53032 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
53033 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
53034 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
53035 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
53036 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
53037 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
53038 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
53039 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
53040 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
53041 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
53042 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
53043 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53044 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
53045 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
53046 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53047 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53048 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
53049 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
53050 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
53051 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
53052 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
53053 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
53054 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53055 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
53056 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
53057 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53058 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53059 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
53060 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
53061 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53062 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
53063 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
53064 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53065 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
53066 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
53067 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53068 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
53069 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
53070 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
53071 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53072 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
53073 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53074 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
53075 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
53076 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53077 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
53078 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
53079 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
53080 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53081 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
53082 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
53083 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
53084 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53085 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
53086 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
53087 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53088 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
53089 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
53090 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
53091 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
53092 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
53093 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53094 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
53095 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
53096 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
53097 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
53098 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
53099 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
53100 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
53101 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
53102 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53103 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
53104 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
53105 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
53106 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
53107 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53108 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
53109 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
53110 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
53111 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53112 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
53113 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
53114 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
53115 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
53116 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
53117 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
53118 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53119 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
53120 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
53121 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
53122 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
53123 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
53124 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
53125 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
53126 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
53127 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53128 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53129 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53130 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
53131 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
53132 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
53133 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
53134 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
53135 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53136 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
53137 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
53138 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
53139 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
53140 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
53141 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
53142 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53143 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
53144 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
53145 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
53146 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
53147 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
53148 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
53149 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53150 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53151 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
53152 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
53153 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
53154 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53155 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
53156 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
53157 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
53158 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
53159 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
53160 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
53161 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
53162 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
53163 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
53164 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
53165 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
53166 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
53167 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
53168 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
53169 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
53170 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
53171 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53172 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
53173 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
53174 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
53175 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53176 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
53177 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
53178 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
53179 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53180 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
53181 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53182 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
53183 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
53184 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
53185 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
53186 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
53187 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53188 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
53189 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
53190 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
53191 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
53192 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53193 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
53194 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53195 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
53196 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
53197 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
53198 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53199 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
53200 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53201 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
53202 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
53203 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
53204 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53205 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
53206 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
53207 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
53208 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
53209 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
53210 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
53211 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53212 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
53213 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
53214 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
53215 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
53216 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
53217 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
53218 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
53219 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
53220 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
53221 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
53222 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
53223 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
53224 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
53225 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
53226 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
53227 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
53228 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
53229 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
53230 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
53231 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53232 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
53233 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
53234 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
53235 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
53236 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
53237 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
53238 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
53239 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
53240 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
53241 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
53242 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
53243 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
53244 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
53245 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
53246 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
53247 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53248 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53249 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53250 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
53251 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
53252 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
53253 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
53254 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
53255 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
53256 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
53257 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
53258 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
53259 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
53260 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53261 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
53262 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
53263 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
53264 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
53265 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
53266 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
53267 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
53268 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
53269 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
53270 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
53271 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
53272 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
53273 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
53274 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
53275 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
53276 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
53277 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
53278 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
53279 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
53280 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
53281 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
53282 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53283 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
53284 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
53285 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
53286 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
53287 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
53288 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53289 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
53290 { (char *)"AcceleratorTable_Ok", (PyCFunction)_wrap_AcceleratorTable_Ok, METH_O, NULL},
53291 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
53292 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
53293 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
53294 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
53295 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
53296 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
53297 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
53298 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
53299 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
53300 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
53301 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
53302 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
53303 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
53304 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
53305 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
53306 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53307 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
53308 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
53309 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
53310 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
53311 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53312 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
53313 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
53314 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
53315 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
53316 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
53317 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53318 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
53319 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
53320 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53321 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53322 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53323 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
53324 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53325 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53326 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
53327 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
53328 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
53329 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
53330 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
53331 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
53332 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53333 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
53334 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
53335 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
53336 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
53337 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
53338 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
53339 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
53340 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
53341 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
53342 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
53343 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
53344 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
53345 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
53346 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
53347 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
53348 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
53349 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
53350 { (char *)"Window_GetBestFittingSize", (PyCFunction)_wrap_Window_GetBestFittingSize, METH_O, NULL},
53351 { (char *)"Window_GetAdjustedBestSize", (PyCFunction)_wrap_Window_GetAdjustedBestSize, METH_O, NULL},
53352 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
53353 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
53354 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
53355 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
53356 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53357 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53358 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53359 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53360 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
53361 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
53362 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53363 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
53364 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
53365 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
53366 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
53367 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
53368 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
53369 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53370 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
53371 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
53372 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
53373 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53374 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
53375 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53376 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
53377 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
53378 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
53379 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53380 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
53381 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53382 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
53383 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53384 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
53385 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
53386 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53387 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
53388 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
53389 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
53390 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
53391 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
53392 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
53393 { (char *)"Window_GetDefaultItem", (PyCFunction)_wrap_Window_GetDefaultItem, METH_O, NULL},
53394 { (char *)"Window_SetDefaultItem", (PyCFunction) _wrap_Window_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
53395 { (char *)"Window_SetTmpDefaultItem", (PyCFunction) _wrap_Window_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
53396 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
53397 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53398 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53399 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
53400 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
53401 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
53402 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
53403 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
53404 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
53405 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
53406 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
53407 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
53408 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
53409 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53410 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53411 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53412 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53413 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
53414 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
53415 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
53416 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
53417 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
53418 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
53419 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53420 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
53421 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
53422 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
53423 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
53424 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
53425 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
53426 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
53427 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
53428 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
53429 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
53430 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
53431 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
53432 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
53433 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
53434 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
53435 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
53436 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
53437 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
53438 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
53439 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
53440 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
53441 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
53442 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
53443 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
53444 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53445 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
53446 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
53447 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
53448 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53449 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53450 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53451 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53452 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
53453 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
53454 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
53455 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
53456 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53457 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
53458 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
53459 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
53460 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
53461 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
53462 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
53463 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
53464 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
53465 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
53466 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
53467 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
53468 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
53469 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
53470 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
53471 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
53472 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
53473 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
53474 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
53475 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
53476 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
53477 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
53478 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
53479 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53480 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
53481 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
53482 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
53483 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
53484 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
53485 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
53486 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
53487 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
53488 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
53489 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53490 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
53491 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
53492 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
53493 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
53494 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
53495 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
53496 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
53497 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
53498 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
53499 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
53500 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
53501 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
53502 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
53503 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
53504 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
53505 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
53506 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
53507 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
53508 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
53509 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
53510 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53511 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
53512 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
53513 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53514 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
53515 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
53516 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
53517 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
53518 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
53519 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
53520 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
53521 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53522 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
53523 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
53524 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
53525 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
53526 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
53527 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
53528 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
53529 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
53530 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53531 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
53532 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
53533 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
53534 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
53535 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
53536 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53537 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
53538 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
53539 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
53540 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53541 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
53542 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53543 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53544 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53545 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53546 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
53547 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
53548 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
53549 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
53550 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53551 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
53552 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53553 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53554 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53555 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
53556 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
53557 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53558 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53559 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53560 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53561 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
53562 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
53563 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
53564 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
53565 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
53566 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
53567 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
53568 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
53569 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
53570 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
53571 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53572 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53573 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53574 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53575 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
53576 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53577 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53578 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53579 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53580 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
53581 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
53582 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53583 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
53584 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53585 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
53586 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
53587 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
53588 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
53589 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
53590 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
53591 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
53592 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
53593 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
53594 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
53595 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
53596 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
53597 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53598 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53599 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
53600 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53601 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
53602 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53603 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
53604 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
53605 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
53606 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
53607 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
53608 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
53609 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53610 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53611 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53612 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
53613 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53614 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53615 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53616 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53617 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53618 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
53619 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
53620 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
53621 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
53622 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53623 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
53624 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
53625 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
53626 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
53627 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
53628 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
53629 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53630 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53631 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
53632 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
53633 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
53634 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
53635 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
53636 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
53637 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
53638 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
53639 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
53640 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
53641 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
53642 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53643 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
53644 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53645 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
53646 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53647 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
53648 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
53649 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
53650 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
53651 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
53652 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
53653 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53654 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
53655 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
53656 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
53657 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
53658 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
53659 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53660 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
53661 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
53662 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53663 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
53664 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
53665 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
53666 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
53667 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
53668 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
53669 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
53670 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
53671 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
53672 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
53673 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
53674 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53675 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
53676 { (char *)"Control_GetLabel", (PyCFunction)_wrap_Control_GetLabel, METH_O, NULL},
53677 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
53678 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
53679 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
53680 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53681 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
53682 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53683 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
53684 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
53685 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53686 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53687 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
53688 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
53689 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
53690 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
53691 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
53692 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
53693 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
53694 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
53695 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
53696 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
53697 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
53698 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
53699 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
53700 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
53701 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
53702 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53703 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
53704 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53705 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
53706 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
53707 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
53708 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
53709 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
53710 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
53711 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
53712 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
53713 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
53714 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
53715 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
53716 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
53717 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
53718 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
53719 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
53720 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
53721 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
53722 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
53723 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53724 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
53725 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
53726 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
53727 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
53728 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53729 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
53730 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53731 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
53732 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
53733 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53734 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
53735 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
53736 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
53737 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
53738 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
53739 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
53740 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
53741 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53742 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
53743 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53744 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
53745 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53746 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
53747 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
53748 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53749 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
53750 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
53751 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
53752 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
53753 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53754 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
53755 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
53756 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
53757 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
53758 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
53759 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
53760 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
53761 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
53762 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53763 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53764 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
53765 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
53766 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
53767 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53768 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
53769 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
53770 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
53771 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
53772 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53773 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
53774 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
53775 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53776 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
53777 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
53778 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
53779 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
53780 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53781 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
53782 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
53783 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
53784 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53785 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
53786 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
53787 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
53788 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
53789 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
53790 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
53791 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
53792 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
53793 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
53794 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
53795 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53796 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
53797 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
53798 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
53799 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
53800 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
53801 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
53802 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
53803 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
53804 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
53805 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
53806 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
53807 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
53808 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
53809 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
53810 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
53811 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
53812 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
53813 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
53814 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
53815 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
53816 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
53817 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
53818 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
53819 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
53820 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
53821 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53822 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
53823 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
53824 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
53825 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
53826 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
53827 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53828 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53829 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53830 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
53831 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
53832 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
53833 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
53834 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
53835 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
53836 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
53837 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
53838 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
53839 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53840 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53841 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53842 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
53843 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
53844 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
53845 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
53846 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
53847 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53848 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53849 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
53850 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
53851 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
53852 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
53853 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
53854 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
53855 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
53856 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
53857 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
53858 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53859 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
53860 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
53861 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53862 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
53863 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
53864 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
53865 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
53866 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
53867 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
53868 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
53869 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
53870 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
53871 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
53872 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53873 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53874 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
53875 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
53876 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
53877 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
53878 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53879 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
53880 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
53881 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
53882 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
53883 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
53884 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
53885 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
53886 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
53887 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
53888 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
53889 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
53890 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
53891 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
53892 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
53893 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
53894 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
53895 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
53896 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
53897 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
53898 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
53899 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
53900 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
53901 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
53902 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
53903 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
53904 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
53905 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
53906 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
53907 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
53908 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
53909 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
53910 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
53911 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
53912 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
53913 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
53914 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
53915 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
53916 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
53917 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
53918 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
53919 { NULL, NULL, 0, NULL }
53920 };
53921
53922
53923 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
53924
53925 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
53926 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
53927 }
53928 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
53929 return (void *)((wxSizer *) ((wxBoxSizer *) x));
53930 }
53931 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
53932 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
53933 }
53934 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
53935 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
53936 }
53937 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
53938 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
53939 }
53940 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
53941 return (void *)((wxSizer *) ((wxGridSizer *) x));
53942 }
53943 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
53944 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
53945 }
53946 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
53947 return (void *)((wxSizer *) ((wxPySizer *) x));
53948 }
53949 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
53950 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
53951 }
53952 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
53953 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
53954 }
53955 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
53956 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
53957 }
53958 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
53959 return (void *)((wxEvent *) ((wxMenuEvent *) x));
53960 }
53961 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
53962 return (void *)((wxEvent *) ((wxCloseEvent *) x));
53963 }
53964 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
53965 return (void *)((wxEvent *) ((wxMouseEvent *) x));
53966 }
53967 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
53968 return (void *)((wxEvent *) ((wxEraseEvent *) x));
53969 }
53970 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
53971 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
53972 }
53973 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
53974 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
53975 }
53976 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
53977 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
53978 }
53979 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
53980 return (void *)((wxEvent *) ((wxPyEvent *) x));
53981 }
53982 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
53983 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
53984 }
53985 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
53986 return (void *)((wxEvent *) ((wxIdleEvent *) x));
53987 }
53988 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
53989 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
53990 }
53991 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
53992 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
53993 }
53994 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
53995 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
53996 }
53997 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
53998 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
53999 }
54000 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
54001 return (void *)((wxEvent *) ((wxActivateEvent *) x));
54002 }
54003 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
54004 return (void *)((wxEvent *) ((wxSizeEvent *) x));
54005 }
54006 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
54007 return (void *)((wxEvent *) ((wxMoveEvent *) x));
54008 }
54009 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
54010 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
54011 }
54012 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
54013 return (void *)((wxEvent *) ((wxPaintEvent *) x));
54014 }
54015 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
54016 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
54017 }
54018 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
54019 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
54020 }
54021 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
54022 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
54023 }
54024 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
54025 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
54026 }
54027 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
54028 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
54029 }
54030 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
54031 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
54032 }
54033 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
54034 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
54035 }
54036 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
54037 return (void *)((wxEvent *) ((wxFocusEvent *) x));
54038 }
54039 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
54040 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
54041 }
54042 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
54043 return (void *)((wxEvent *) ((wxShowEvent *) x));
54044 }
54045 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
54046 return (void *)((wxEvent *) ((wxCommandEvent *) x));
54047 }
54048 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
54049 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
54050 }
54051 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
54052 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54053 }
54054 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
54055 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
54056 }
54057 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
54058 return (void *)((wxEvent *) ((wxKeyEvent *) x));
54059 }
54060 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
54061 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
54062 }
54063 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
54064 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
54065 }
54066 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
54067 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
54068 }
54069 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
54070 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
54071 }
54072 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
54073 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
54074 }
54075 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
54076 return (void *)((wxControl *) ((wxControlWithItems *) x));
54077 }
54078 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
54079 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
54080 }
54081 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
54082 return (void *)((wxEvtHandler *) ((wxWindow *) x));
54083 }
54084 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
54085 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
54086 }
54087 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
54088 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
54089 }
54090 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
54091 return (void *)((wxEvtHandler *) ((wxValidator *) x));
54092 }
54093 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
54094 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
54095 }
54096 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
54097 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
54098 }
54099 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
54100 return (void *)((wxEvtHandler *) ((wxMenu *) x));
54101 }
54102 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
54103 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
54104 }
54105 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
54106 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
54107 }
54108 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
54109 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
54110 }
54111 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
54112 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
54113 }
54114 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
54115 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
54116 }
54117 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
54118 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54119 }
54120 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
54121 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
54122 }
54123 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
54124 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
54125 }
54126 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
54127 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
54128 }
54129 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
54130 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54131 }
54132 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
54133 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54134 }
54135 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
54136 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
54137 }
54138 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
54139 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
54140 }
54141 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
54142 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
54143 }
54144 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
54145 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
54146 }
54147 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
54148 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
54149 }
54150 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
54151 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
54152 }
54153 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
54154 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
54155 }
54156 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
54157 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
54158 }
54159 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
54160 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
54161 }
54162 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
54163 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
54164 }
54165 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
54166 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
54167 }
54168 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
54169 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
54170 }
54171 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
54172 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
54173 }
54174 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
54175 return (void *)((wxObject *) ((wxSizerItem *) x));
54176 }
54177 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
54178 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
54179 }
54180 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
54181 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
54182 }
54183 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
54184 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
54185 }
54186 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
54187 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
54188 }
54189 static void *_p_wxSizerTo_p_wxObject(void *x) {
54190 return (void *)((wxObject *) ((wxSizer *) x));
54191 }
54192 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
54193 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
54194 }
54195 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
54196 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
54197 }
54198 static void *_p_wxEventTo_p_wxObject(void *x) {
54199 return (void *)((wxObject *) ((wxEvent *) x));
54200 }
54201 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
54202 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
54203 }
54204 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
54205 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
54206 }
54207 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
54208 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
54209 }
54210 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
54211 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
54212 }
54213 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
54214 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
54215 }
54216 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
54217 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
54218 }
54219 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
54220 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
54221 }
54222 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
54223 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
54224 }
54225 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
54226 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
54227 }
54228 static void *_p_wxControlTo_p_wxObject(void *x) {
54229 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
54230 }
54231 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
54232 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
54233 }
54234 static void *_p_wxFSFileTo_p_wxObject(void *x) {
54235 return (void *)((wxObject *) ((wxFSFile *) x));
54236 }
54237 static void *_p_wxPySizerTo_p_wxObject(void *x) {
54238 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
54239 }
54240 static void *_p_wxPyEventTo_p_wxObject(void *x) {
54241 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
54242 }
54243 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
54244 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
54245 }
54246 static void *_p_wxShowEventTo_p_wxObject(void *x) {
54247 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
54248 }
54249 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
54250 return (void *)((wxObject *) ((wxMenuItem *) x));
54251 }
54252 static void *_p_wxDateEventTo_p_wxObject(void *x) {
54253 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
54254 }
54255 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
54256 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
54257 }
54258 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
54259 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
54260 }
54261 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
54262 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
54263 }
54264 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
54265 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
54266 }
54267 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
54268 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
54269 }
54270 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
54271 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
54272 }
54273 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
54274 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
54275 }
54276 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
54277 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
54278 }
54279 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
54280 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
54281 }
54282 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
54283 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
54284 }
54285 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
54286 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
54287 }
54288 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
54289 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
54290 }
54291 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
54292 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
54293 }
54294 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
54295 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54296 }
54297 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
54298 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54299 }
54300 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
54301 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
54302 }
54303 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
54304 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
54305 }
54306 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
54307 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
54308 }
54309 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
54310 return (void *)((wxObject *) ((wxImageHandler *) x));
54311 }
54312 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
54313 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
54314 }
54315 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
54316 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
54317 }
54318 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
54319 return (void *)((wxObject *) ((wxEvtHandler *) x));
54320 }
54321 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
54322 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54323 }
54324 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
54325 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
54326 }
54327 static void *_p_wxImageTo_p_wxObject(void *x) {
54328 return (void *)((wxObject *) ((wxImage *) x));
54329 }
54330 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
54331 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
54332 }
54333 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
54334 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54335 }
54336 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
54337 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
54338 }
54339 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
54340 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
54341 }
54342 static void *_p_wxWindowTo_p_wxObject(void *x) {
54343 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
54344 }
54345 static void *_p_wxMenuTo_p_wxObject(void *x) {
54346 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
54347 }
54348 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
54349 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
54350 }
54351 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
54352 return (void *)((wxObject *) ((wxFileSystem *) x));
54353 }
54354 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
54355 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
54356 }
54357 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
54358 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
54359 }
54360 static void *_p_wxPyAppTo_p_wxObject(void *x) {
54361 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
54362 }
54363 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
54364 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
54365 }
54366 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
54367 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
54368 }
54369 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
54370 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
54371 }
54372 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
54373 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
54374 }
54375 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
54376 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
54377 }
54378 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
54379 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
54380 }
54381 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
54382 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
54383 }
54384 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
54385 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
54386 }
54387 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
54388 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
54389 }
54390 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
54391 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
54392 }
54393 static void *_p_wxValidatorTo_p_wxObject(void *x) {
54394 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
54395 }
54396 static void *_p_wxControlTo_p_wxWindow(void *x) {
54397 return (void *)((wxWindow *) ((wxControl *) x));
54398 }
54399 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
54400 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
54401 }
54402 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
54403 return (void *)((wxWindow *) ((wxMenuBar *) x));
54404 }
54405 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
54406 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
54407 }
54408 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
54409 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
54410 }
54411 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
54412 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
54413 }
54414 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
54415 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
54416 }
54417 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
54418 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
54419 }
54420 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
54421 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54422 }
54423 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
54424 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
54425 }
54426 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
54427 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
54428 }
54429 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
54430 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
54431 }
54432 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
54433 return (void *)((wxValidator *) ((wxPyValidator *) x));
54434 }
54435 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
54436 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
54437 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};
54438 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
54439 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
54440 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
54441 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
54442 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
54443 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
54444 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
54445 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
54446 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
54447 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
54448 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
54449 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
54450 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
54451 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
54452 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
54453 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
54454 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
54455 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
54456 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
54457 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
54458 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
54459 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
54460 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
54461 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
54462 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
54463 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
54464 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
54465 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
54466 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
54467 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
54468 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
54469 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
54470 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
54471 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
54472 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
54473 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
54474 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
54475 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
54476 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
54477 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
54478 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
54479 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
54480 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
54481 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
54482 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
54483 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
54484 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
54485 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
54486 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
54487 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
54488 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
54489 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
54490 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
54491 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
54492 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
54493 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
54494 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
54495 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
54496 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
54497 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
54498 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
54499 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
54500 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
54501 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
54502 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
54503 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
54504 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
54505 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
54506 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
54507 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
54508 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
54509 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
54510 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
54511 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
54512 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
54513 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
54514 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
54515 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
54516 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
54517 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
54518 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
54519 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
54520 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
54521 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
54522 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
54523 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
54524 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
54525 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
54526 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
54527 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
54528 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
54529 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
54530 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
54531 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
54532 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
54533 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
54534 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
54535 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
54536 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
54537 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
54538 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
54539 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
54540 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
54541 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
54542 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
54543 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
54544 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
54545 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
54546 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
54547 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
54548 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
54549 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
54550 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
54551 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
54552 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
54553 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
54554 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
54555 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
54556 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
54557 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
54558 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
54559 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
54560 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
54561 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
54562 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
54563 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
54564
54565 static swig_type_info *swig_type_initial[] = {
54566 &_swigt__p_buffer,
54567 &_swigt__p_char,
54568 &_swigt__p_form_ops_t,
54569 &_swigt__p_int,
54570 &_swigt__p_long,
54571 &_swigt__p_unsigned_char,
54572 &_swigt__p_unsigned_int,
54573 &_swigt__p_unsigned_long,
54574 &_swigt__p_wxANIHandler,
54575 &_swigt__p_wxAcceleratorEntry,
54576 &_swigt__p_wxAcceleratorTable,
54577 &_swigt__p_wxActivateEvent,
54578 &_swigt__p_wxAppTraits,
54579 &_swigt__p_wxArrayString,
54580 &_swigt__p_wxBMPHandler,
54581 &_swigt__p_wxBitmap,
54582 &_swigt__p_wxBoxSizer,
54583 &_swigt__p_wxButton,
54584 &_swigt__p_wxCURHandler,
54585 &_swigt__p_wxCaret,
54586 &_swigt__p_wxChildFocusEvent,
54587 &_swigt__p_wxCloseEvent,
54588 &_swigt__p_wxColour,
54589 &_swigt__p_wxCommandEvent,
54590 &_swigt__p_wxContextMenuEvent,
54591 &_swigt__p_wxControl,
54592 &_swigt__p_wxControlWithItems,
54593 &_swigt__p_wxCursor,
54594 &_swigt__p_wxDC,
54595 &_swigt__p_wxDateEvent,
54596 &_swigt__p_wxDateTime,
54597 &_swigt__p_wxDisplayChangedEvent,
54598 &_swigt__p_wxDropFilesEvent,
54599 &_swigt__p_wxDuplexMode,
54600 &_swigt__p_wxEraseEvent,
54601 &_swigt__p_wxEvent,
54602 &_swigt__p_wxEventLoop,
54603 &_swigt__p_wxEventLoopActivator,
54604 &_swigt__p_wxEvtHandler,
54605 &_swigt__p_wxFSFile,
54606 &_swigt__p_wxFileSystem,
54607 &_swigt__p_wxFileSystemHandler,
54608 &_swigt__p_wxFlexGridSizer,
54609 &_swigt__p_wxFocusEvent,
54610 &_swigt__p_wxFont,
54611 &_swigt__p_wxFrame,
54612 &_swigt__p_wxGBPosition,
54613 &_swigt__p_wxGBSizerItem,
54614 &_swigt__p_wxGBSpan,
54615 &_swigt__p_wxGIFHandler,
54616 &_swigt__p_wxGridBagSizer,
54617 &_swigt__p_wxGridSizer,
54618 &_swigt__p_wxICOHandler,
54619 &_swigt__p_wxIconizeEvent,
54620 &_swigt__p_wxIdleEvent,
54621 &_swigt__p_wxImage,
54622 &_swigt__p_wxImageHandler,
54623 &_swigt__p_wxImageHistogram,
54624 &_swigt__p_wxImage_HSVValue,
54625 &_swigt__p_wxImage_RGBValue,
54626 &_swigt__p_wxIndividualLayoutConstraint,
54627 &_swigt__p_wxInitDialogEvent,
54628 &_swigt__p_wxInputStream,
54629 &_swigt__p_wxInternetFSHandler,
54630 &_swigt__p_wxItemContainer,
54631 &_swigt__p_wxJPEGHandler,
54632 &_swigt__p_wxKeyEvent,
54633 &_swigt__p_wxLayoutConstraints,
54634 &_swigt__p_wxMaximizeEvent,
54635 &_swigt__p_wxMemoryFSHandler,
54636 &_swigt__p_wxMenu,
54637 &_swigt__p_wxMenuBar,
54638 &_swigt__p_wxMenuBarBase,
54639 &_swigt__p_wxMenuEvent,
54640 &_swigt__p_wxMenuItem,
54641 &_swigt__p_wxMouseCaptureChangedEvent,
54642 &_swigt__p_wxMouseEvent,
54643 &_swigt__p_wxMoveEvent,
54644 &_swigt__p_wxNavigationKeyEvent,
54645 &_swigt__p_wxNcPaintEvent,
54646 &_swigt__p_wxNotifyEvent,
54647 &_swigt__p_wxObject,
54648 &_swigt__p_wxOutputStream,
54649 &_swigt__p_wxPCXHandler,
54650 &_swigt__p_wxPNGHandler,
54651 &_swigt__p_wxPNMHandler,
54652 &_swigt__p_wxPaintEvent,
54653 &_swigt__p_wxPaletteChangedEvent,
54654 &_swigt__p_wxPaperSize,
54655 &_swigt__p_wxPoint,
54656 &_swigt__p_wxPoint2D,
54657 &_swigt__p_wxPropagateOnce,
54658 &_swigt__p_wxPropagationDisabler,
54659 &_swigt__p_wxPyApp,
54660 &_swigt__p_wxPyCommandEvent,
54661 &_swigt__p_wxPyDropTarget,
54662 &_swigt__p_wxPyEvent,
54663 &_swigt__p_wxPyFileSystemHandler,
54664 &_swigt__p_wxPyImageHandler,
54665 &_swigt__p_wxPyInputStream,
54666 &_swigt__p_wxPySizer,
54667 &_swigt__p_wxPyValidator,
54668 &_swigt__p_wxQuantize,
54669 &_swigt__p_wxQueryNewPaletteEvent,
54670 &_swigt__p_wxRealPoint,
54671 &_swigt__p_wxRect,
54672 &_swigt__p_wxRegion,
54673 &_swigt__p_wxScrollEvent,
54674 &_swigt__p_wxScrollWinEvent,
54675 &_swigt__p_wxSetCursorEvent,
54676 &_swigt__p_wxShowEvent,
54677 &_swigt__p_wxSize,
54678 &_swigt__p_wxSizeEvent,
54679 &_swigt__p_wxSizer,
54680 &_swigt__p_wxSizerItem,
54681 &_swigt__p_wxStaticBox,
54682 &_swigt__p_wxStaticBoxSizer,
54683 &_swigt__p_wxStdDialogButtonSizer,
54684 &_swigt__p_wxSysColourChangedEvent,
54685 &_swigt__p_wxTIFFHandler,
54686 &_swigt__p_wxToolTip,
54687 &_swigt__p_wxUpdateUIEvent,
54688 &_swigt__p_wxValidator,
54689 &_swigt__p_wxVisualAttributes,
54690 &_swigt__p_wxWindow,
54691 &_swigt__p_wxWindowCreateEvent,
54692 &_swigt__p_wxWindowDestroyEvent,
54693 &_swigt__p_wxXPMHandler,
54694 &_swigt__p_wxZipFSHandler,
54695 };
54696
54697 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
54698 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
54699 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
54700 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
54701 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
54702 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
54703 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
54704 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
54705 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
54706 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
54707 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
54708 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
54709 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
54710 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
54711 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}};
54712 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
54713 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}};
54714 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
54715 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}};
54716 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
54717 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
54718 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
54719 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
54720 static swig_cast_info _swigc__p_wxCommandEvent[] = { {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxCommandEvent, 0, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxCommandEvent, 0, 0},{0, 0, 0, 0}};
54721 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
54722 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}};
54723 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
54724 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
54725 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
54726 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
54727 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
54728 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54729 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
54730 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
54731 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
54732 static swig_cast_info _swigc__p_wxEvent[] = { {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEvent, 0, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxEvent, 0, 0},{0, 0, 0, 0}};
54733 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
54734 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
54735 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}};
54736 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
54737 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
54738 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}};
54739 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}};
54740 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
54741 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
54742 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
54743 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
54744 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
54745 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
54746 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
54747 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
54748 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}};
54749 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}};
54750 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
54751 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
54752 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
54753 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}};
54754 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
54755 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
54756 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
54757 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
54758 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
54759 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
54760 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
54761 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}};
54762 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
54763 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
54764 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
54765 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
54766 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
54767 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
54768 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
54769 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
54770 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
54771 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
54772 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54773 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
54774 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
54775 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
54776 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
54777 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
54778 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxAcceleratorTable, _p_wxAcceleratorTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxImage, _p_wxImageTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxObject, 0, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileSystem, _p_wxFileSystemTo_p_wxObject, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxObject, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxObject, 0, 0},{0, 0, 0, 0}};
54779 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
54780 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
54781 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
54782 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
54783 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
54784 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54785 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
54786 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
54787 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
54788 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
54789 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
54790 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
54791 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
54792 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
54793 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
54794 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
54795 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
54796 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
54797 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
54798 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
54799 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
54800 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
54801 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
54802 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
54803 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
54804 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
54805 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
54806 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
54807 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
54808 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
54809 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
54810 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}};
54811 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}};
54812 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
54813 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
54814 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
54815 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54816 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
54817 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
54818 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
54819 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}};
54820 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
54821 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}};
54822 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
54823 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
54824 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
54825 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
54826
54827 static swig_cast_info *swig_cast_initial[] = {
54828 _swigc__p_buffer,
54829 _swigc__p_char,
54830 _swigc__p_form_ops_t,
54831 _swigc__p_int,
54832 _swigc__p_long,
54833 _swigc__p_unsigned_char,
54834 _swigc__p_unsigned_int,
54835 _swigc__p_unsigned_long,
54836 _swigc__p_wxANIHandler,
54837 _swigc__p_wxAcceleratorEntry,
54838 _swigc__p_wxAcceleratorTable,
54839 _swigc__p_wxActivateEvent,
54840 _swigc__p_wxAppTraits,
54841 _swigc__p_wxArrayString,
54842 _swigc__p_wxBMPHandler,
54843 _swigc__p_wxBitmap,
54844 _swigc__p_wxBoxSizer,
54845 _swigc__p_wxButton,
54846 _swigc__p_wxCURHandler,
54847 _swigc__p_wxCaret,
54848 _swigc__p_wxChildFocusEvent,
54849 _swigc__p_wxCloseEvent,
54850 _swigc__p_wxColour,
54851 _swigc__p_wxCommandEvent,
54852 _swigc__p_wxContextMenuEvent,
54853 _swigc__p_wxControl,
54854 _swigc__p_wxControlWithItems,
54855 _swigc__p_wxCursor,
54856 _swigc__p_wxDC,
54857 _swigc__p_wxDateEvent,
54858 _swigc__p_wxDateTime,
54859 _swigc__p_wxDisplayChangedEvent,
54860 _swigc__p_wxDropFilesEvent,
54861 _swigc__p_wxDuplexMode,
54862 _swigc__p_wxEraseEvent,
54863 _swigc__p_wxEvent,
54864 _swigc__p_wxEventLoop,
54865 _swigc__p_wxEventLoopActivator,
54866 _swigc__p_wxEvtHandler,
54867 _swigc__p_wxFSFile,
54868 _swigc__p_wxFileSystem,
54869 _swigc__p_wxFileSystemHandler,
54870 _swigc__p_wxFlexGridSizer,
54871 _swigc__p_wxFocusEvent,
54872 _swigc__p_wxFont,
54873 _swigc__p_wxFrame,
54874 _swigc__p_wxGBPosition,
54875 _swigc__p_wxGBSizerItem,
54876 _swigc__p_wxGBSpan,
54877 _swigc__p_wxGIFHandler,
54878 _swigc__p_wxGridBagSizer,
54879 _swigc__p_wxGridSizer,
54880 _swigc__p_wxICOHandler,
54881 _swigc__p_wxIconizeEvent,
54882 _swigc__p_wxIdleEvent,
54883 _swigc__p_wxImage,
54884 _swigc__p_wxImageHandler,
54885 _swigc__p_wxImageHistogram,
54886 _swigc__p_wxImage_HSVValue,
54887 _swigc__p_wxImage_RGBValue,
54888 _swigc__p_wxIndividualLayoutConstraint,
54889 _swigc__p_wxInitDialogEvent,
54890 _swigc__p_wxInputStream,
54891 _swigc__p_wxInternetFSHandler,
54892 _swigc__p_wxItemContainer,
54893 _swigc__p_wxJPEGHandler,
54894 _swigc__p_wxKeyEvent,
54895 _swigc__p_wxLayoutConstraints,
54896 _swigc__p_wxMaximizeEvent,
54897 _swigc__p_wxMemoryFSHandler,
54898 _swigc__p_wxMenu,
54899 _swigc__p_wxMenuBar,
54900 _swigc__p_wxMenuBarBase,
54901 _swigc__p_wxMenuEvent,
54902 _swigc__p_wxMenuItem,
54903 _swigc__p_wxMouseCaptureChangedEvent,
54904 _swigc__p_wxMouseEvent,
54905 _swigc__p_wxMoveEvent,
54906 _swigc__p_wxNavigationKeyEvent,
54907 _swigc__p_wxNcPaintEvent,
54908 _swigc__p_wxNotifyEvent,
54909 _swigc__p_wxObject,
54910 _swigc__p_wxOutputStream,
54911 _swigc__p_wxPCXHandler,
54912 _swigc__p_wxPNGHandler,
54913 _swigc__p_wxPNMHandler,
54914 _swigc__p_wxPaintEvent,
54915 _swigc__p_wxPaletteChangedEvent,
54916 _swigc__p_wxPaperSize,
54917 _swigc__p_wxPoint,
54918 _swigc__p_wxPoint2D,
54919 _swigc__p_wxPropagateOnce,
54920 _swigc__p_wxPropagationDisabler,
54921 _swigc__p_wxPyApp,
54922 _swigc__p_wxPyCommandEvent,
54923 _swigc__p_wxPyDropTarget,
54924 _swigc__p_wxPyEvent,
54925 _swigc__p_wxPyFileSystemHandler,
54926 _swigc__p_wxPyImageHandler,
54927 _swigc__p_wxPyInputStream,
54928 _swigc__p_wxPySizer,
54929 _swigc__p_wxPyValidator,
54930 _swigc__p_wxQuantize,
54931 _swigc__p_wxQueryNewPaletteEvent,
54932 _swigc__p_wxRealPoint,
54933 _swigc__p_wxRect,
54934 _swigc__p_wxRegion,
54935 _swigc__p_wxScrollEvent,
54936 _swigc__p_wxScrollWinEvent,
54937 _swigc__p_wxSetCursorEvent,
54938 _swigc__p_wxShowEvent,
54939 _swigc__p_wxSize,
54940 _swigc__p_wxSizeEvent,
54941 _swigc__p_wxSizer,
54942 _swigc__p_wxSizerItem,
54943 _swigc__p_wxStaticBox,
54944 _swigc__p_wxStaticBoxSizer,
54945 _swigc__p_wxStdDialogButtonSizer,
54946 _swigc__p_wxSysColourChangedEvent,
54947 _swigc__p_wxTIFFHandler,
54948 _swigc__p_wxToolTip,
54949 _swigc__p_wxUpdateUIEvent,
54950 _swigc__p_wxValidator,
54951 _swigc__p_wxVisualAttributes,
54952 _swigc__p_wxWindow,
54953 _swigc__p_wxWindowCreateEvent,
54954 _swigc__p_wxWindowDestroyEvent,
54955 _swigc__p_wxXPMHandler,
54956 _swigc__p_wxZipFSHandler,
54957 };
54958
54959
54960 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
54961
54962 static swig_const_info swig_const_table[] = {
54963 {0, 0, 0, 0.0, 0, 0}};
54964
54965 #ifdef __cplusplus
54966 }
54967 #endif
54968 /* -----------------------------------------------------------------------------
54969 * Type initialization:
54970 * This problem is tough by the requirement that no dynamic
54971 * memory is used. Also, since swig_type_info structures store pointers to
54972 * swig_cast_info structures and swig_cast_info structures store pointers back
54973 * to swig_type_info structures, we need some lookup code at initialization.
54974 * The idea is that swig generates all the structures that are needed.
54975 * The runtime then collects these partially filled structures.
54976 * The SWIG_InitializeModule function takes these initial arrays out of
54977 * swig_module, and does all the lookup, filling in the swig_module.types
54978 * array with the correct data and linking the correct swig_cast_info
54979 * structures together.
54980 *
54981 * The generated swig_type_info structures are assigned staticly to an initial
54982 * array. We just loop though that array, and handle each type individually.
54983 * First we lookup if this type has been already loaded, and if so, use the
54984 * loaded structure instead of the generated one. Then we have to fill in the
54985 * cast linked list. The cast data is initially stored in something like a
54986 * two-dimensional array. Each row corresponds to a type (there are the same
54987 * number of rows as there are in the swig_type_initial array). Each entry in
54988 * a column is one of the swig_cast_info structures for that type.
54989 * The cast_initial array is actually an array of arrays, because each row has
54990 * a variable number of columns. So to actually build the cast linked list,
54991 * we find the array of casts associated with the type, and loop through it
54992 * adding the casts to the list. The one last trick we need to do is making
54993 * sure the type pointer in the swig_cast_info struct is correct.
54994 *
54995 * First off, we lookup the cast->type name to see if it is already loaded.
54996 * There are three cases to handle:
54997 * 1) If the cast->type has already been loaded AND the type we are adding
54998 * casting info to has not been loaded (it is in this module), THEN we
54999 * replace the cast->type pointer with the type pointer that has already
55000 * been loaded.
55001 * 2) If BOTH types (the one we are adding casting info to, and the
55002 * cast->type) are loaded, THEN the cast info has already been loaded by
55003 * the previous module so we just ignore it.
55004 * 3) Finally, if cast->type has not already been loaded, then we add that
55005 * swig_cast_info to the linked list (because the cast->type) pointer will
55006 * be correct.
55007 * ----------------------------------------------------------------------------- */
55008
55009 #ifdef __cplusplus
55010 extern "C" {
55011 #if 0
55012 } /* c-mode */
55013 #endif
55014 #endif
55015
55016 #if 0
55017 #define SWIGRUNTIME_DEBUG
55018 #endif
55019
55020 SWIGRUNTIME void
55021 SWIG_InitializeModule(void *clientdata) {
55022 size_t i;
55023 swig_module_info *module_head;
55024 static int init_run = 0;
55025
55026 clientdata = clientdata;
55027
55028 if (init_run) return;
55029 init_run = 1;
55030
55031 /* Initialize the swig_module */
55032 swig_module.type_initial = swig_type_initial;
55033 swig_module.cast_initial = swig_cast_initial;
55034
55035 /* Try and load any already created modules */
55036 module_head = SWIG_GetModule(clientdata);
55037 if (module_head) {
55038 swig_module.next = module_head->next;
55039 module_head->next = &swig_module;
55040 } else {
55041 /* This is the first module loaded */
55042 swig_module.next = &swig_module;
55043 SWIG_SetModule(clientdata, &swig_module);
55044 }
55045
55046 /* Now work on filling in swig_module.types */
55047 #ifdef SWIGRUNTIME_DEBUG
55048 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
55049 #endif
55050 for (i = 0; i < swig_module.size; ++i) {
55051 swig_type_info *type = 0;
55052 swig_type_info *ret;
55053 swig_cast_info *cast;
55054
55055 #ifdef SWIGRUNTIME_DEBUG
55056 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
55057 #endif
55058
55059 /* if there is another module already loaded */
55060 if (swig_module.next != &swig_module) {
55061 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
55062 }
55063 if (type) {
55064 /* Overwrite clientdata field */
55065 #ifdef SWIGRUNTIME_DEBUG
55066 printf("SWIG_InitializeModule: found type %s\n", type->name);
55067 #endif
55068 if (swig_module.type_initial[i]->clientdata) {
55069 type->clientdata = swig_module.type_initial[i]->clientdata;
55070 #ifdef SWIGRUNTIME_DEBUG
55071 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
55072 #endif
55073 }
55074 } else {
55075 type = swig_module.type_initial[i];
55076 }
55077
55078 /* Insert casting types */
55079 cast = swig_module.cast_initial[i];
55080 while (cast->type) {
55081 /* Don't need to add information already in the list */
55082 ret = 0;
55083 #ifdef SWIGRUNTIME_DEBUG
55084 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
55085 #endif
55086 if (swig_module.next != &swig_module) {
55087 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
55088 #ifdef SWIGRUNTIME_DEBUG
55089 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
55090 #endif
55091 }
55092 if (ret) {
55093 if (type == swig_module.type_initial[i]) {
55094 #ifdef SWIGRUNTIME_DEBUG
55095 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
55096 #endif
55097 cast->type = ret;
55098 ret = 0;
55099 } else {
55100 /* Check for casting already in the list */
55101 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
55102 #ifdef SWIGRUNTIME_DEBUG
55103 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
55104 #endif
55105 if (!ocast) ret = 0;
55106 }
55107 }
55108
55109 if (!ret) {
55110 #ifdef SWIGRUNTIME_DEBUG
55111 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
55112 #endif
55113 if (type->cast) {
55114 type->cast->prev = cast;
55115 cast->next = type->cast;
55116 }
55117 type->cast = cast;
55118 }
55119 cast++;
55120 }
55121 /* Set entry in modules->types array equal to the type */
55122 swig_module.types[i] = type;
55123 }
55124 swig_module.types[i] = 0;
55125
55126 #ifdef SWIGRUNTIME_DEBUG
55127 printf("**** SWIG_InitializeModule: Cast List ******\n");
55128 for (i = 0; i < swig_module.size; ++i) {
55129 int j = 0;
55130 swig_cast_info *cast = swig_module.cast_initial[i];
55131 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
55132 while (cast->type) {
55133 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
55134 cast++;
55135 ++j;
55136 }
55137 printf("---- Total casts: %d\n",j);
55138 }
55139 printf("**** SWIG_InitializeModule: Cast List ******\n");
55140 #endif
55141 }
55142
55143 /* This function will propagate the clientdata field of type to
55144 * any new swig_type_info structures that have been added into the list
55145 * of equivalent types. It is like calling
55146 * SWIG_TypeClientData(type, clientdata) a second time.
55147 */
55148 SWIGRUNTIME void
55149 SWIG_PropagateClientData(void) {
55150 size_t i;
55151 swig_cast_info *equiv;
55152 static int init_run = 0;
55153
55154 if (init_run) return;
55155 init_run = 1;
55156
55157 for (i = 0; i < swig_module.size; i++) {
55158 if (swig_module.types[i]->clientdata) {
55159 equiv = swig_module.types[i]->cast;
55160 while (equiv) {
55161 if (!equiv->converter) {
55162 if (equiv->type && !equiv->type->clientdata)
55163 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
55164 }
55165 equiv = equiv->next;
55166 }
55167 }
55168 }
55169 }
55170
55171 #ifdef __cplusplus
55172 #if 0
55173 {
55174 /* c-mode */
55175 #endif
55176 }
55177 #endif
55178
55179
55180
55181 #ifdef __cplusplus
55182 extern "C" {
55183 #endif
55184
55185 /* Python-specific SWIG API */
55186 #define SWIG_newvarlink() SWIG_Python_newvarlink()
55187 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
55188 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
55189
55190 /* -----------------------------------------------------------------------------
55191 * global variable support code.
55192 * ----------------------------------------------------------------------------- */
55193
55194 typedef struct swig_globalvar {
55195 char *name; /* Name of global variable */
55196 PyObject *(*get_attr)(void); /* Return the current value */
55197 int (*set_attr)(PyObject *); /* Set the value */
55198 struct swig_globalvar *next;
55199 } swig_globalvar;
55200
55201 typedef struct swig_varlinkobject {
55202 PyObject_HEAD
55203 swig_globalvar *vars;
55204 } swig_varlinkobject;
55205
55206 SWIGINTERN PyObject *
55207 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
55208 return PyString_FromString("<Swig global variables>");
55209 }
55210
55211 SWIGINTERN PyObject *
55212 swig_varlink_str(swig_varlinkobject *v) {
55213 PyObject *str = PyString_FromString("(");
55214 swig_globalvar *var;
55215 for (var = v->vars; var; var=var->next) {
55216 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
55217 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
55218 }
55219 PyString_ConcatAndDel(&str,PyString_FromString(")"));
55220 return str;
55221 }
55222
55223 SWIGINTERN int
55224 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
55225 PyObject *str = swig_varlink_str(v);
55226 fprintf(fp,"Swig global variables ");
55227 fprintf(fp,"%s\n", PyString_AsString(str));
55228 Py_DECREF(str);
55229 return 0;
55230 }
55231
55232 SWIGINTERN void
55233 swig_varlink_dealloc(swig_varlinkobject *v) {
55234 swig_globalvar *var = v->vars;
55235 while (var) {
55236 swig_globalvar *n = var->next;
55237 free(var->name);
55238 free(var);
55239 var = n;
55240 }
55241 }
55242
55243 SWIGINTERN PyObject *
55244 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
55245 PyObject *res = NULL;
55246 swig_globalvar *var = v->vars;
55247 while (var) {
55248 if (strcmp(var->name,n) == 0) {
55249 res = (*var->get_attr)();
55250 break;
55251 }
55252 var = var->next;
55253 }
55254 if (res == NULL && !PyErr_Occurred()) {
55255 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55256 }
55257 return res;
55258 }
55259
55260 SWIGINTERN int
55261 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
55262 int res = 1;
55263 swig_globalvar *var = v->vars;
55264 while (var) {
55265 if (strcmp(var->name,n) == 0) {
55266 res = (*var->set_attr)(p);
55267 break;
55268 }
55269 var = var->next;
55270 }
55271 if (res == 1 && !PyErr_Occurred()) {
55272 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55273 }
55274 return res;
55275 }
55276
55277 SWIGINTERN PyTypeObject*
55278 swig_varlink_type(void) {
55279 static char varlink__doc__[] = "Swig var link object";
55280 static PyTypeObject varlink_type;
55281 static int type_init = 0;
55282 if (!type_init) {
55283 const PyTypeObject tmp
55284 = {
55285 PyObject_HEAD_INIT(NULL)
55286 0, /* Number of items in variable part (ob_size) */
55287 (char *)"swigvarlink", /* Type name (tp_name) */
55288 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
55289 0, /* Itemsize (tp_itemsize) */
55290 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
55291 (printfunc) swig_varlink_print, /* Print (tp_print) */
55292 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
55293 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
55294 0, /* tp_compare */
55295 (reprfunc) swig_varlink_repr, /* tp_repr */
55296 0, /* tp_as_number */
55297 0, /* tp_as_sequence */
55298 0, /* tp_as_mapping */
55299 0, /* tp_hash */
55300 0, /* tp_call */
55301 (reprfunc)swig_varlink_str, /* tp_str */
55302 0, /* tp_getattro */
55303 0, /* tp_setattro */
55304 0, /* tp_as_buffer */
55305 0, /* tp_flags */
55306 varlink__doc__, /* tp_doc */
55307 0, /* tp_traverse */
55308 0, /* tp_clear */
55309 0, /* tp_richcompare */
55310 0, /* tp_weaklistoffset */
55311 #if PY_VERSION_HEX >= 0x02020000
55312 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
55313 #endif
55314 #if PY_VERSION_HEX >= 0x02030000
55315 0, /* tp_del */
55316 #endif
55317 #ifdef COUNT_ALLOCS
55318 0,0,0,0 /* tp_alloc -> tp_next */
55319 #endif
55320 };
55321 varlink_type = tmp;
55322 varlink_type.ob_type = &PyType_Type;
55323 type_init = 1;
55324 }
55325 return &varlink_type;
55326 }
55327
55328 /* Create a variable linking object for use later */
55329 SWIGINTERN PyObject *
55330 SWIG_Python_newvarlink(void) {
55331 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
55332 if (result) {
55333 result->vars = 0;
55334 }
55335 return ((PyObject*) result);
55336 }
55337
55338 SWIGINTERN void
55339 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
55340 swig_varlinkobject *v = (swig_varlinkobject *) p;
55341 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
55342 if (gv) {
55343 size_t size = strlen(name)+1;
55344 gv->name = (char *)malloc(size);
55345 if (gv->name) {
55346 strncpy(gv->name,name,size);
55347 gv->get_attr = get_attr;
55348 gv->set_attr = set_attr;
55349 gv->next = v->vars;
55350 }
55351 }
55352 v->vars = gv;
55353 }
55354
55355 SWIGINTERN PyObject *
55356 SWIG_globals() {
55357 static PyObject *_SWIG_globals = 0;
55358 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
55359 return _SWIG_globals;
55360 }
55361
55362 /* -----------------------------------------------------------------------------
55363 * constants/methods manipulation
55364 * ----------------------------------------------------------------------------- */
55365
55366 /* Install Constants */
55367 SWIGINTERN void
55368 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
55369 PyObject *obj = 0;
55370 size_t i;
55371 for (i = 0; constants[i].type; ++i) {
55372 switch(constants[i].type) {
55373 case SWIG_PY_POINTER:
55374 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
55375 break;
55376 case SWIG_PY_BINARY:
55377 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
55378 break;
55379 default:
55380 obj = 0;
55381 break;
55382 }
55383 if (obj) {
55384 PyDict_SetItemString(d, constants[i].name, obj);
55385 Py_DECREF(obj);
55386 }
55387 }
55388 }
55389
55390 /* -----------------------------------------------------------------------------*/
55391 /* Fix SwigMethods to carry the callback ptrs when needed */
55392 /* -----------------------------------------------------------------------------*/
55393
55394 SWIGINTERN void
55395 SWIG_Python_FixMethods(PyMethodDef *methods,
55396 swig_const_info *const_table,
55397 swig_type_info **types,
55398 swig_type_info **types_initial) {
55399 size_t i;
55400 for (i = 0; methods[i].ml_name; ++i) {
55401 char *c = methods[i].ml_doc;
55402 if (c && (c = strstr(c, "swig_ptr: "))) {
55403 int j;
55404 swig_const_info *ci = 0;
55405 char *name = c + 10;
55406 for (j = 0; const_table[j].type; ++j) {
55407 if (strncmp(const_table[j].name, name,
55408 strlen(const_table[j].name)) == 0) {
55409 ci = &(const_table[j]);
55410 break;
55411 }
55412 }
55413 if (ci) {
55414 size_t shift = (ci->ptype) - types;
55415 swig_type_info *ty = types_initial[shift];
55416 size_t ldoc = (c - methods[i].ml_doc);
55417 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
55418 char *ndoc = (char*)malloc(ldoc + lptr + 10);
55419 if (ndoc) {
55420 char *buff = ndoc;
55421 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
55422 if (ptr) {
55423 strncpy(buff, methods[i].ml_doc, ldoc);
55424 buff += ldoc;
55425 strncpy(buff, "swig_ptr: ", 10);
55426 buff += 10;
55427 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
55428 methods[i].ml_doc = ndoc;
55429 }
55430 }
55431 }
55432 }
55433 }
55434 }
55435
55436 #ifdef __cplusplus
55437 }
55438 #endif
55439
55440 /* -----------------------------------------------------------------------------*
55441 * Partial Init method
55442 * -----------------------------------------------------------------------------*/
55443
55444 #ifdef __cplusplus
55445 extern "C"
55446 #endif
55447 SWIGEXPORT void SWIG_init(void) {
55448 PyObject *m, *d;
55449
55450 /* Fix SwigMethods to carry the callback ptrs when needed */
55451 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
55452
55453 m = Py_InitModule((char *) SWIG_name, SwigMethods);
55454 d = PyModule_GetDict(m);
55455
55456 SWIG_InitializeModule(0);
55457 SWIG_InstallConstants(d,swig_const_table);
55458
55459
55460
55461 #ifndef wxPyUSE_EXPORT
55462 // Make our API structure a CObject so other modules can import it
55463 // from this module.
55464 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
55465 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
55466 Py_XDECREF(cobj);
55467 #endif
55468
55469 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
55470 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
55471 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
55472 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
55473 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
55474 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
55475 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
55476 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
55477 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
55478 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
55479 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
55480 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
55481 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
55482 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
55483 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
55484 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
55485 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
55486 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
55487 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
55488 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
55489 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
55490 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
55491 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
55492 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
55493 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
55494 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
55495 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
55496 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
55497 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
55498 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
55499 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
55500 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
55501 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
55502 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
55503 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
55504 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
55505 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
55506 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
55507 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
55508 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
55509 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
55510 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
55511 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
55512 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
55513 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
55514 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
55515 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
55516 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
55517 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
55518 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
55519 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
55520 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
55521 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
55522 SWIG_Python_SetConstant(d, "ST_DOTS_MIDDLE",SWIG_From_int(static_cast< int >(wxST_DOTS_MIDDLE)));
55523 SWIG_Python_SetConstant(d, "ST_DOTS_END",SWIG_From_int(static_cast< int >(wxST_DOTS_END)));
55524 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
55525 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
55526 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
55527 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
55528 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
55529 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
55530 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
55531 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
55532 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
55533 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
55534 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
55535 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
55536 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
55537 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
55538 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
55539 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
55540 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
55541 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
55542 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
55543 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
55544 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
55545 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
55546 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
55547 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
55548 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
55549 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
55550 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
55551 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
55552 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
55553 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
55554 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
55555 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
55556 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
55557 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
55558 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
55559 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
55560 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
55561 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
55562 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
55563 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
55564 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
55565 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
55566 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
55567 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
55568 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
55569 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
55570 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
55571 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
55572 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
55573 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
55574 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
55575 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
55576 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
55577 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
55578 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
55579 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
55580 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
55581 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
55582 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
55583 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
55584 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
55585 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
55586 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
55587 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
55588 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
55589 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
55590 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
55591 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
55592 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
55593 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
55594 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
55595 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
55596 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
55597 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
55598 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
55599 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
55600 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
55601 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
55602 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
55603 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
55604 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
55605 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
55606 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
55607 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
55608 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
55609 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
55610 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
55611 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
55612 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
55613 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
55614 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
55615 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
55616 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
55617 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
55618 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
55619 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
55620 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
55621 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
55622 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
55623 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
55624 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
55625 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
55626 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
55627 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
55628 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
55629 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
55630 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
55631 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
55632 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
55633 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
55634 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
55635 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
55636 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
55637 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
55638 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
55639 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
55640 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
55641 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
55642 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
55643 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
55644 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
55645 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
55646 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
55647 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
55648 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
55649 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
55650 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
55651 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
55652 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
55653 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
55654 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
55655 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
55656 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
55657 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
55658 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
55659 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
55660 SWIG_Python_SetConstant(d, "OPEN",SWIG_From_int(static_cast< int >(wxOPEN)));
55661 SWIG_Python_SetConstant(d, "SAVE",SWIG_From_int(static_cast< int >(wxSAVE)));
55662 SWIG_Python_SetConstant(d, "HIDE_READONLY",SWIG_From_int(static_cast< int >(wxHIDE_READONLY)));
55663 SWIG_Python_SetConstant(d, "OVERWRITE_PROMPT",SWIG_From_int(static_cast< int >(wxOVERWRITE_PROMPT)));
55664 SWIG_Python_SetConstant(d, "FILE_MUST_EXIST",SWIG_From_int(static_cast< int >(wxFILE_MUST_EXIST)));
55665 SWIG_Python_SetConstant(d, "MULTIPLE",SWIG_From_int(static_cast< int >(wxMULTIPLE)));
55666 SWIG_Python_SetConstant(d, "CHANGE_DIR",SWIG_From_int(static_cast< int >(wxCHANGE_DIR)));
55667 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
55668 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
55669 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
55670 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
55671 SWIG_Python_SetConstant(d, "PD_AUTO_HIDE",SWIG_From_int(static_cast< int >(wxPD_AUTO_HIDE)));
55672 SWIG_Python_SetConstant(d, "PD_APP_MODAL",SWIG_From_int(static_cast< int >(wxPD_APP_MODAL)));
55673 SWIG_Python_SetConstant(d, "PD_CAN_ABORT",SWIG_From_int(static_cast< int >(wxPD_CAN_ABORT)));
55674 SWIG_Python_SetConstant(d, "PD_ELAPSED_TIME",SWIG_From_int(static_cast< int >(wxPD_ELAPSED_TIME)));
55675 SWIG_Python_SetConstant(d, "PD_ESTIMATED_TIME",SWIG_From_int(static_cast< int >(wxPD_ESTIMATED_TIME)));
55676 SWIG_Python_SetConstant(d, "PD_REMAINING_TIME",SWIG_From_int(static_cast< int >(wxPD_REMAINING_TIME)));
55677 SWIG_Python_SetConstant(d, "PD_SMOOTH",SWIG_From_int(static_cast< int >(wxPD_SMOOTH)));
55678 SWIG_Python_SetConstant(d, "PD_CAN_SKIP",SWIG_From_int(static_cast< int >(wxPD_CAN_SKIP)));
55679 SWIG_Python_SetConstant(d, "DD_NEW_DIR_BUTTON",SWIG_From_int(static_cast< int >(wxDD_NEW_DIR_BUTTON)));
55680 SWIG_Python_SetConstant(d, "DD_DEFAULT_STYLE",SWIG_From_int(static_cast< int >(wxDD_DEFAULT_STYLE)));
55681 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
55682 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
55683 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
55684 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
55685 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
55686 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
55687 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
55688 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
55689 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
55690 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
55691 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
55692 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
55693 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
55694 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
55695 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
55696 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
55697 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
55698 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
55699 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
55700 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
55701 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
55702 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
55703 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
55704 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
55705 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
55706 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
55707 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
55708 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
55709 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
55710 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
55711 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
55712 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
55713 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
55714 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
55715 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
55716 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
55717 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
55718 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
55719 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
55720 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
55721 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
55722 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
55723 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
55724 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
55725 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
55726 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
55727 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
55728 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
55729 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
55730 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
55731 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
55732 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
55733 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
55734 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
55735 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
55736 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
55737 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
55738 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
55739 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
55740 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
55741 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
55742 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
55743 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
55744 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
55745 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
55746 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
55747 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
55748 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
55749 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
55750 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
55751 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
55752 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
55753 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
55754 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
55755 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
55756 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
55757 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
55758 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
55759 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
55760 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
55761 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
55762 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
55763 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
55764 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
55765 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
55766 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
55767 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
55768 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
55769 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
55770 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
55771 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
55772 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
55773 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
55774 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
55775 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
55776 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
55777 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
55778 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
55779 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
55780 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
55781 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
55782 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
55783 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
55784 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
55785 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
55786 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
55787 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
55788 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
55789 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
55790 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
55791 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
55792 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
55793 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
55794 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
55795 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
55796 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
55797 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
55798 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
55799 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
55800 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
55801 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
55802 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
55803 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
55804 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
55805 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
55806 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
55807 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
55808 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
55809 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
55810 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
55811 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
55812 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
55813 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
55814 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
55815 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
55816 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
55817 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
55818 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
55819 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
55820 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
55821 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
55822 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
55823 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
55824 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
55825 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
55826 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
55827 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
55828 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
55829 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
55830 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
55831 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
55832 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
55833 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
55834 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
55835 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
55836 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
55837 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
55838 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
55839 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
55840 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
55841 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
55842 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
55843 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
55844 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
55845 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
55846 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
55847 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
55848 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
55849 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
55850 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
55851 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
55852 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
55853 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
55854 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
55855 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
55856 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
55857 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
55858 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
55859 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
55860 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
55861 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
55862 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
55863 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
55864 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
55865 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
55866 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
55867 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
55868 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
55869 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
55870 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
55871 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
55872 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
55873 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
55874 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
55875 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
55876 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
55877 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
55878 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
55879 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
55880 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
55881 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
55882 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
55883 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
55884 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
55885 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
55886 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
55887 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
55888 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
55889 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
55890 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
55891 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
55892 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
55893 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
55894 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
55895 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
55896 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
55897 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
55898 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
55899 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
55900 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
55901 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
55902 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
55903 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
55904 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
55905 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
55906 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
55907 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
55908 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
55909 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
55910 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
55911 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
55912 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
55913 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
55914 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
55915 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
55916 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
55917 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
55918 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
55919 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
55920 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
55921 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
55922 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
55923 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
55924 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
55925 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
55926 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
55927 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
55928 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
55929 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
55930 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
55931 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
55932 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
55933 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
55934 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
55935 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
55936 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
55937 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
55938 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
55939 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
55940 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
55941 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
55942 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
55943 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
55944 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
55945 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
55946 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
55947 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
55948 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
55949 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
55950 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
55951 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
55952 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
55953 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
55954 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
55955 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
55956 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
55957 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
55958 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
55959 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
55960 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
55961 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
55962 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
55963 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
55964 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
55965 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
55966 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
55967 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
55968 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
55969 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
55970 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
55971 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
55972 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
55973 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
55974 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
55975 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
55976 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
55977 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
55978 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
55979 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
55980 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
55981 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
55982 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
55983 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
55984 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
55985 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
55986 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
55987 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
55988 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
55989 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
55990 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
55991 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
55992 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
55993 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
55994 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
55995 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
55996 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
55997 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
55998 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
55999 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
56000 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
56001 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
56002 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
56003 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
56004 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
56005 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
56006 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
56007 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
56008 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
56009 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
56010 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
56011 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
56012 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
56013 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
56014 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
56015 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
56016 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
56017 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
56018 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
56019 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
56020 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
56021 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
56022 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
56023 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
56024 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
56025 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
56026 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
56027 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
56028 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
56029 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
56030 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
56031 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
56032 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
56033 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
56034 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
56035 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
56036 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
56037 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
56038 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
56039 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
56040 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
56041 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
56042 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
56043 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
56044 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
56045 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
56046 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
56047 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
56048 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
56049 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
56050 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
56051 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
56052 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
56053 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
56054 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
56055 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
56056 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
56057 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
56058 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
56059 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
56060 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
56061 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
56062 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
56063 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
56064 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
56065 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
56066 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
56067 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
56068 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
56069 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
56070 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
56071 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
56072 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
56073 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
56074 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
56075 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
56076 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
56077 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
56078 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
56079 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
56080 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
56081 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
56082 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
56083 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
56084 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
56085 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
56086 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
56087 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
56088 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
56089 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
56090 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
56091 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
56092 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
56093 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
56094 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
56095 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
56096 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
56097 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
56098 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
56099 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
56100 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
56101 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
56102 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
56103 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
56104 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
56105 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
56106 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
56107 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
56108 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
56109 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
56110 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
56111 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
56112 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
56113 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
56114 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
56115 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
56116 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
56117 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
56118 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
56119 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
56120 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
56121 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
56122 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
56123 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
56124 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
56125 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
56126 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
56127 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
56128 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
56129 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
56130 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
56131 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
56132 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
56133 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
56134 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
56135 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
56136 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
56137 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
56138 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
56139 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
56140
56141 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
56142
56143
56144 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
56145
56146 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
56147 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
56148 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
56149 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
56150 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
56151 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
56152 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
56153 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
56154 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
56155 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
56156 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
56157 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
56158 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
56159 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
56160 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
56161 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
56162 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
56163 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
56164 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
56165 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
56166 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
56167 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
56168 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
56169 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
56170 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
56171 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
56172 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
56173 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
56174 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
56175 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
56176 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
56177 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
56178 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
56179 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
56180 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
56181 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
56182 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
56183 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
56184 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
56185 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
56186 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
56187 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
56188 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
56189 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
56190 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
56191 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
56192 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
56193 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
56194 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
56195 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
56196 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
56197 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
56198 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
56199 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
56200 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
56201 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
56202 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
56203 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
56204 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
56205 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
56206 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
56207 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
56208 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
56209 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
56210 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
56211 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
56212 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
56213 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
56214 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
56215 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
56216 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
56217 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
56218 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
56219 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
56220 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
56221 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
56222 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
56223 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
56224 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
56225 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
56226 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
56227 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
56228 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
56229 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
56230 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
56231 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
56232 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
56233 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
56234 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
56235 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
56236 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
56237 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
56238 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
56239 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
56240 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
56241 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
56242 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
56243 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
56244 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
56245 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
56246 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
56247 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
56248 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
56249 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
56250 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
56251 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
56252 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
56253 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
56254 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
56255 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
56256 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
56257 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
56258 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
56259 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
56260 PyDict_SetItemString(d, "wxEVT_POWER", PyInt_FromLong(wxEVT_POWER));
56261 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
56262 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
56263 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
56264 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
56265 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
56266 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
56267 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
56268 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
56269 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
56270 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
56271 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
56272 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
56273 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
56274 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
56275 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
56276 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
56277 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
56278 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
56279 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
56280 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
56281 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
56282 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
56283 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
56284 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
56285 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
56286 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
56287 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
56288 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
56289 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
56290 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
56291 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
56292 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
56293 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
56294 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
56295 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
56296 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
56297 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
56298 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
56299 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
56300 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
56301 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
56302 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
56303 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
56304 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
56305 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
56306 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
56307 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
56308 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
56309 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
56310 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
56311 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
56312 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
56313 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
56314 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
56315 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
56316 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
56317 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
56318 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
56319 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
56320 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
56321 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
56322 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
56323 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
56324 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
56325 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
56326 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
56327 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
56328 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
56329 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
56330 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
56331 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
56332 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
56333 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
56334 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
56335 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
56336 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
56337 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
56338 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
56339 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
56340 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
56341 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
56342 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
56343 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
56344 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
56345 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
56346 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
56347 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
56348 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
56349 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
56350
56351 // Initialize threading, some globals and such
56352 __wxPyPreStart(d);
56353
56354
56355 // Although these are defined in __version__ they need to be here too so
56356 // that an assert can be done to ensure that the wxPython and the wxWindows
56357 // versions match.
56358 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
56359 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
56360 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
56361
56362 }
56363
wxWidgets (Impactor)