]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/mac/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
reSWIGged
[wxWidgets.git] / wxPython / src / mac / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 /* for raw pointers */
989 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
990 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
991 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
992 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
993 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
994 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
995 #define swig_owntype int
996
997 /* for raw packed data */
998 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
999 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1000
1001 /* for class or struct pointers */
1002 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1003 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1004
1005 /* for C or C++ function pointers */
1006 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1007 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1008
1009 /* for C++ member pointers, ie, member methods */
1010 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1011 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1012
1013
1014 /* Runtime API */
1015
1016 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1017 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1018 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1019
1020 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1021 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1022 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1023 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1024 #define SWIG_fail goto fail
1025
1026
1027 /* Runtime API implementation */
1028
1029 /* Error manipulation */
1030
1031 SWIGINTERN void
1032 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1033 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1034 PyErr_SetObject(errtype, obj);
1035 Py_DECREF(obj);
1036 SWIG_PYTHON_THREAD_END_BLOCK;
1037 }
1038
1039 SWIGINTERN void
1040 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1041 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1042 PyErr_SetString(errtype, (char *) msg);
1043 SWIG_PYTHON_THREAD_END_BLOCK;
1044 }
1045
1046 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1047
1048 /* Set a constant value */
1049
1050 SWIGINTERN void
1051 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1052 PyDict_SetItemString(d, (char*) name, obj);
1053 Py_DECREF(obj);
1054 }
1055
1056 /* Append a value to the result obj */
1057
1058 SWIGINTERN PyObject*
1059 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1060 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1061 if (!result) {
1062 result = obj;
1063 } else if (result == Py_None) {
1064 Py_DECREF(result);
1065 result = obj;
1066 } else {
1067 if (!PyList_Check(result)) {
1068 PyObject *o2 = result;
1069 result = PyList_New(1);
1070 PyList_SetItem(result, 0, o2);
1071 }
1072 PyList_Append(result,obj);
1073 Py_DECREF(obj);
1074 }
1075 return result;
1076 #else
1077 PyObject* o2;
1078 PyObject* o3;
1079 if (!result) {
1080 result = obj;
1081 } else if (result == Py_None) {
1082 Py_DECREF(result);
1083 result = obj;
1084 } else {
1085 if (!PyTuple_Check(result)) {
1086 o2 = result;
1087 result = PyTuple_New(1);
1088 PyTuple_SET_ITEM(result, 0, o2);
1089 }
1090 o3 = PyTuple_New(1);
1091 PyTuple_SET_ITEM(o3, 0, obj);
1092 o2 = result;
1093 result = PySequence_Concat(o2, o3);
1094 Py_DECREF(o2);
1095 Py_DECREF(o3);
1096 }
1097 return result;
1098 #endif
1099 }
1100
1101 /* Unpack the argument tuple */
1102
1103 SWIGINTERN int
1104 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1105 {
1106 if (!args) {
1107 if (!min && !max) {
1108 return 1;
1109 } else {
1110 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1111 name, (min == max ? "" : "at least "), min);
1112 return 0;
1113 }
1114 }
1115 if (!PyTuple_Check(args)) {
1116 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1117 return 0;
1118 } else {
1119 register int l = PyTuple_GET_SIZE(args);
1120 if (l < min) {
1121 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1122 name, (min == max ? "" : "at least "), min, l);
1123 return 0;
1124 } else if (l > max) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at most "), max, l);
1127 return 0;
1128 } else {
1129 register int i;
1130 for (i = 0; i < l; ++i) {
1131 objs[i] = PyTuple_GET_ITEM(args, i);
1132 }
1133 for (; l < max; ++l) {
1134 objs[l] = 0;
1135 }
1136 return i + 1;
1137 }
1138 }
1139 }
1140
1141 /* A functor is a function object with one single object argument */
1142 #if PY_VERSION_HEX >= 0x02020000
1143 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1144 #else
1145 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1146 #endif
1147
1148 /*
1149 Helper for static pointer initialization for both C and C++ code, for example
1150 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1151 */
1152 #ifdef __cplusplus
1153 #define SWIG_STATIC_POINTER(var) var
1154 #else
1155 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1156 #endif
1157
1158 /* -----------------------------------------------------------------------------
1159 * Pointer declarations
1160 * ----------------------------------------------------------------------------- */
1161
1162 /* Flags for new pointer objects */
1163 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1164 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1165
1166 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1167
1168 #ifdef __cplusplus
1169 extern "C" {
1170 #if 0
1171 } /* cc-mode */
1172 #endif
1173 #endif
1174
1175 /* How to access Py_None */
1176 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1177 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1178 # ifndef SWIG_PYTHON_BUILD_NONE
1179 # define SWIG_PYTHON_BUILD_NONE
1180 # endif
1181 # endif
1182 #endif
1183
1184 #ifdef SWIG_PYTHON_BUILD_NONE
1185 # ifdef Py_None
1186 # undef Py_None
1187 # define Py_None SWIG_Py_None()
1188 # endif
1189 SWIGRUNTIMEINLINE PyObject *
1190 _SWIG_Py_None(void)
1191 {
1192 PyObject *none = Py_BuildValue("");
1193 Py_DECREF(none);
1194 return none;
1195 }
1196 SWIGRUNTIME PyObject *
1197 SWIG_Py_None(void)
1198 {
1199 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1200 return none;
1201 }
1202 #endif
1203
1204 /* The python void return value */
1205
1206 SWIGRUNTIMEINLINE PyObject *
1207 SWIG_Py_Void(void)
1208 {
1209 PyObject *none = Py_None;
1210 Py_INCREF(none);
1211 return none;
1212 }
1213
1214 /* PySwigClientData */
1215
1216 typedef struct {
1217 PyObject *klass;
1218 PyObject *newraw;
1219 PyObject *newargs;
1220 PyObject *destroy;
1221 int delargs;
1222 int implicitconv;
1223 } PySwigClientData;
1224
1225 SWIGRUNTIMEINLINE int
1226 SWIG_Python_CheckImplicit(swig_type_info *ty)
1227 {
1228 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1229 return data ? data->implicitconv : 0;
1230 }
1231
1232 SWIGRUNTIMEINLINE PyObject *
1233 SWIG_Python_ExceptionType(swig_type_info *desc) {
1234 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1235 PyObject *klass = data ? data->klass : 0;
1236 return (klass ? klass : PyExc_RuntimeError);
1237 }
1238
1239
1240 SWIGRUNTIME PySwigClientData *
1241 PySwigClientData_New(PyObject* obj)
1242 {
1243 if (!obj) {
1244 return 0;
1245 } else {
1246 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1247 /* the klass element */
1248 data->klass = obj;
1249 Py_INCREF(data->klass);
1250 /* the newraw method and newargs arguments used to create a new raw instance */
1251 if (PyClass_Check(obj)) {
1252 data->newraw = 0;
1253 data->newargs = obj;
1254 Py_INCREF(obj);
1255 } else {
1256 #if (PY_VERSION_HEX < 0x02020000)
1257 data->newraw = 0;
1258 #else
1259 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1260 #endif
1261 if (data->newraw) {
1262 Py_INCREF(data->newraw);
1263 data->newargs = PyTuple_New(1);
1264 PyTuple_SetItem(data->newargs, 0, obj);
1265 } else {
1266 data->newargs = obj;
1267 }
1268 Py_INCREF(data->newargs);
1269 }
1270 /* the destroy method, aka as the C++ delete method */
1271 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1272 if (PyErr_Occurred()) {
1273 PyErr_Clear();
1274 data->destroy = 0;
1275 }
1276 if (data->destroy) {
1277 int flags;
1278 Py_INCREF(data->destroy);
1279 flags = PyCFunction_GET_FLAGS(data->destroy);
1280 #ifdef METH_O
1281 data->delargs = !(flags & (METH_O));
1282 #else
1283 data->delargs = 0;
1284 #endif
1285 } else {
1286 data->delargs = 0;
1287 }
1288 data->implicitconv = 0;
1289 return data;
1290 }
1291 }
1292
1293 SWIGRUNTIME void
1294 PySwigClientData_Del(PySwigClientData* data)
1295 {
1296 Py_XDECREF(data->newraw);
1297 Py_XDECREF(data->newargs);
1298 Py_XDECREF(data->destroy);
1299 }
1300
1301 /* =============== PySwigObject =====================*/
1302
1303 typedef struct {
1304 PyObject_HEAD
1305 void *ptr;
1306 swig_type_info *ty;
1307 int own;
1308 PyObject *next;
1309 } PySwigObject;
1310
1311 SWIGRUNTIME PyObject *
1312 PySwigObject_long(PySwigObject *v)
1313 {
1314 return PyLong_FromVoidPtr(v->ptr);
1315 }
1316
1317 SWIGRUNTIME PyObject *
1318 PySwigObject_format(const char* fmt, PySwigObject *v)
1319 {
1320 PyObject *res = NULL;
1321 PyObject *args = PyTuple_New(1);
1322 if (args) {
1323 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1324 PyObject *ofmt = PyString_FromString(fmt);
1325 if (ofmt) {
1326 res = PyString_Format(ofmt,args);
1327 Py_DECREF(ofmt);
1328 }
1329 Py_DECREF(args);
1330 }
1331 }
1332 return res;
1333 }
1334
1335 SWIGRUNTIME PyObject *
1336 PySwigObject_oct(PySwigObject *v)
1337 {
1338 return PySwigObject_format("%o",v);
1339 }
1340
1341 SWIGRUNTIME PyObject *
1342 PySwigObject_hex(PySwigObject *v)
1343 {
1344 return PySwigObject_format("%x",v);
1345 }
1346
1347 SWIGRUNTIME PyObject *
1348 #ifdef METH_NOARGS
1349 PySwigObject_repr(PySwigObject *v)
1350 #else
1351 PySwigObject_repr(PySwigObject *v, PyObject *args)
1352 #endif
1353 {
1354 const char *name = SWIG_TypePrettyName(v->ty);
1355 PyObject *hex = PySwigObject_hex(v);
1356 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1357 Py_DECREF(hex);
1358 if (v->next) {
1359 #ifdef METH_NOARGS
1360 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1361 #else
1362 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1363 #endif
1364 PyString_ConcatAndDel(&repr,nrep);
1365 }
1366 return repr;
1367 }
1368
1369 SWIGRUNTIME int
1370 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1371 {
1372 #ifdef METH_NOARGS
1373 PyObject *repr = PySwigObject_repr(v);
1374 #else
1375 PyObject *repr = PySwigObject_repr(v, NULL);
1376 #endif
1377 if (repr) {
1378 fputs(PyString_AsString(repr), fp);
1379 Py_DECREF(repr);
1380 return 0;
1381 } else {
1382 return 1;
1383 }
1384 }
1385
1386 SWIGRUNTIME PyObject *
1387 PySwigObject_str(PySwigObject *v)
1388 {
1389 char result[SWIG_BUFFER_SIZE];
1390 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1391 PyString_FromString(result) : 0;
1392 }
1393
1394 SWIGRUNTIME int
1395 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1396 {
1397 void *i = v->ptr;
1398 void *j = w->ptr;
1399 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1400 }
1401
1402 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1403
1404 SWIGRUNTIME PyTypeObject*
1405 PySwigObject_type(void) {
1406 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1407 return type;
1408 }
1409
1410 SWIGRUNTIMEINLINE int
1411 PySwigObject_Check(PyObject *op) {
1412 return ((op)->ob_type == PySwigObject_type())
1413 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1414 }
1415
1416 SWIGRUNTIME PyObject *
1417 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1418
1419 SWIGRUNTIME void
1420 PySwigObject_dealloc(PyObject *v)
1421 {
1422 PySwigObject *sobj = (PySwigObject *) v;
1423 PyObject *next = sobj->next;
1424 if (sobj->own) {
1425 swig_type_info *ty = sobj->ty;
1426 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1427 PyObject *destroy = data ? data->destroy : 0;
1428 if (destroy) {
1429 /* destroy is always a VARARGS method */
1430 PyObject *res;
1431 if (data->delargs) {
1432 /* we need to create a temporal object to carry the destroy operation */
1433 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1434 res = SWIG_Python_CallFunctor(destroy, tmp);
1435 Py_DECREF(tmp);
1436 } else {
1437 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1438 PyObject *mself = PyCFunction_GET_SELF(destroy);
1439 res = ((*meth)(mself, v));
1440 }
1441 Py_XDECREF(res);
1442 } else {
1443 const char *name = SWIG_TypePrettyName(ty);
1444 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1445 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1446 #endif
1447 }
1448 }
1449 Py_XDECREF(next);
1450 PyObject_DEL(v);
1451 }
1452
1453 SWIGRUNTIME PyObject*
1454 PySwigObject_append(PyObject* v, PyObject* next)
1455 {
1456 PySwigObject *sobj = (PySwigObject *) v;
1457 #ifndef METH_O
1458 PyObject *tmp = 0;
1459 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1460 next = tmp;
1461 #endif
1462 if (!PySwigObject_Check(next)) {
1463 return NULL;
1464 }
1465 sobj->next = next;
1466 Py_INCREF(next);
1467 return SWIG_Py_Void();
1468 }
1469
1470 SWIGRUNTIME PyObject*
1471 #ifdef METH_NOARGS
1472 PySwigObject_next(PyObject* v)
1473 #else
1474 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1475 #endif
1476 {
1477 PySwigObject *sobj = (PySwigObject *) v;
1478 if (sobj->next) {
1479 Py_INCREF(sobj->next);
1480 return sobj->next;
1481 } else {
1482 return SWIG_Py_Void();
1483 }
1484 }
1485
1486 SWIGINTERN PyObject*
1487 #ifdef METH_NOARGS
1488 PySwigObject_disown(PyObject *v)
1489 #else
1490 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1491 #endif
1492 {
1493 PySwigObject *sobj = (PySwigObject *)v;
1494 sobj->own = 0;
1495 return SWIG_Py_Void();
1496 }
1497
1498 SWIGINTERN PyObject*
1499 #ifdef METH_NOARGS
1500 PySwigObject_acquire(PyObject *v)
1501 #else
1502 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1503 #endif
1504 {
1505 PySwigObject *sobj = (PySwigObject *)v;
1506 sobj->own = SWIG_POINTER_OWN;
1507 return SWIG_Py_Void();
1508 }
1509
1510 SWIGINTERN PyObject*
1511 PySwigObject_own(PyObject *v, PyObject *args)
1512 {
1513 PyObject *val = 0;
1514 #if (PY_VERSION_HEX < 0x02020000)
1515 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1516 #else
1517 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1518 #endif
1519 {
1520 return NULL;
1521 }
1522 else
1523 {
1524 PySwigObject *sobj = (PySwigObject *)v;
1525 PyObject *obj = PyBool_FromLong(sobj->own);
1526 if (val) {
1527 #ifdef METH_NOARGS
1528 if (PyObject_IsTrue(val)) {
1529 PySwigObject_acquire(v);
1530 } else {
1531 PySwigObject_disown(v);
1532 }
1533 #else
1534 if (PyObject_IsTrue(val)) {
1535 PySwigObject_acquire(v,args);
1536 } else {
1537 PySwigObject_disown(v,args);
1538 }
1539 #endif
1540 }
1541 return obj;
1542 }
1543 }
1544
1545 #ifdef METH_O
1546 static PyMethodDef
1547 swigobject_methods[] = {
1548 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1549 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1550 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1551 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1552 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1553 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1554 {0, 0, 0, 0}
1555 };
1556 #else
1557 static PyMethodDef
1558 swigobject_methods[] = {
1559 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1560 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1561 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1562 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1563 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1564 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1565 {0, 0, 0, 0}
1566 };
1567 #endif
1568
1569 #if PY_VERSION_HEX < 0x02020000
1570 SWIGINTERN PyObject *
1571 PySwigObject_getattr(PySwigObject *sobj,char *name)
1572 {
1573 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1574 }
1575 #endif
1576
1577 SWIGRUNTIME PyTypeObject*
1578 _PySwigObject_type(void) {
1579 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1580
1581 static PyNumberMethods PySwigObject_as_number = {
1582 (binaryfunc)0, /*nb_add*/
1583 (binaryfunc)0, /*nb_subtract*/
1584 (binaryfunc)0, /*nb_multiply*/
1585 (binaryfunc)0, /*nb_divide*/
1586 (binaryfunc)0, /*nb_remainder*/
1587 (binaryfunc)0, /*nb_divmod*/
1588 (ternaryfunc)0,/*nb_power*/
1589 (unaryfunc)0, /*nb_negative*/
1590 (unaryfunc)0, /*nb_positive*/
1591 (unaryfunc)0, /*nb_absolute*/
1592 (inquiry)0, /*nb_nonzero*/
1593 0, /*nb_invert*/
1594 0, /*nb_lshift*/
1595 0, /*nb_rshift*/
1596 0, /*nb_and*/
1597 0, /*nb_xor*/
1598 0, /*nb_or*/
1599 (coercion)0, /*nb_coerce*/
1600 (unaryfunc)PySwigObject_long, /*nb_int*/
1601 (unaryfunc)PySwigObject_long, /*nb_long*/
1602 (unaryfunc)0, /*nb_float*/
1603 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1604 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1605 #if PY_VERSION_HEX >= 0x02020000
1606 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1607 #elif PY_VERSION_HEX >= 0x02000000
1608 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1609 #endif
1610 };
1611
1612 static PyTypeObject pyswigobject_type;
1613 static int type_init = 0;
1614 if (!type_init) {
1615 const PyTypeObject tmp
1616 = {
1617 PyObject_HEAD_INIT(NULL)
1618 0, /* ob_size */
1619 (char *)"PySwigObject", /* tp_name */
1620 sizeof(PySwigObject), /* tp_basicsize */
1621 0, /* tp_itemsize */
1622 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1623 (printfunc)PySwigObject_print, /* tp_print */
1624 #if PY_VERSION_HEX < 0x02020000
1625 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1626 #else
1627 (getattrfunc)0, /* tp_getattr */
1628 #endif
1629 (setattrfunc)0, /* tp_setattr */
1630 (cmpfunc)PySwigObject_compare, /* tp_compare */
1631 (reprfunc)PySwigObject_repr, /* tp_repr */
1632 &PySwigObject_as_number, /* tp_as_number */
1633 0, /* tp_as_sequence */
1634 0, /* tp_as_mapping */
1635 (hashfunc)0, /* tp_hash */
1636 (ternaryfunc)0, /* tp_call */
1637 (reprfunc)PySwigObject_str, /* tp_str */
1638 PyObject_GenericGetAttr, /* tp_getattro */
1639 0, /* tp_setattro */
1640 0, /* tp_as_buffer */
1641 Py_TPFLAGS_DEFAULT, /* tp_flags */
1642 swigobject_doc, /* tp_doc */
1643 0, /* tp_traverse */
1644 0, /* tp_clear */
1645 0, /* tp_richcompare */
1646 0, /* tp_weaklistoffset */
1647 #if PY_VERSION_HEX >= 0x02020000
1648 0, /* tp_iter */
1649 0, /* tp_iternext */
1650 swigobject_methods, /* tp_methods */
1651 0, /* tp_members */
1652 0, /* tp_getset */
1653 0, /* tp_base */
1654 0, /* tp_dict */
1655 0, /* tp_descr_get */
1656 0, /* tp_descr_set */
1657 0, /* tp_dictoffset */
1658 0, /* tp_init */
1659 0, /* tp_alloc */
1660 0, /* tp_new */
1661 0, /* tp_free */
1662 0, /* tp_is_gc */
1663 0, /* tp_bases */
1664 0, /* tp_mro */
1665 0, /* tp_cache */
1666 0, /* tp_subclasses */
1667 0, /* tp_weaklist */
1668 #endif
1669 #if PY_VERSION_HEX >= 0x02030000
1670 0, /* tp_del */
1671 #endif
1672 #ifdef COUNT_ALLOCS
1673 0,0,0,0 /* tp_alloc -> tp_next */
1674 #endif
1675 };
1676 pyswigobject_type = tmp;
1677 pyswigobject_type.ob_type = &PyType_Type;
1678 type_init = 1;
1679 }
1680 return &pyswigobject_type;
1681 }
1682
1683 SWIGRUNTIME PyObject *
1684 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1685 {
1686 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1687 if (sobj) {
1688 sobj->ptr = ptr;
1689 sobj->ty = ty;
1690 sobj->own = own;
1691 sobj->next = 0;
1692 }
1693 return (PyObject *)sobj;
1694 }
1695
1696 /* -----------------------------------------------------------------------------
1697 * Implements a simple Swig Packed type, and use it instead of string
1698 * ----------------------------------------------------------------------------- */
1699
1700 typedef struct {
1701 PyObject_HEAD
1702 void *pack;
1703 swig_type_info *ty;
1704 size_t size;
1705 } PySwigPacked;
1706
1707 SWIGRUNTIME int
1708 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1709 {
1710 char result[SWIG_BUFFER_SIZE];
1711 fputs("<Swig Packed ", fp);
1712 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1713 fputs("at ", fp);
1714 fputs(result, fp);
1715 }
1716 fputs(v->ty->name,fp);
1717 fputs(">", fp);
1718 return 0;
1719 }
1720
1721 SWIGRUNTIME PyObject *
1722 PySwigPacked_repr(PySwigPacked *v)
1723 {
1724 char result[SWIG_BUFFER_SIZE];
1725 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1726 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1727 } else {
1728 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1729 }
1730 }
1731
1732 SWIGRUNTIME PyObject *
1733 PySwigPacked_str(PySwigPacked *v)
1734 {
1735 char result[SWIG_BUFFER_SIZE];
1736 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1737 return PyString_FromFormat("%s%s", result, v->ty->name);
1738 } else {
1739 return PyString_FromString(v->ty->name);
1740 }
1741 }
1742
1743 SWIGRUNTIME int
1744 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1745 {
1746 size_t i = v->size;
1747 size_t j = w->size;
1748 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1749 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1750 }
1751
1752 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1753
1754 SWIGRUNTIME PyTypeObject*
1755 PySwigPacked_type(void) {
1756 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1757 return type;
1758 }
1759
1760 SWIGRUNTIMEINLINE int
1761 PySwigPacked_Check(PyObject *op) {
1762 return ((op)->ob_type == _PySwigPacked_type())
1763 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1764 }
1765
1766 SWIGRUNTIME void
1767 PySwigPacked_dealloc(PyObject *v)
1768 {
1769 if (PySwigPacked_Check(v)) {
1770 PySwigPacked *sobj = (PySwigPacked *) v;
1771 free(sobj->pack);
1772 }
1773 PyObject_DEL(v);
1774 }
1775
1776 SWIGRUNTIME PyTypeObject*
1777 _PySwigPacked_type(void) {
1778 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1779 static PyTypeObject pyswigpacked_type;
1780 static int type_init = 0;
1781 if (!type_init) {
1782 const PyTypeObject tmp
1783 = {
1784 PyObject_HEAD_INIT(NULL)
1785 0, /* ob_size */
1786 (char *)"PySwigPacked", /* tp_name */
1787 sizeof(PySwigPacked), /* tp_basicsize */
1788 0, /* tp_itemsize */
1789 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1790 (printfunc)PySwigPacked_print, /* tp_print */
1791 (getattrfunc)0, /* tp_getattr */
1792 (setattrfunc)0, /* tp_setattr */
1793 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1794 (reprfunc)PySwigPacked_repr, /* tp_repr */
1795 0, /* tp_as_number */
1796 0, /* tp_as_sequence */
1797 0, /* tp_as_mapping */
1798 (hashfunc)0, /* tp_hash */
1799 (ternaryfunc)0, /* tp_call */
1800 (reprfunc)PySwigPacked_str, /* tp_str */
1801 PyObject_GenericGetAttr, /* tp_getattro */
1802 0, /* tp_setattro */
1803 0, /* tp_as_buffer */
1804 Py_TPFLAGS_DEFAULT, /* tp_flags */
1805 swigpacked_doc, /* tp_doc */
1806 0, /* tp_traverse */
1807 0, /* tp_clear */
1808 0, /* tp_richcompare */
1809 0, /* tp_weaklistoffset */
1810 #if PY_VERSION_HEX >= 0x02020000
1811 0, /* tp_iter */
1812 0, /* tp_iternext */
1813 0, /* tp_methods */
1814 0, /* tp_members */
1815 0, /* tp_getset */
1816 0, /* tp_base */
1817 0, /* tp_dict */
1818 0, /* tp_descr_get */
1819 0, /* tp_descr_set */
1820 0, /* tp_dictoffset */
1821 0, /* tp_init */
1822 0, /* tp_alloc */
1823 0, /* tp_new */
1824 0, /* tp_free */
1825 0, /* tp_is_gc */
1826 0, /* tp_bases */
1827 0, /* tp_mro */
1828 0, /* tp_cache */
1829 0, /* tp_subclasses */
1830 0, /* tp_weaklist */
1831 #endif
1832 #if PY_VERSION_HEX >= 0x02030000
1833 0, /* tp_del */
1834 #endif
1835 #ifdef COUNT_ALLOCS
1836 0,0,0,0 /* tp_alloc -> tp_next */
1837 #endif
1838 };
1839 pyswigpacked_type = tmp;
1840 pyswigpacked_type.ob_type = &PyType_Type;
1841 type_init = 1;
1842 }
1843 return &pyswigpacked_type;
1844 }
1845
1846 SWIGRUNTIME PyObject *
1847 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1848 {
1849 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1850 if (sobj) {
1851 void *pack = malloc(size);
1852 if (pack) {
1853 memcpy(pack, ptr, size);
1854 sobj->pack = pack;
1855 sobj->ty = ty;
1856 sobj->size = size;
1857 } else {
1858 PyObject_DEL((PyObject *) sobj);
1859 sobj = 0;
1860 }
1861 }
1862 return (PyObject *) sobj;
1863 }
1864
1865 SWIGRUNTIME swig_type_info *
1866 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1867 {
1868 if (PySwigPacked_Check(obj)) {
1869 PySwigPacked *sobj = (PySwigPacked *)obj;
1870 if (sobj->size != size) return 0;
1871 memcpy(ptr, sobj->pack, size);
1872 return sobj->ty;
1873 } else {
1874 return 0;
1875 }
1876 }
1877
1878 /* -----------------------------------------------------------------------------
1879 * pointers/data manipulation
1880 * ----------------------------------------------------------------------------- */
1881
1882 SWIGRUNTIMEINLINE PyObject *
1883 _SWIG_This(void)
1884 {
1885 return PyString_FromString("this");
1886 }
1887
1888 SWIGRUNTIME PyObject *
1889 SWIG_This(void)
1890 {
1891 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1892 return swig_this;
1893 }
1894
1895 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1896
1897 SWIGRUNTIME PySwigObject *
1898 SWIG_Python_GetSwigThis(PyObject *pyobj)
1899 {
1900 if (PySwigObject_Check(pyobj)) {
1901 return (PySwigObject *) pyobj;
1902 } else {
1903 PyObject *obj = 0;
1904 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1905 if (PyInstance_Check(pyobj)) {
1906 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1907 } else {
1908 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1909 if (dictptr != NULL) {
1910 PyObject *dict = *dictptr;
1911 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1912 } else {
1913 #ifdef PyWeakref_CheckProxy
1914 if (PyWeakref_CheckProxy(pyobj)) {
1915 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1916 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1917 }
1918 #endif
1919 obj = PyObject_GetAttr(pyobj,SWIG_This());
1920 if (obj) {
1921 Py_DECREF(obj);
1922 } else {
1923 if (PyErr_Occurred()) PyErr_Clear();
1924 return 0;
1925 }
1926 }
1927 }
1928 #else
1929 obj = PyObject_GetAttr(pyobj,SWIG_This());
1930 if (obj) {
1931 Py_DECREF(obj);
1932 } else {
1933 if (PyErr_Occurred()) PyErr_Clear();
1934 return 0;
1935 }
1936 #endif
1937 if (obj && !PySwigObject_Check(obj)) {
1938 /* a PyObject is called 'this', try to get the 'real this'
1939 PySwigObject from it */
1940 return SWIG_Python_GetSwigThis(obj);
1941 }
1942 return (PySwigObject *)obj;
1943 }
1944 }
1945
1946 /* Acquire a pointer value */
1947
1948 SWIGRUNTIME int
1949 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1950 if (own) {
1951 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1952 if (sobj) {
1953 int oldown = sobj->own;
1954 sobj->own = own;
1955 return oldown;
1956 }
1957 }
1958 return 0;
1959 }
1960
1961 /* Convert a pointer value */
1962
1963 SWIGRUNTIME int
1964 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1965 if (!obj) return SWIG_ERROR;
1966 if (obj == Py_None) {
1967 if (ptr) *ptr = 0;
1968 return SWIG_OK;
1969 } else {
1970 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1971 while (sobj) {
1972 void *vptr = sobj->ptr;
1973 if (ty) {
1974 swig_type_info *to = sobj->ty;
1975 if (to == ty) {
1976 /* no type cast needed */
1977 if (ptr) *ptr = vptr;
1978 break;
1979 } else {
1980 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1981 if (!tc) {
1982 sobj = (PySwigObject *)sobj->next;
1983 } else {
1984 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1985 break;
1986 }
1987 }
1988 } else {
1989 if (ptr) *ptr = vptr;
1990 break;
1991 }
1992 }
1993 if (sobj) {
1994 if (own) *own = sobj->own;
1995 if (flags & SWIG_POINTER_DISOWN) {
1996 sobj->own = 0;
1997 }
1998 return SWIG_OK;
1999 } else {
2000 int res = SWIG_ERROR;
2001 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2002 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2003 if (data && !data->implicitconv) {
2004 PyObject *klass = data->klass;
2005 if (klass) {
2006 PyObject *impconv;
2007 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2008 impconv = SWIG_Python_CallFunctor(klass, obj);
2009 data->implicitconv = 0;
2010 if (PyErr_Occurred()) {
2011 PyErr_Clear();
2012 impconv = 0;
2013 }
2014 if (impconv) {
2015 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2016 if (iobj) {
2017 void *vptr;
2018 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2019 if (SWIG_IsOK(res)) {
2020 if (ptr) {
2021 *ptr = vptr;
2022 /* transfer the ownership to 'ptr' */
2023 iobj->own = 0;
2024 res = SWIG_AddCast(res);
2025 res = SWIG_AddNewMask(res);
2026 } else {
2027 res = SWIG_AddCast(res);
2028 }
2029 }
2030 }
2031 Py_DECREF(impconv);
2032 }
2033 }
2034 }
2035 }
2036 return res;
2037 }
2038 }
2039 }
2040
2041 /* Convert a function ptr value */
2042
2043 SWIGRUNTIME int
2044 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2045 if (!PyCFunction_Check(obj)) {
2046 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2047 } else {
2048 void *vptr = 0;
2049
2050 /* here we get the method pointer for callbacks */
2051 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2052 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2053 if (desc) {
2054 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2055 if (!desc) return SWIG_ERROR;
2056 }
2057 if (ty) {
2058 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2059 if (!tc) return SWIG_ERROR;
2060 *ptr = SWIG_TypeCast(tc,vptr);
2061 } else {
2062 *ptr = vptr;
2063 }
2064 return SWIG_OK;
2065 }
2066 }
2067
2068 /* Convert a packed value value */
2069
2070 SWIGRUNTIME int
2071 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2072 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2073 if (!to) return SWIG_ERROR;
2074 if (ty) {
2075 if (to != ty) {
2076 /* check type cast? */
2077 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2078 if (!tc) return SWIG_ERROR;
2079 }
2080 }
2081 return SWIG_OK;
2082 }
2083
2084 /* -----------------------------------------------------------------------------
2085 * Create a new pointer object
2086 * ----------------------------------------------------------------------------- */
2087
2088 /*
2089 Create a new instance object, whitout calling __init__, and set the
2090 'this' attribute.
2091 */
2092
2093 SWIGRUNTIME PyObject*
2094 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2095 {
2096 #if (PY_VERSION_HEX >= 0x02020000)
2097 PyObject *inst = 0;
2098 PyObject *newraw = data->newraw;
2099 if (newraw) {
2100 inst = PyObject_Call(newraw, data->newargs, NULL);
2101 if (inst) {
2102 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2103 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2104 if (dictptr != NULL) {
2105 PyObject *dict = *dictptr;
2106 if (dict == NULL) {
2107 dict = PyDict_New();
2108 *dictptr = dict;
2109 PyDict_SetItem(dict, SWIG_This(), swig_this);
2110 }
2111 }
2112 #else
2113 PyObject *key = SWIG_This();
2114 PyObject_SetAttr(inst, key, swig_this);
2115 #endif
2116 }
2117 } else {
2118 PyObject *dict = PyDict_New();
2119 PyDict_SetItem(dict, SWIG_This(), swig_this);
2120 inst = PyInstance_NewRaw(data->newargs, dict);
2121 Py_DECREF(dict);
2122 }
2123 return inst;
2124 #else
2125 #if (PY_VERSION_HEX >= 0x02010000)
2126 PyObject *inst;
2127 PyObject *dict = PyDict_New();
2128 PyDict_SetItem(dict, SWIG_This(), swig_this);
2129 inst = PyInstance_NewRaw(data->newargs, dict);
2130 Py_DECREF(dict);
2131 return (PyObject *) inst;
2132 #else
2133 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2134 if (inst == NULL) {
2135 return NULL;
2136 }
2137 inst->in_class = (PyClassObject *)data->newargs;
2138 Py_INCREF(inst->in_class);
2139 inst->in_dict = PyDict_New();
2140 if (inst->in_dict == NULL) {
2141 Py_DECREF(inst);
2142 return NULL;
2143 }
2144 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2145 inst->in_weakreflist = NULL;
2146 #endif
2147 #ifdef Py_TPFLAGS_GC
2148 PyObject_GC_Init(inst);
2149 #endif
2150 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2151 return (PyObject *) inst;
2152 #endif
2153 #endif
2154 }
2155
2156 SWIGRUNTIME void
2157 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2158 {
2159 PyObject *dict;
2160 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2161 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2162 if (dictptr != NULL) {
2163 dict = *dictptr;
2164 if (dict == NULL) {
2165 dict = PyDict_New();
2166 *dictptr = dict;
2167 }
2168 PyDict_SetItem(dict, SWIG_This(), swig_this);
2169 return;
2170 }
2171 #endif
2172 dict = PyObject_GetAttrString(inst, "__dict__");
2173 PyDict_SetItem(dict, SWIG_This(), swig_this);
2174 Py_DECREF(dict);
2175 }
2176
2177
2178 SWIGINTERN PyObject *
2179 SWIG_Python_InitShadowInstance(PyObject *args) {
2180 PyObject *obj[2];
2181 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2182 return NULL;
2183 } else {
2184 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2185 if (sthis) {
2186 PySwigObject_append((PyObject*) sthis, obj[1]);
2187 } else {
2188 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2189 }
2190 return SWIG_Py_Void();
2191 }
2192 }
2193
2194 /* Create a new pointer object */
2195
2196 SWIGRUNTIME PyObject *
2197 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2198 if (!ptr) {
2199 return SWIG_Py_Void();
2200 } else {
2201 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2202 PyObject *robj = PySwigObject_New(ptr, type, own);
2203 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2204 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2205 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2206 if (inst) {
2207 Py_DECREF(robj);
2208 robj = inst;
2209 }
2210 }
2211 return robj;
2212 }
2213 }
2214
2215 /* Create a new packed object */
2216
2217 SWIGRUNTIMEINLINE PyObject *
2218 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2219 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2220 }
2221
2222 /* -----------------------------------------------------------------------------*
2223 * Get type list
2224 * -----------------------------------------------------------------------------*/
2225
2226 #ifdef SWIG_LINK_RUNTIME
2227 void *SWIG_ReturnGlobalTypeList(void *);
2228 #endif
2229
2230 SWIGRUNTIME swig_module_info *
2231 SWIG_Python_GetModule(void) {
2232 static void *type_pointer = (void *)0;
2233 /* first check if module already created */
2234 if (!type_pointer) {
2235 #ifdef SWIG_LINK_RUNTIME
2236 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2237 #else
2238 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2239 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2240 if (PyErr_Occurred()) {
2241 PyErr_Clear();
2242 type_pointer = (void *)0;
2243 }
2244 #endif
2245 }
2246 return (swig_module_info *) type_pointer;
2247 }
2248
2249 #if PY_MAJOR_VERSION < 2
2250 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2251 is copied out of Python/modsupport.c in python version 2.3.4 */
2252 SWIGINTERN int
2253 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2254 {
2255 PyObject *dict;
2256 if (!PyModule_Check(m)) {
2257 PyErr_SetString(PyExc_TypeError,
2258 "PyModule_AddObject() needs module as first arg");
2259 return SWIG_ERROR;
2260 }
2261 if (!o) {
2262 PyErr_SetString(PyExc_TypeError,
2263 "PyModule_AddObject() needs non-NULL value");
2264 return SWIG_ERROR;
2265 }
2266
2267 dict = PyModule_GetDict(m);
2268 if (dict == NULL) {
2269 /* Internal error -- modules must have a dict! */
2270 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2271 PyModule_GetName(m));
2272 return SWIG_ERROR;
2273 }
2274 if (PyDict_SetItemString(dict, name, o))
2275 return SWIG_ERROR;
2276 Py_DECREF(o);
2277 return SWIG_OK;
2278 }
2279 #endif
2280
2281 SWIGRUNTIME void
2282 SWIG_Python_DestroyModule(void *vptr)
2283 {
2284 swig_module_info *swig_module = (swig_module_info *) vptr;
2285 swig_type_info **types = swig_module->types;
2286 size_t i;
2287 for (i =0; i < swig_module->size; ++i) {
2288 swig_type_info *ty = types[i];
2289 if (ty->owndata) {
2290 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2291 if (data) PySwigClientData_Del(data);
2292 }
2293 }
2294 Py_DECREF(SWIG_This());
2295 }
2296
2297 SWIGRUNTIME void
2298 SWIG_Python_SetModule(swig_module_info *swig_module) {
2299 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2300
2301 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2302 swig_empty_runtime_method_table);
2303 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2304 if (pointer && module) {
2305 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2306 } else {
2307 Py_XDECREF(pointer);
2308 }
2309 }
2310
2311 /* The python cached type query */
2312 SWIGRUNTIME PyObject *
2313 SWIG_Python_TypeCache() {
2314 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2315 return cache;
2316 }
2317
2318 SWIGRUNTIME swig_type_info *
2319 SWIG_Python_TypeQuery(const char *type)
2320 {
2321 PyObject *cache = SWIG_Python_TypeCache();
2322 PyObject *key = PyString_FromString(type);
2323 PyObject *obj = PyDict_GetItem(cache, key);
2324 swig_type_info *descriptor;
2325 if (obj) {
2326 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2327 } else {
2328 swig_module_info *swig_module = SWIG_Python_GetModule();
2329 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2330 if (descriptor) {
2331 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2332 PyDict_SetItem(cache, key, obj);
2333 Py_DECREF(obj);
2334 }
2335 }
2336 Py_DECREF(key);
2337 return descriptor;
2338 }
2339
2340 /*
2341 For backward compatibility only
2342 */
2343 #define SWIG_POINTER_EXCEPTION 0
2344 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2345 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2346
2347 SWIGRUNTIME int
2348 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2349 {
2350 if (PyErr_Occurred()) {
2351 PyObject *type = 0;
2352 PyObject *value = 0;
2353 PyObject *traceback = 0;
2354 PyErr_Fetch(&type, &value, &traceback);
2355 if (value) {
2356 PyObject *old_str = PyObject_Str(value);
2357 Py_XINCREF(type);
2358 PyErr_Clear();
2359 if (infront) {
2360 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2361 } else {
2362 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2363 }
2364 Py_DECREF(old_str);
2365 }
2366 return 1;
2367 } else {
2368 return 0;
2369 }
2370 }
2371
2372 SWIGRUNTIME int
2373 SWIG_Python_ArgFail(int argnum)
2374 {
2375 if (PyErr_Occurred()) {
2376 /* add information about failing argument */
2377 char mesg[256];
2378 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2379 return SWIG_Python_AddErrMesg(mesg, 1);
2380 } else {
2381 return 0;
2382 }
2383 }
2384
2385 SWIGRUNTIMEINLINE const char *
2386 PySwigObject_GetDesc(PyObject *self)
2387 {
2388 PySwigObject *v = (PySwigObject *)self;
2389 swig_type_info *ty = v ? v->ty : 0;
2390 return ty ? ty->str : (char*)"";
2391 }
2392
2393 SWIGRUNTIME void
2394 SWIG_Python_TypeError(const char *type, PyObject *obj)
2395 {
2396 if (type) {
2397 #if defined(SWIG_COBJECT_TYPES)
2398 if (obj && PySwigObject_Check(obj)) {
2399 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2400 if (otype) {
2401 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2402 type, otype);
2403 return;
2404 }
2405 } else
2406 #endif
2407 {
2408 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2409 if (otype) {
2410 PyObject *str = PyObject_Str(obj);
2411 const char *cstr = str ? PyString_AsString(str) : 0;
2412 if (cstr) {
2413 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2414 type, otype, cstr);
2415 } else {
2416 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2417 type, otype);
2418 }
2419 Py_XDECREF(str);
2420 return;
2421 }
2422 }
2423 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2424 } else {
2425 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2426 }
2427 }
2428
2429
2430 /* Convert a pointer value, signal an exception on a type mismatch */
2431 SWIGRUNTIME void *
2432 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2433 void *result;
2434 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2435 PyErr_Clear();
2436 if (flags & SWIG_POINTER_EXCEPTION) {
2437 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2438 SWIG_Python_ArgFail(argnum);
2439 }
2440 }
2441 return result;
2442 }
2443
2444
2445 #ifdef __cplusplus
2446 #if 0
2447 { /* cc-mode */
2448 #endif
2449 }
2450 #endif
2451
2452
2453
2454 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2455
2456 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2457
2458
2459
2460 /* -------- TYPES TABLE (BEGIN) -------- */
2461
2462 #define SWIGTYPE_p_buffer swig_types[0]
2463 #define SWIGTYPE_p_char swig_types[1]
2464 #define SWIGTYPE_p_form_ops_t swig_types[2]
2465 #define SWIGTYPE_p_int swig_types[3]
2466 #define SWIGTYPE_p_long swig_types[4]
2467 #define SWIGTYPE_p_unsigned_char swig_types[5]
2468 #define SWIGTYPE_p_unsigned_int swig_types[6]
2469 #define SWIGTYPE_p_unsigned_long swig_types[7]
2470 #define SWIGTYPE_p_wxANIHandler swig_types[8]
2471 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[9]
2472 #define SWIGTYPE_p_wxAcceleratorTable swig_types[10]
2473 #define SWIGTYPE_p_wxActivateEvent swig_types[11]
2474 #define SWIGTYPE_p_wxAppTraits swig_types[12]
2475 #define SWIGTYPE_p_wxArrayString swig_types[13]
2476 #define SWIGTYPE_p_wxBMPHandler swig_types[14]
2477 #define SWIGTYPE_p_wxBitmap swig_types[15]
2478 #define SWIGTYPE_p_wxBoxSizer swig_types[16]
2479 #define SWIGTYPE_p_wxButton swig_types[17]
2480 #define SWIGTYPE_p_wxCURHandler swig_types[18]
2481 #define SWIGTYPE_p_wxCaret swig_types[19]
2482 #define SWIGTYPE_p_wxChildFocusEvent swig_types[20]
2483 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[21]
2484 #define SWIGTYPE_p_wxCloseEvent swig_types[22]
2485 #define SWIGTYPE_p_wxColour swig_types[23]
2486 #define SWIGTYPE_p_wxCommandEvent swig_types[24]
2487 #define SWIGTYPE_p_wxContextMenuEvent swig_types[25]
2488 #define SWIGTYPE_p_wxControl swig_types[26]
2489 #define SWIGTYPE_p_wxControlWithItems swig_types[27]
2490 #define SWIGTYPE_p_wxCursor swig_types[28]
2491 #define SWIGTYPE_p_wxDC swig_types[29]
2492 #define SWIGTYPE_p_wxDateEvent swig_types[30]
2493 #define SWIGTYPE_p_wxDateTime swig_types[31]
2494 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[32]
2495 #define SWIGTYPE_p_wxDropFilesEvent swig_types[33]
2496 #define SWIGTYPE_p_wxDuplexMode swig_types[34]
2497 #define SWIGTYPE_p_wxEraseEvent swig_types[35]
2498 #define SWIGTYPE_p_wxEvent swig_types[36]
2499 #define SWIGTYPE_p_wxEventLoop swig_types[37]
2500 #define SWIGTYPE_p_wxEventLoopActivator swig_types[38]
2501 #define SWIGTYPE_p_wxEvtHandler swig_types[39]
2502 #define SWIGTYPE_p_wxFSFile swig_types[40]
2503 #define SWIGTYPE_p_wxFileSystem swig_types[41]
2504 #define SWIGTYPE_p_wxFileSystemHandler swig_types[42]
2505 #define SWIGTYPE_p_wxFlexGridSizer swig_types[43]
2506 #define SWIGTYPE_p_wxFocusEvent swig_types[44]
2507 #define SWIGTYPE_p_wxFont swig_types[45]
2508 #define SWIGTYPE_p_wxFrame swig_types[46]
2509 #define SWIGTYPE_p_wxGBPosition swig_types[47]
2510 #define SWIGTYPE_p_wxGBSizerItem swig_types[48]
2511 #define SWIGTYPE_p_wxGBSpan swig_types[49]
2512 #define SWIGTYPE_p_wxGIFHandler swig_types[50]
2513 #define SWIGTYPE_p_wxGridBagSizer swig_types[51]
2514 #define SWIGTYPE_p_wxGridSizer swig_types[52]
2515 #define SWIGTYPE_p_wxICOHandler swig_types[53]
2516 #define SWIGTYPE_p_wxIconizeEvent swig_types[54]
2517 #define SWIGTYPE_p_wxIdleEvent swig_types[55]
2518 #define SWIGTYPE_p_wxImage swig_types[56]
2519 #define SWIGTYPE_p_wxImageHandler swig_types[57]
2520 #define SWIGTYPE_p_wxImageHistogram swig_types[58]
2521 #define SWIGTYPE_p_wxImage_HSVValue swig_types[59]
2522 #define SWIGTYPE_p_wxImage_RGBValue swig_types[60]
2523 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[61]
2524 #define SWIGTYPE_p_wxInitDialogEvent swig_types[62]
2525 #define SWIGTYPE_p_wxInputStream swig_types[63]
2526 #define SWIGTYPE_p_wxInternetFSHandler swig_types[64]
2527 #define SWIGTYPE_p_wxItemContainer swig_types[65]
2528 #define SWIGTYPE_p_wxJPEGHandler swig_types[66]
2529 #define SWIGTYPE_p_wxKeyEvent swig_types[67]
2530 #define SWIGTYPE_p_wxLayoutConstraints swig_types[68]
2531 #define SWIGTYPE_p_wxMaximizeEvent swig_types[69]
2532 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[70]
2533 #define SWIGTYPE_p_wxMenu swig_types[71]
2534 #define SWIGTYPE_p_wxMenuBar swig_types[72]
2535 #define SWIGTYPE_p_wxMenuBarBase swig_types[73]
2536 #define SWIGTYPE_p_wxMenuEvent swig_types[74]
2537 #define SWIGTYPE_p_wxMenuItem swig_types[75]
2538 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[76]
2539 #define SWIGTYPE_p_wxMouseEvent swig_types[77]
2540 #define SWIGTYPE_p_wxMoveEvent swig_types[78]
2541 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[79]
2542 #define SWIGTYPE_p_wxNcPaintEvent swig_types[80]
2543 #define SWIGTYPE_p_wxNotifyEvent swig_types[81]
2544 #define SWIGTYPE_p_wxObject swig_types[82]
2545 #define SWIGTYPE_p_wxOutputStream swig_types[83]
2546 #define SWIGTYPE_p_wxPCXHandler swig_types[84]
2547 #define SWIGTYPE_p_wxPNGHandler swig_types[85]
2548 #define SWIGTYPE_p_wxPNMHandler swig_types[86]
2549 #define SWIGTYPE_p_wxPaintEvent swig_types[87]
2550 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[88]
2551 #define SWIGTYPE_p_wxPaperSize swig_types[89]
2552 #define SWIGTYPE_p_wxPoint swig_types[90]
2553 #define SWIGTYPE_p_wxPoint2D swig_types[91]
2554 #define SWIGTYPE_p_wxPropagateOnce swig_types[92]
2555 #define SWIGTYPE_p_wxPropagationDisabler swig_types[93]
2556 #define SWIGTYPE_p_wxPyApp swig_types[94]
2557 #define SWIGTYPE_p_wxPyCommandEvent swig_types[95]
2558 #define SWIGTYPE_p_wxPyDropTarget swig_types[96]
2559 #define SWIGTYPE_p_wxPyEvent swig_types[97]
2560 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[98]
2561 #define SWIGTYPE_p_wxPyImageHandler swig_types[99]
2562 #define SWIGTYPE_p_wxPyInputStream swig_types[100]
2563 #define SWIGTYPE_p_wxPySizer swig_types[101]
2564 #define SWIGTYPE_p_wxPyValidator swig_types[102]
2565 #define SWIGTYPE_p_wxQuantize swig_types[103]
2566 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[104]
2567 #define SWIGTYPE_p_wxRealPoint swig_types[105]
2568 #define SWIGTYPE_p_wxRect swig_types[106]
2569 #define SWIGTYPE_p_wxRegion swig_types[107]
2570 #define SWIGTYPE_p_wxScrollEvent swig_types[108]
2571 #define SWIGTYPE_p_wxScrollWinEvent swig_types[109]
2572 #define SWIGTYPE_p_wxSetCursorEvent swig_types[110]
2573 #define SWIGTYPE_p_wxShowEvent swig_types[111]
2574 #define SWIGTYPE_p_wxSize swig_types[112]
2575 #define SWIGTYPE_p_wxSizeEvent swig_types[113]
2576 #define SWIGTYPE_p_wxSizer swig_types[114]
2577 #define SWIGTYPE_p_wxSizerItem swig_types[115]
2578 #define SWIGTYPE_p_wxStaticBox swig_types[116]
2579 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[117]
2580 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[118]
2581 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[119]
2582 #define SWIGTYPE_p_wxTIFFHandler swig_types[120]
2583 #define SWIGTYPE_p_wxToolTip swig_types[121]
2584 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[122]
2585 #define SWIGTYPE_p_wxValidator swig_types[123]
2586 #define SWIGTYPE_p_wxVisualAttributes swig_types[124]
2587 #define SWIGTYPE_p_wxWindow swig_types[125]
2588 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[126]
2589 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[127]
2590 #define SWIGTYPE_p_wxXPMHandler swig_types[128]
2591 #define SWIGTYPE_p_wxZipFSHandler swig_types[129]
2592 static swig_type_info *swig_types[131];
2593 static swig_module_info swig_module = {swig_types, 130, 0, 0, 0, 0};
2594 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2595 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2596
2597 /* -------- TYPES TABLE (END) -------- */
2598
2599 #if (PY_VERSION_HEX <= 0x02000000)
2600 # if !defined(SWIG_PYTHON_CLASSIC)
2601 # error "This python version requires to use swig with the '-classic' option"
2602 # endif
2603 #endif
2604 #if (PY_VERSION_HEX <= 0x02020000)
2605 # error "This python version requires to use swig with the '-nomodern' option"
2606 #endif
2607 #if (PY_VERSION_HEX <= 0x02020000)
2608 # error "This python version requires to use swig with the '-nomodernargs' option"
2609 #endif
2610 #ifndef METH_O
2611 # error "This python version requires to use swig with the '-nofastunpack' option"
2612 #endif
2613
2614 /*-----------------------------------------------
2615 @(target):= _core_.so
2616 ------------------------------------------------*/
2617 #define SWIG_init init_core_
2618
2619 #define SWIG_name "_core_"
2620
2621 #define SWIGVERSION 0x010329
2622
2623
2624 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2625 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2626
2627
2628 #include <stdexcept>
2629
2630
2631 namespace swig {
2632 class PyObject_ptr {
2633 protected:
2634 PyObject *_obj;
2635
2636 public:
2637 PyObject_ptr() :_obj(0)
2638 {
2639 }
2640
2641 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2642 {
2643 Py_XINCREF(_obj);
2644 }
2645
2646 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2647 {
2648 if (initial_ref) Py_XINCREF(_obj);
2649 }
2650
2651 PyObject_ptr & operator=(const PyObject_ptr& item)
2652 {
2653 Py_XINCREF(item._obj);
2654 Py_XDECREF(_obj);
2655 _obj = item._obj;
2656 return *this;
2657 }
2658
2659 ~PyObject_ptr()
2660 {
2661 Py_XDECREF(_obj);
2662 }
2663
2664 operator PyObject *() const
2665 {
2666 return _obj;
2667 }
2668
2669 PyObject *operator->() const
2670 {
2671 return _obj;
2672 }
2673 };
2674 }
2675
2676
2677 namespace swig {
2678 struct PyObject_var : PyObject_ptr {
2679 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2680
2681 PyObject_var & operator = (PyObject* obj)
2682 {
2683 Py_XDECREF(_obj);
2684 _obj = obj;
2685 return *this;
2686 }
2687 };
2688 }
2689
2690
2691 #include "wx/wxPython/wxPython_int.h"
2692 #include "wx/wxPython/pyclasses.h"
2693 #include "wx/wxPython/twoitem.h"
2694
2695
2696 #ifndef wxPyUSE_EXPORT
2697 // Helper functions for dealing with SWIG objects and such. These are
2698 // located here so they know about the SWIG types and functions declared
2699 // in the wrapper code.
2700
2701 #include <wx/hashmap.h>
2702 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
2703
2704
2705 // Maintains a hashmap of className to swig_type_info pointers. Given the
2706 // name of a class either looks up the type info in the cache, or scans the
2707 // SWIG tables for it.
2708 extern PyObject* wxPyPtrTypeMap;
2709 static
2710 swig_type_info* wxPyFindSwigType(const wxChar* className) {
2711
2712 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
2713
2714 if (typeInfoCache == NULL)
2715 typeInfoCache = new wxPyTypeInfoHashMap;
2716
2717 wxString name(className);
2718 swig_type_info* swigType = (*typeInfoCache)[name];
2719
2720 if (! swigType) {
2721 // it wasn't in the cache, so look it up from SWIG
2722 name.Append(wxT(" *"));
2723 swigType = SWIG_TypeQuery(name.mb_str());
2724
2725 // if it still wasn't found, try looking for a mapped name
2726 if (!swigType) {
2727 PyObject* item;
2728 name = className;
2729
2730 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
2731 (char*)(const char*)name.mbc_str())) != NULL) {
2732 name = wxString(PyString_AsString(item), *wxConvCurrent);
2733 name.Append(wxT(" *"));
2734 swigType = SWIG_TypeQuery(name.mb_str());
2735 }
2736 }
2737 if (swigType) {
2738 // and add it to the map if found
2739 (*typeInfoCache)[className] = swigType;
2740 }
2741 }
2742 return swigType;
2743 }
2744
2745
2746 // Check if a class name is a type known to SWIG
2747 bool wxPyCheckSwigType(const wxChar* className) {
2748
2749 swig_type_info* swigType = wxPyFindSwigType(className);
2750 return swigType != NULL;
2751 }
2752
2753
2754 // Given a pointer to a C++ object and a class name, construct a Python proxy
2755 // object for it.
2756 PyObject* wxPyConstructObject(void* ptr,
2757 const wxChar* className,
2758 int setThisOwn) {
2759
2760 swig_type_info* swigType = wxPyFindSwigType(className);
2761 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
2762
2763 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
2764 }
2765
2766
2767 // Extract a pointer to the wrapped C++ object from a Python proxy object.
2768 // Ensures that the proxy object is of the specified (or derived) type. If
2769 // not able to perform the conversion then a Python exception is set and the
2770 // error should be handled properly in the caller. Returns True on success.
2771 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
2772 const wxChar* className) {
2773
2774 swig_type_info* swigType = wxPyFindSwigType(className);
2775 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
2776
2777 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
2778 }
2779
2780
2781
2782 // Make a SWIGified pointer object suitable for a .this attribute
2783 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
2784
2785 PyObject* robj = NULL;
2786
2787 swig_type_info* swigType = wxPyFindSwigType(className);
2788 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyMakeSwigPtr"));
2789
2790 robj = PySwigObject_New(ptr, swigType, 0);
2791 return robj;
2792 }
2793
2794
2795 // Python's PyInstance_Check does not return True for instances of new-style
2796 // classes. This should get close enough for both new and old classes but I
2797 // should re-evaluate the need for doing instance checks...
2798 bool wxPyInstance_Check(PyObject* obj) {
2799 return PyObject_HasAttrString(obj, "__class__") != 0;
2800 }
2801
2802
2803 // This one checks if the object is an instance of a SWIG proxy class (it has
2804 // a .this attribute, and the .this attribute is a PySwigObject.)
2805 bool wxPySwigInstance_Check(PyObject* obj) {
2806 static PyObject* this_str = NULL;
2807 if (this_str == NULL)
2808 this_str = PyString_FromString("this");
2809
2810 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
2811 if (this_attr) {
2812 bool retval = (PySwigObject_Check(this_attr) != 0);
2813 Py_DECREF(this_attr);
2814 return retval;
2815 }
2816
2817 PyErr_Clear();
2818 return false;
2819 }
2820
2821
2822 // Export a C API in a struct. Other modules will be able to load this from
2823 // the wx._core_ module and will then have safe access to these functions,
2824 // even if they are located in another shared library.
2825 static wxPyCoreAPI API = {
2826
2827 wxPyCheckSwigType,
2828 wxPyConstructObject,
2829 wxPyConvertSwigPtr,
2830 wxPyMakeSwigPtr,
2831
2832 wxPyBeginAllowThreads,
2833 wxPyEndAllowThreads,
2834 wxPyBeginBlockThreads,
2835 wxPyEndBlockThreads,
2836
2837 wxPy_ConvertList,
2838
2839 wxString_in_helper,
2840 Py2wxString,
2841 wx2PyString,
2842
2843 byte_LIST_helper,
2844 int_LIST_helper,
2845 long_LIST_helper,
2846 string_LIST_helper,
2847 wxPoint_LIST_helper,
2848 wxBitmap_LIST_helper,
2849 wxString_LIST_helper,
2850 wxAcceleratorEntry_LIST_helper,
2851
2852 wxSize_helper,
2853 wxPoint_helper,
2854 wxRealPoint_helper,
2855 wxRect_helper,
2856 wxColour_helper,
2857 wxPoint2D_helper,
2858
2859 wxPySimple_typecheck,
2860 wxColour_typecheck,
2861
2862 wxPyCBH_setCallbackInfo,
2863 wxPyCBH_findCallback,
2864 wxPyCBH_callCallback,
2865 wxPyCBH_callCallbackObj,
2866 wxPyCBH_delete,
2867
2868 wxPyMake_wxObject,
2869 wxPyMake_wxSizer,
2870 wxPyPtrTypeMap_Add,
2871 wxPy2int_seq_helper,
2872 wxPy4int_seq_helper,
2873 wxArrayString2PyList_helper,
2874 wxArrayInt2PyList_helper,
2875
2876 wxPyClientData_dtor,
2877 wxPyUserData_dtor,
2878 wxPyOORClientData_dtor,
2879
2880 wxPyCBInputStream_create,
2881 wxPyCBInputStream_copy,
2882
2883 wxPyInstance_Check,
2884 wxPySwigInstance_Check,
2885
2886 wxPyCheckForApp
2887
2888 };
2889
2890 #endif
2891
2892
2893 #if !WXWIN_COMPATIBILITY_2_4
2894 #define wxHIDE_READONLY 0
2895 #endif
2896
2897
2898 #define SWIG_From_long PyInt_FromLong
2899
2900
2901 SWIGINTERNINLINE PyObject *
2902 SWIG_From_int (int value)
2903 {
2904 return SWIG_From_long (value);
2905 }
2906
2907 static const wxString wxPyEmptyString(wxEmptyString);
2908 SWIGINTERN wxString wxObject_GetClassName(wxObject *self){
2909 return self->GetClassInfo()->GetClassName();
2910 }
2911 SWIGINTERN void wxObject_Destroy(wxObject *self){
2912 delete self;
2913 }
2914
2915 #ifndef __WXMAC__
2916 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
2917 #endif
2918
2919
2920 #include <limits.h>
2921 #ifndef LLONG_MIN
2922 # define LLONG_MIN LONG_LONG_MIN
2923 #endif
2924 #ifndef LLONG_MAX
2925 # define LLONG_MAX LONG_LONG_MAX
2926 #endif
2927 #ifndef ULLONG_MAX
2928 # define ULLONG_MAX ULONG_LONG_MAX
2929 #endif
2930
2931
2932 SWIGINTERN int
2933 SWIG_AsVal_long (PyObject* obj, long* val)
2934 {
2935 if (PyNumber_Check(obj)) {
2936 if (val) *val = PyInt_AsLong(obj);
2937 return SWIG_OK;
2938 }
2939 return SWIG_TypeError;
2940 }
2941
2942
2943 SWIGINTERN int
2944 SWIG_AsVal_int (PyObject * obj, int *val)
2945 {
2946 long v;
2947 int res = SWIG_AsVal_long (obj, &v);
2948 if (SWIG_IsOK(res)) {
2949 if ((v < INT_MIN || v > INT_MAX)) {
2950 return SWIG_OverflowError;
2951 } else {
2952 if (val) *val = static_cast< int >(v);
2953 }
2954 }
2955 return res;
2956 }
2957
2958 SWIGINTERN bool wxSize___eq__(wxSize *self,PyObject *other){
2959 wxSize temp, *obj = &temp;
2960 if ( other == Py_None ) return false;
2961 if ( ! wxSize_helper(other, &obj) ) {
2962 PyErr_Clear();
2963 return false;
2964 }
2965 return self->operator==(*obj);
2966 }
2967 SWIGINTERN bool wxSize___ne__(wxSize *self,PyObject *other){
2968 wxSize temp, *obj = &temp;
2969 if ( other == Py_None ) return true;
2970 if ( ! wxSize_helper(other, &obj)) {
2971 PyErr_Clear();
2972 return true;
2973 }
2974 return self->operator!=(*obj);
2975 }
2976 SWIGINTERN PyObject *wxSize_Get(wxSize *self){
2977 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2978 PyObject* tup = PyTuple_New(2);
2979 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
2980 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
2981 wxPyEndBlockThreads(blocked);
2982 return tup;
2983 }
2984
2985 SWIGINTERN int
2986 SWIG_AsVal_double (PyObject *obj, double* val)
2987 {
2988 if (PyNumber_Check(obj)) {
2989 if (val) *val = PyFloat_AsDouble(obj);
2990 return SWIG_OK;
2991 }
2992 return SWIG_TypeError;
2993 }
2994
2995
2996 #define SWIG_From_double PyFloat_FromDouble
2997
2998 SWIGINTERN bool wxRealPoint___eq__(wxRealPoint *self,PyObject *other){
2999 wxRealPoint temp, *obj = &temp;
3000 if ( other == Py_None ) return false;
3001 if ( ! wxRealPoint_helper(other, &obj) ) {
3002 PyErr_Clear();
3003 return false;
3004 }
3005 return self->operator==(*obj);
3006 }
3007 SWIGINTERN bool wxRealPoint___ne__(wxRealPoint *self,PyObject *other){
3008 wxRealPoint temp, *obj = &temp;
3009 if ( other == Py_None ) return true;
3010 if ( ! wxRealPoint_helper(other, &obj)) {
3011 PyErr_Clear();
3012 return true;
3013 }
3014 return self->operator!=(*obj);
3015 }
3016 SWIGINTERN void wxRealPoint_Set(wxRealPoint *self,double x,double y){
3017 self->x = x;
3018 self->y = y;
3019 }
3020 SWIGINTERN PyObject *wxRealPoint_Get(wxRealPoint *self){
3021 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3022 PyObject* tup = PyTuple_New(2);
3023 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
3024 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
3025 wxPyEndBlockThreads(blocked);
3026 return tup;
3027 }
3028 SWIGINTERN bool wxPoint___eq__(wxPoint *self,PyObject *other){
3029 wxPoint temp, *obj = &temp;
3030 if ( other == Py_None ) return false;
3031 if ( ! wxPoint_helper(other, &obj) ) {
3032 PyErr_Clear();
3033 return false;
3034 }
3035 return self->operator==(*obj);
3036 }
3037 SWIGINTERN bool wxPoint___ne__(wxPoint *self,PyObject *other){
3038 wxPoint temp, *obj = &temp;
3039 if ( other == Py_None ) return true;
3040 if ( ! wxPoint_helper(other, &obj)) {
3041 PyErr_Clear();
3042 return true;
3043 }
3044 return self->operator!=(*obj);
3045 }
3046 SWIGINTERN void wxPoint_Set(wxPoint *self,long x,long y){
3047 self->x = x;
3048 self->y = y;
3049 }
3050 SWIGINTERN PyObject *wxPoint_Get(wxPoint *self){
3051 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3052 PyObject* tup = PyTuple_New(2);
3053 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3054 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3055 wxPyEndBlockThreads(blocked);
3056 return tup;
3057 }
3058 SWIGINTERN bool wxRect___eq__(wxRect *self,PyObject *other){
3059 wxRect temp, *obj = &temp;
3060 if ( other == Py_None ) return false;
3061 if ( ! wxRect_helper(other, &obj) ) {
3062 PyErr_Clear();
3063 return false;
3064 }
3065 return self->operator==(*obj);
3066 }
3067 SWIGINTERN bool wxRect___ne__(wxRect *self,PyObject *other){
3068 wxRect temp, *obj = &temp;
3069 if ( other == Py_None ) return true;
3070 if ( ! wxRect_helper(other, &obj)) {
3071 PyErr_Clear();
3072 return true;
3073 }
3074 return self->operator!=(*obj);
3075 }
3076 SWIGINTERN void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
3077 self->x = x;
3078 self->y = y;
3079 self->width = width;
3080 self->height = height;
3081 }
3082 SWIGINTERN PyObject *wxRect_Get(wxRect *self){
3083 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3084 PyObject* tup = PyTuple_New(4);
3085 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3086 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3087 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
3088 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
3089 wxPyEndBlockThreads(blocked);
3090 return tup;
3091 }
3092
3093 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
3094 wxRegion reg1(*r1);
3095 wxRegion reg2(*r2);
3096 wxRect dest(0,0,0,0);
3097 PyObject* obj;
3098
3099 reg1.Intersect(reg2);
3100 dest = reg1.GetBox();
3101
3102 if (dest != wxRect(0,0,0,0)) {
3103 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3104 wxRect* newRect = new wxRect(dest);
3105 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
3106 wxPyEndBlockThreads(blocked);
3107 return obj;
3108 }
3109 Py_INCREF(Py_None);
3110 return Py_None;
3111 }
3112
3113 SWIGINTERN bool wxPoint2D___eq__(wxPoint2D *self,PyObject *other){
3114 wxPoint2D temp, *obj = &temp;
3115 if ( other == Py_None ) return false;
3116 if ( ! wxPoint2D_helper(other, &obj) ) {
3117 PyErr_Clear();
3118 return false;
3119 }
3120 return self->operator==(*obj);
3121 }
3122 SWIGINTERN bool wxPoint2D___ne__(wxPoint2D *self,PyObject *other){
3123 wxPoint2D temp, *obj = &temp;
3124 if ( other == Py_None ) return true;
3125 if ( ! wxPoint2D_helper(other, &obj)) {
3126 PyErr_Clear();
3127 return true;
3128 }
3129 return self->operator!=(*obj);
3130 }
3131 SWIGINTERN void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
3132 self->m_x = x;
3133 self->m_y = y;
3134 }
3135 SWIGINTERN PyObject *wxPoint2D_Get(wxPoint2D *self){
3136 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3137 PyObject* tup = PyTuple_New(2);
3138 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3139 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3140 wxPyEndBlockThreads(blocked);
3141 return tup;
3142 }
3143
3144 #include "wx/wxPython/pyistream.h"
3145
3146 SWIGINTERN wxPyInputStream *new_wxPyInputStream(PyObject *p){
3147 wxInputStream* wxis = wxPyCBInputStream::create(p);
3148 if (wxis)
3149 return new wxPyInputStream(wxis);
3150 else
3151 return NULL;
3152 }
3153
3154 SWIGINTERN swig_type_info*
3155 SWIG_pchar_descriptor()
3156 {
3157 static int init = 0;
3158 static swig_type_info* info = 0;
3159 if (!init) {
3160 info = SWIG_TypeQuery("_p_char");
3161 init = 1;
3162 }
3163 return info;
3164 }
3165
3166
3167 SWIGINTERNINLINE PyObject *
3168 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3169 {
3170 if (carray) {
3171 if (size > INT_MAX) {
3172 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3173 return pchar_descriptor ?
3174 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3175 } else {
3176 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3177 }
3178 } else {
3179 return SWIG_Py_Void();
3180 }
3181 }
3182
3183
3184 SWIGINTERNINLINE PyObject *
3185 SWIG_From_char (char c)
3186 {
3187 return SWIG_FromCharPtrAndSize(&c,1);
3188 }
3189
3190
3191 SWIGINTERNINLINE PyObject*
3192 SWIG_From_unsigned_SS_long (unsigned long value)
3193 {
3194 return (value > LONG_MAX) ?
3195 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3196 }
3197
3198
3199 SWIGINTERNINLINE PyObject *
3200 SWIG_From_size_t (size_t value)
3201 {
3202 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3203 }
3204
3205
3206 SWIGINTERN int
3207 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3208 {
3209 if (PyString_Check(obj)) {
3210 char *cstr; int len;
3211 PyString_AsStringAndSize(obj, &cstr, &len);
3212 if (cptr) {
3213 if (alloc) {
3214 /*
3215 In python the user should not be able to modify the inner
3216 string representation. To warranty that, if you define
3217 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3218 buffer is always returned.
3219
3220 The default behavior is just to return the pointer value,
3221 so, be careful.
3222 */
3223 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3224 if (*alloc != SWIG_OLDOBJ)
3225 #else
3226 if (*alloc == SWIG_NEWOBJ)
3227 #endif
3228 {
3229 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3230 *alloc = SWIG_NEWOBJ;
3231 }
3232 else {
3233 *cptr = cstr;
3234 *alloc = SWIG_OLDOBJ;
3235 }
3236 } else {
3237 *cptr = PyString_AsString(obj);
3238 }
3239 }
3240 if (psize) *psize = len + 1;
3241 return SWIG_OK;
3242 } else {
3243 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3244 if (pchar_descriptor) {
3245 void* vptr = 0;
3246 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3247 if (cptr) *cptr = (char *) vptr;
3248 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3249 if (alloc) *alloc = SWIG_OLDOBJ;
3250 return SWIG_OK;
3251 }
3252 }
3253 }
3254 return SWIG_TypeError;
3255 }
3256
3257
3258 SWIGINTERN int
3259 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3260 {
3261 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3262 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3263 if (SWIG_IsOK(res)) {
3264 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3265 if (csize <= size) {
3266 if (val) {
3267 if (csize) memcpy(val, cptr, csize*sizeof(char));
3268 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3269 }
3270 if (alloc == SWIG_NEWOBJ) {
3271 delete[] cptr;
3272 res = SWIG_DelNewMask(res);
3273 }
3274 return res;
3275 }
3276 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3277 }
3278 return SWIG_TypeError;
3279 }
3280
3281
3282 SWIGINTERN int
3283 SWIG_AsVal_char (PyObject * obj, char *val)
3284 {
3285 int res = SWIG_AsCharArray(obj, val, 1);
3286 if (!SWIG_IsOK(res)) {
3287 long v;
3288 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3289 if (SWIG_IsOK(res)) {
3290 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3291 if (val) *val = static_cast< char >(v);
3292 } else {
3293 res = SWIG_OverflowError;
3294 }
3295 }
3296 }
3297 return res;
3298 }
3299
3300 SWIGINTERN void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
3301 // We use only strings for the streams, not unicode
3302 PyObject* str = PyObject_Str(obj);
3303 if (! str) {
3304 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
3305 return;
3306 }
3307 self->Write(PyString_AS_STRING(str),
3308 PyString_GET_SIZE(str));
3309 Py_DECREF(str);
3310 }
3311
3312 #include "wx/wxPython/pyistream.h"
3313
3314
3315 class wxPyFileSystemHandler : public wxFileSystemHandler
3316 {
3317 public:
3318 wxPyFileSystemHandler() : wxFileSystemHandler() {}
3319
3320 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
3321 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
3322 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
3323 DEC_PYCALLBACK_STRING__pure(FindNext);
3324
3325 wxString GetProtocol(const wxString& location) {
3326 return wxFileSystemHandler::GetProtocol(location);
3327 }
3328
3329 wxString GetLeftLocation(const wxString& location) {
3330 return wxFileSystemHandler::GetLeftLocation(location);
3331 }
3332
3333 wxString GetAnchor(const wxString& location) {
3334 return wxFileSystemHandler::GetAnchor(location);
3335 }
3336
3337 wxString GetRightLocation(const wxString& location) {
3338 return wxFileSystemHandler::GetRightLocation(location);
3339 }
3340
3341 wxString GetMimeTypeFromExt(const wxString& location) {
3342 return wxFileSystemHandler::GetMimeTypeFromExt(location);
3343 }
3344
3345 PYPRIVATE;
3346 };
3347
3348
3349 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
3350 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
3351 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
3352 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
3353
3354
3355 SWIGINTERN int
3356 SWIG_AsVal_bool (PyObject *obj, bool *val)
3357 {
3358 if (obj == Py_True) {
3359 if (val) *val = true;
3360 return SWIG_OK;
3361 } else if (obj == Py_False) {
3362 if (val) *val = false;
3363 return SWIG_OK;
3364 } else {
3365 long v = 0;
3366 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3367 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3368 return res;
3369 }
3370 }
3371
3372 SWIGINTERN wxString wxFileSystem_URLToFileName(wxString const &url){
3373 wxFileName fname = wxFileSystem::URLToFileName(url);
3374 return fname.GetFullPath();
3375 }
3376
3377 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
3378 wxImage& image,
3379 long type) {
3380 wxMemoryFSHandler::AddFile(filename, image, type);
3381 }
3382
3383 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
3384 const wxBitmap& bitmap,
3385 long type) {
3386 wxMemoryFSHandler::AddFile(filename, bitmap, type);
3387 }
3388
3389 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
3390 PyObject* data) {
3391 if (! PyString_Check(data)) {
3392 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
3393 "Expected string object"));
3394 return;
3395 }
3396
3397 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3398 void* ptr = (void*)PyString_AsString(data);
3399 size_t size = PyString_Size(data);
3400 wxPyEndBlockThreads(blocked);
3401
3402 wxMemoryFSHandler::AddFile(filename, ptr, size);
3403 }
3404
3405
3406 #include "wx/wxPython/pyistream.h"
3407
3408
3409 SWIGINTERN int
3410 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3411 {
3412 long v = 0;
3413 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3414 return SWIG_TypeError;
3415 }
3416 else if (val)
3417 *val = (unsigned long)v;
3418 return SWIG_OK;
3419 }
3420
3421
3422 SWIGINTERN int
3423 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
3424 {
3425 unsigned long v;
3426 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3427 if (SWIG_IsOK(res)) {
3428 if ((v > UCHAR_MAX)) {
3429 return SWIG_OverflowError;
3430 } else {
3431 if (val) *val = static_cast< unsigned char >(v);
3432 }
3433 }
3434 return res;
3435 }
3436
3437
3438 SWIGINTERNINLINE PyObject *
3439 SWIG_From_unsigned_SS_char (unsigned char value)
3440 {
3441 return SWIG_From_unsigned_SS_long (value);
3442 }
3443
3444 SWIGINTERN unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
3445 wxImageHistogramEntry e = (*self)[key];
3446 return e.value;
3447 }
3448 SWIGINTERN unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
3449 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
3450 wxImageHistogramEntry e = (*self)[key];
3451 return e.value;
3452 }
3453 SWIGINTERN unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
3454 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
3455 colour.Green(),
3456 colour.Blue());
3457 wxImageHistogramEntry e = (*self)[key];
3458 return e.value;
3459 }
3460
3461 typedef unsigned char* buffer;
3462
3463
3464 // Pull the nested class out to the top level for SWIG's sake
3465 #define wxImage_RGBValue wxImage::RGBValue
3466 #define wxImage_HSVValue wxImage::HSVValue
3467
3468 SWIGINTERN wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
3469 if (width > 0 && height > 0)
3470 return new wxImage(width, height, clear);
3471 else
3472 return new wxImage;
3473 }
3474 SWIGINTERN wxImage *new_wxImage(wxBitmap const &bitmap){
3475 return new wxImage(bitmap.ConvertToImage());
3476 }
3477 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
3478 if (DATASIZE != width*height*3) {
3479 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3480 return NULL;
3481 }
3482
3483 // Copy the source data so the wxImage can clean it up later
3484 buffer copy = (buffer)malloc(DATASIZE);
3485 if (copy == NULL) {
3486 wxPyBLOCK_THREADS(PyErr_NoMemory());
3487 return NULL;
3488 }
3489 memcpy(copy, data, DATASIZE);
3490 return new wxImage(width, height, copy, false);
3491 }
3492 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
3493 if (DATASIZE != width*height*3) {
3494 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3495 return NULL;
3496 }
3497 if (ALPHASIZE != width*height) {
3498 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3499 return NULL;
3500 }
3501
3502 // Copy the source data so the wxImage can clean it up later
3503 buffer dcopy = (buffer)malloc(DATASIZE);
3504 if (dcopy == NULL) {
3505 wxPyBLOCK_THREADS(PyErr_NoMemory());
3506 return NULL;
3507 }
3508 memcpy(dcopy, data, DATASIZE);
3509
3510 buffer acopy = (buffer)malloc(ALPHASIZE);
3511 if (acopy == NULL) {
3512 wxPyBLOCK_THREADS(PyErr_NoMemory());
3513 return NULL;
3514 }
3515 memcpy(acopy, alpha, ALPHASIZE);
3516
3517 return new wxImage(width, height, dcopy, acopy, false);
3518 }
3519 SWIGINTERN wxSize wxImage_GetSize(wxImage *self){
3520 wxSize size(self->GetWidth(), self->GetHeight());
3521 return size;
3522 }
3523 SWIGINTERN PyObject *wxImage_GetData(wxImage *self){
3524 buffer data = self->GetData();
3525 int len = self->GetWidth() * self->GetHeight() * 3;
3526 PyObject* rv;
3527 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
3528 return rv;
3529 }
3530 SWIGINTERN void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
3531 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3532 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3533 return;
3534 }
3535 buffer copy = (buffer)malloc(DATASIZE);
3536 if (copy == NULL) {
3537 wxPyBLOCK_THREADS(PyErr_NoMemory());
3538 return;
3539 }
3540 memcpy(copy, data, DATASIZE);
3541 self->SetData(copy, false);
3542 // wxImage takes ownership of copy...
3543 }
3544 SWIGINTERN PyObject *wxImage_GetDataBuffer(wxImage *self){
3545 buffer data = self->GetData();
3546 int len = self->GetWidth() * self->GetHeight() * 3;
3547 PyObject* rv;
3548 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3549 return rv;
3550 }
3551 SWIGINTERN void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
3552 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3553 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3554 return;
3555 }
3556 self->SetData(data, true);
3557 }
3558 SWIGINTERN PyObject *wxImage_GetAlphaData(wxImage *self){
3559 buffer data = self->GetAlpha();
3560 if (! data) {
3561 RETURN_NONE();
3562 } else {
3563 int len = self->GetWidth() * self->GetHeight();
3564 PyObject* rv;
3565 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
3566 return rv;
3567 }
3568 }
3569 SWIGINTERN void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
3570 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3571 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3572 return;
3573 }
3574 buffer acopy = (buffer)malloc(ALPHASIZE);
3575 if (acopy == NULL) {
3576 wxPyBLOCK_THREADS(PyErr_NoMemory());
3577 return;
3578 }
3579 memcpy(acopy, alpha, ALPHASIZE);
3580 self->SetAlpha(acopy, false);
3581 // wxImage takes ownership of acopy...
3582 }
3583 SWIGINTERN PyObject *wxImage_GetAlphaBuffer(wxImage *self){
3584 buffer data = self->GetAlpha();
3585 int len = self->GetWidth() * self->GetHeight();
3586 PyObject* rv;
3587 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3588 return rv;
3589 }
3590 SWIGINTERN void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
3591 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3592 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3593 return;
3594 }
3595 self->SetAlpha(alpha, true);
3596 }
3597 SWIGINTERN PyObject *wxImage_GetHandlers(){
3598 wxList& list = wxImage::GetHandlers();
3599 return wxPy_ConvertList(&list);
3600 }
3601 SWIGINTERN wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
3602 wxBitmap bitmap(*self, depth);
3603 return bitmap;
3604 }
3605 SWIGINTERN wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
3606 wxImage mono = self->ConvertToMono( red, green, blue );
3607 wxBitmap bitmap( mono, 1 );
3608 return bitmap;
3609 }
3610 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
3611 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3612 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3613 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3614 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
3615 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3616 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
3617 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
3618 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
3619 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3620 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3621 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3622 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
3623 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3624 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
3625
3626 #include <wx/quantize.h>
3627
3628 SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
3629 return wxQuantize::Quantize(src, dest,
3630 //NULL, // palette
3631 desiredNoColours,
3632 NULL, // eightBitData
3633 flags);
3634 }
3635 SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
3636 if (PyCallable_Check(func)) {
3637 self->Connect(id, lastId, eventType,
3638 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3639 new wxPyCallback(func));
3640 }
3641 else if (func == Py_None) {
3642 self->Disconnect(id, lastId, eventType,
3643 (wxObjectEventFunction)
3644 &wxPyCallback::EventThunker);
3645 }
3646 else {
3647 wxPyBLOCK_THREADS(
3648 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3649 }
3650 }
3651 SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
3652 return self->Disconnect(id, lastId, eventType,
3653 (wxObjectEventFunction)
3654 &wxPyCallback::EventThunker);
3655 }
3656 SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
3657 if (_self && _self != Py_None) {
3658 self->SetClientObject(new wxPyOORClientData(_self, incref));
3659 }
3660 else {
3661 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3662 if (data) {
3663 self->SetClientObject(NULL); // This will delete it too
3664 }
3665 }
3666 }
3667
3668 #if ! wxUSE_HOTKEY
3669 #define wxEVT_HOTKEY -9999
3670 #endif
3671
3672 SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3673 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3674 if (data) {
3675 Py_INCREF(data->m_obj);
3676 return data->m_obj;
3677 } else {
3678 Py_INCREF(Py_None);
3679 return Py_None;
3680 }
3681 }
3682 SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3683 wxPyClientData* data = new wxPyClientData(clientData);
3684 self->SetClientObject(data);
3685 }
3686 SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
3687 #if wxUSE_UNICODE
3688 return self->GetUnicodeKey();
3689 #else
3690 return 0;
3691 #endif
3692 }
3693
3694 SWIGINTERNINLINE PyObject *
3695 SWIG_From_unsigned_SS_int (unsigned int value)
3696 {
3697 return SWIG_From_unsigned_SS_long (value);
3698 }
3699
3700
3701 SWIGINTERN int
3702 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3703 {
3704 unsigned long v;
3705 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3706 if (SWIG_IsOK(res)) {
3707 if ((v > UINT_MAX)) {
3708 return SWIG_OverflowError;
3709 } else {
3710 if (val) *val = static_cast< unsigned int >(v);
3711 }
3712 }
3713 return res;
3714 }
3715
3716 SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
3717 self->m_size = size;
3718 }
3719 SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
3720 int count = self->GetNumberOfFiles();
3721 wxString* files = self->GetFiles();
3722 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3723 PyObject* list = PyList_New(count);
3724
3725 if (!list) {
3726 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
3727 wxPyEndBlockThreads(blocked);
3728 return NULL;
3729 }
3730
3731 for (int i=0; i<count; i++) {
3732 PyList_SetItem(list, i, wx2PyString(files[i]));
3733 }
3734 wxPyEndBlockThreads(blocked);
3735 return list;
3736 }
3737
3738
3739 SWIGINTERN wxPyApp *new_wxPyApp(){
3740 wxPythonApp = new wxPyApp();
3741 return wxPythonApp;
3742 }
3743 SWIGINTERN int wxPyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
3744
3745 void wxApp_CleanUp() {
3746 __wxPyCleanup();
3747 }
3748
3749
3750 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
3751
3752
3753
3754
3755
3756 SWIGINTERNINLINE PyObject *
3757 SWIG_FromCharPtr(const char *cptr)
3758 {
3759 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3760 }
3761
3762
3763 #if 0 // #ifdef __WXMAC__
3764
3765 // A dummy class that raises an exception if used...
3766 class wxEventLoop
3767 {
3768 public:
3769 wxEventLoop() { wxPyRaiseNotImplemented(); }
3770 int Run() { return 0; }
3771 void Exit(int rc = 0) {}
3772 bool Pending() const { return false; }
3773 bool Dispatch() { return false; }
3774 bool IsRunning() const { return false; }
3775 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3776 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3777 };
3778
3779 #else
3780
3781 #include <wx/evtloop.h>
3782
3783 #endif
3784
3785
3786
3787 static const wxString wxPyPanelNameStr(wxPanelNameStr);
3788 SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3789 SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3790 SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
3791 wxWindowList& list = self->GetChildren();
3792 return wxPy_ConvertList(&list);
3793 }
3794 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3795 #if wxUSE_HOTKEY
3796 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3797 #else
3798 return false;
3799 #endif
3800 }
3801 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3802
3803
3804
3805 return false;
3806
3807 }
3808 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3809 return wxPyGetWinHandle(self);
3810 }
3811 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3812 self->AssociateHandle((WXWidget)handle);
3813 }
3814 SWIGINTERN void wxWindow_DragAcceptFiles(wxWindow *self,bool accept){}
3815
3816 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3817 return wxWindow::FindWindowById(id, parent);
3818 }
3819
3820 wxWindow* wxFindWindowByName( const wxString& name,
3821 const wxWindow *parent = NULL ) {
3822 return wxWindow::FindWindowByName(name, parent);
3823 }
3824
3825 wxWindow* wxFindWindowByLabel( const wxString& label,
3826 const wxWindow *parent = NULL ) {
3827 return wxWindow::FindWindowByLabel(label, parent);
3828 }
3829
3830
3831 #ifdef __WXMSW__
3832 #include <wx/msw/private.h> // to get wxGetWindowId
3833 #endif
3834
3835
3836 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3837 #ifdef __WXMSW__
3838 WXHWND hWnd = (WXHWND)_hWnd;
3839 long id = wxGetWindowId(hWnd);
3840 wxWindow* win = new wxWindow;
3841 if (parent)
3842 parent->AddChild(win);
3843 win->SetEventHandler(win);
3844 win->SetHWND(hWnd);
3845 win->SetId(id);
3846 win->SubclassWin(hWnd);
3847 win->AdoptAttributesFromHWND();
3848 win->SetupColours();
3849 return win;
3850 #else
3851 wxPyRaiseNotImplemented();
3852 return NULL;
3853 #endif
3854 }
3855
3856
3857 PyObject* GetTopLevelWindows() {
3858 return wxPy_ConvertList(&wxTopLevelWindows);
3859 }
3860
3861
3862 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3863 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3864 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3865
3866 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3867
3868
3869 SWIGINTERNINLINE int
3870 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3871 {
3872 unsigned long v;
3873 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3874 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3875 return res;
3876 }
3877
3878 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3879 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3880 wxMenuItemList& list = self->GetMenuItems();
3881 return wxPy_ConvertList(&list);
3882 }
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 int 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 = (int)((wxCommandEvent const *)arg1)->GetInt();
19106 wxPyEndAllowThreads(__tstate);
19107 if (PyErr_Occurred()) SWIG_fail;
19108 }
19109 resultobj = SWIG_From_int(static_cast< int >(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_ClipboardTextEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26380 PyObject *resultobj = 0;
26381 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26382 int arg2 = (int) 0 ;
26383 wxClipboardTextEvent *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 *) "type",(char *) "winid", NULL
26392 };
26393
26394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ClipboardTextEvent",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_ClipboardTextEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26399 }
26400 arg1 = static_cast< wxEventType >(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_ClipboardTextEvent" "', expected argument " "2"" of type '" "int""'");
26406 }
26407 arg2 = static_cast< int >(val2);
26408 }
26409 {
26410 PyThreadState* __tstate = wxPyBeginAllowThreads();
26411 result = (wxClipboardTextEvent *)new wxClipboardTextEvent(arg1,arg2);
26412 wxPyEndAllowThreads(__tstate);
26413 if (PyErr_Occurred()) SWIG_fail;
26414 }
26415 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardTextEvent, SWIG_POINTER_NEW | 0 );
26416 return resultobj;
26417 fail:
26418 return NULL;
26419 }
26420
26421
26422 SWIGINTERN PyObject *ClipboardTextEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26423 PyObject *obj;
26424 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26425 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardTextEvent, SWIG_NewClientData(obj));
26426 return SWIG_Py_Void();
26427 }
26428
26429 SWIGINTERN PyObject *ClipboardTextEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26430 return SWIG_Python_InitShadowInstance(args);
26431 }
26432
26433 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26434 PyObject *resultobj = 0;
26435 int arg1 = (int) 0 ;
26436 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
26437 wxPyEvent *result = 0 ;
26438 int val1 ;
26439 int ecode1 = 0 ;
26440 int val2 ;
26441 int ecode2 = 0 ;
26442 PyObject * obj0 = 0 ;
26443 PyObject * obj1 = 0 ;
26444 char * kwnames[] = {
26445 (char *) "winid",(char *) "eventType", NULL
26446 };
26447
26448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26449 if (obj0) {
26450 ecode1 = SWIG_AsVal_int(obj0, &val1);
26451 if (!SWIG_IsOK(ecode1)) {
26452 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
26453 }
26454 arg1 = static_cast< int >(val1);
26455 }
26456 if (obj1) {
26457 ecode2 = SWIG_AsVal_int(obj1, &val2);
26458 if (!SWIG_IsOK(ecode2)) {
26459 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
26460 }
26461 arg2 = static_cast< wxEventType >(val2);
26462 }
26463 {
26464 PyThreadState* __tstate = wxPyBeginAllowThreads();
26465 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
26466 wxPyEndAllowThreads(__tstate);
26467 if (PyErr_Occurred()) SWIG_fail;
26468 }
26469 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
26470 return resultobj;
26471 fail:
26472 return NULL;
26473 }
26474
26475
26476 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26477 PyObject *resultobj = 0;
26478 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26479 void *argp1 = 0 ;
26480 int res1 = 0 ;
26481 PyObject *swig_obj[1] ;
26482
26483 if (!args) SWIG_fail;
26484 swig_obj[0] = args;
26485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
26486 if (!SWIG_IsOK(res1)) {
26487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26488 }
26489 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26490 {
26491 PyThreadState* __tstate = wxPyBeginAllowThreads();
26492 delete arg1;
26493
26494 wxPyEndAllowThreads(__tstate);
26495 if (PyErr_Occurred()) SWIG_fail;
26496 }
26497 resultobj = SWIG_Py_Void();
26498 return resultobj;
26499 fail:
26500 return NULL;
26501 }
26502
26503
26504 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26505 PyObject *resultobj = 0;
26506 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26507 PyObject *arg2 = (PyObject *) 0 ;
26508 void *argp1 = 0 ;
26509 int res1 = 0 ;
26510 PyObject * obj0 = 0 ;
26511 PyObject * obj1 = 0 ;
26512 char * kwnames[] = {
26513 (char *) "self",(char *) "self", NULL
26514 };
26515
26516 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26517 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26518 if (!SWIG_IsOK(res1)) {
26519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26520 }
26521 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26522 arg2 = obj1;
26523 {
26524 PyThreadState* __tstate = wxPyBeginAllowThreads();
26525 (arg1)->SetSelf(arg2);
26526 wxPyEndAllowThreads(__tstate);
26527 if (PyErr_Occurred()) SWIG_fail;
26528 }
26529 resultobj = SWIG_Py_Void();
26530 return resultobj;
26531 fail:
26532 return NULL;
26533 }
26534
26535
26536 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26537 PyObject *resultobj = 0;
26538 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26539 PyObject *result = 0 ;
26540 void *argp1 = 0 ;
26541 int res1 = 0 ;
26542 PyObject *swig_obj[1] ;
26543
26544 if (!args) SWIG_fail;
26545 swig_obj[0] = args;
26546 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26547 if (!SWIG_IsOK(res1)) {
26548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26549 }
26550 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26551 {
26552 PyThreadState* __tstate = wxPyBeginAllowThreads();
26553 result = (PyObject *)(arg1)->GetSelf();
26554 wxPyEndAllowThreads(__tstate);
26555 if (PyErr_Occurred()) SWIG_fail;
26556 }
26557 resultobj = result;
26558 return resultobj;
26559 fail:
26560 return NULL;
26561 }
26562
26563
26564 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26565 PyObject *obj;
26566 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26567 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
26568 return SWIG_Py_Void();
26569 }
26570
26571 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26572 return SWIG_Python_InitShadowInstance(args);
26573 }
26574
26575 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26576 PyObject *resultobj = 0;
26577 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26578 int arg2 = (int) 0 ;
26579 wxPyCommandEvent *result = 0 ;
26580 int val1 ;
26581 int ecode1 = 0 ;
26582 int val2 ;
26583 int ecode2 = 0 ;
26584 PyObject * obj0 = 0 ;
26585 PyObject * obj1 = 0 ;
26586 char * kwnames[] = {
26587 (char *) "eventType",(char *) "id", NULL
26588 };
26589
26590 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26591 if (obj0) {
26592 ecode1 = SWIG_AsVal_int(obj0, &val1);
26593 if (!SWIG_IsOK(ecode1)) {
26594 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26595 }
26596 arg1 = static_cast< wxEventType >(val1);
26597 }
26598 if (obj1) {
26599 ecode2 = SWIG_AsVal_int(obj1, &val2);
26600 if (!SWIG_IsOK(ecode2)) {
26601 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
26602 }
26603 arg2 = static_cast< int >(val2);
26604 }
26605 {
26606 PyThreadState* __tstate = wxPyBeginAllowThreads();
26607 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
26608 wxPyEndAllowThreads(__tstate);
26609 if (PyErr_Occurred()) SWIG_fail;
26610 }
26611 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
26612 return resultobj;
26613 fail:
26614 return NULL;
26615 }
26616
26617
26618 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26619 PyObject *resultobj = 0;
26620 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26621 void *argp1 = 0 ;
26622 int res1 = 0 ;
26623 PyObject *swig_obj[1] ;
26624
26625 if (!args) SWIG_fail;
26626 swig_obj[0] = args;
26627 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
26628 if (!SWIG_IsOK(res1)) {
26629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26630 }
26631 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26632 {
26633 PyThreadState* __tstate = wxPyBeginAllowThreads();
26634 delete arg1;
26635
26636 wxPyEndAllowThreads(__tstate);
26637 if (PyErr_Occurred()) SWIG_fail;
26638 }
26639 resultobj = SWIG_Py_Void();
26640 return resultobj;
26641 fail:
26642 return NULL;
26643 }
26644
26645
26646 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26647 PyObject *resultobj = 0;
26648 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26649 PyObject *arg2 = (PyObject *) 0 ;
26650 void *argp1 = 0 ;
26651 int res1 = 0 ;
26652 PyObject * obj0 = 0 ;
26653 PyObject * obj1 = 0 ;
26654 char * kwnames[] = {
26655 (char *) "self",(char *) "self", NULL
26656 };
26657
26658 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26659 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26660 if (!SWIG_IsOK(res1)) {
26661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26662 }
26663 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26664 arg2 = obj1;
26665 {
26666 PyThreadState* __tstate = wxPyBeginAllowThreads();
26667 (arg1)->SetSelf(arg2);
26668 wxPyEndAllowThreads(__tstate);
26669 if (PyErr_Occurred()) SWIG_fail;
26670 }
26671 resultobj = SWIG_Py_Void();
26672 return resultobj;
26673 fail:
26674 return NULL;
26675 }
26676
26677
26678 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26679 PyObject *resultobj = 0;
26680 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26681 PyObject *result = 0 ;
26682 void *argp1 = 0 ;
26683 int res1 = 0 ;
26684 PyObject *swig_obj[1] ;
26685
26686 if (!args) SWIG_fail;
26687 swig_obj[0] = args;
26688 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26689 if (!SWIG_IsOK(res1)) {
26690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26691 }
26692 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26693 {
26694 PyThreadState* __tstate = wxPyBeginAllowThreads();
26695 result = (PyObject *)(arg1)->GetSelf();
26696 wxPyEndAllowThreads(__tstate);
26697 if (PyErr_Occurred()) SWIG_fail;
26698 }
26699 resultobj = result;
26700 return resultobj;
26701 fail:
26702 return NULL;
26703 }
26704
26705
26706 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26707 PyObject *obj;
26708 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26709 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
26710 return SWIG_Py_Void();
26711 }
26712
26713 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26714 return SWIG_Python_InitShadowInstance(args);
26715 }
26716
26717 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26718 PyObject *resultobj = 0;
26719 wxWindow *arg1 = (wxWindow *) 0 ;
26720 wxDateTime *arg2 = 0 ;
26721 wxEventType arg3 ;
26722 wxDateEvent *result = 0 ;
26723 void *argp1 = 0 ;
26724 int res1 = 0 ;
26725 void *argp2 = 0 ;
26726 int res2 = 0 ;
26727 int val3 ;
26728 int ecode3 = 0 ;
26729 PyObject * obj0 = 0 ;
26730 PyObject * obj1 = 0 ;
26731 PyObject * obj2 = 0 ;
26732 char * kwnames[] = {
26733 (char *) "win",(char *) "dt",(char *) "type", NULL
26734 };
26735
26736 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26737 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26738 if (!SWIG_IsOK(res1)) {
26739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26740 }
26741 arg1 = reinterpret_cast< wxWindow * >(argp1);
26742 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26743 if (!SWIG_IsOK(res2)) {
26744 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26745 }
26746 if (!argp2) {
26747 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26748 }
26749 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26750 ecode3 = SWIG_AsVal_int(obj2, &val3);
26751 if (!SWIG_IsOK(ecode3)) {
26752 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
26753 }
26754 arg3 = static_cast< wxEventType >(val3);
26755 {
26756 PyThreadState* __tstate = wxPyBeginAllowThreads();
26757 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
26758 wxPyEndAllowThreads(__tstate);
26759 if (PyErr_Occurred()) SWIG_fail;
26760 }
26761 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
26762 return resultobj;
26763 fail:
26764 return NULL;
26765 }
26766
26767
26768 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26769 PyObject *resultobj = 0;
26770 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
26771 wxDateTime *result = 0 ;
26772 void *argp1 = 0 ;
26773 int res1 = 0 ;
26774 PyObject *swig_obj[1] ;
26775
26776 if (!args) SWIG_fail;
26777 swig_obj[0] = args;
26778 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
26779 if (!SWIG_IsOK(res1)) {
26780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
26781 }
26782 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
26783 {
26784 PyThreadState* __tstate = wxPyBeginAllowThreads();
26785 {
26786 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
26787 result = (wxDateTime *) &_result_ref;
26788 }
26789 wxPyEndAllowThreads(__tstate);
26790 if (PyErr_Occurred()) SWIG_fail;
26791 }
26792 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26793 return resultobj;
26794 fail:
26795 return NULL;
26796 }
26797
26798
26799 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26800 PyObject *resultobj = 0;
26801 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
26802 wxDateTime *arg2 = 0 ;
26803 void *argp1 = 0 ;
26804 int res1 = 0 ;
26805 void *argp2 = 0 ;
26806 int res2 = 0 ;
26807 PyObject * obj0 = 0 ;
26808 PyObject * obj1 = 0 ;
26809 char * kwnames[] = {
26810 (char *) "self",(char *) "date", NULL
26811 };
26812
26813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
26814 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
26815 if (!SWIG_IsOK(res1)) {
26816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
26817 }
26818 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
26819 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26820 if (!SWIG_IsOK(res2)) {
26821 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26822 }
26823 if (!argp2) {
26824 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26825 }
26826 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26827 {
26828 PyThreadState* __tstate = wxPyBeginAllowThreads();
26829 (arg1)->SetDate((wxDateTime const &)*arg2);
26830 wxPyEndAllowThreads(__tstate);
26831 if (PyErr_Occurred()) SWIG_fail;
26832 }
26833 resultobj = SWIG_Py_Void();
26834 return resultobj;
26835 fail:
26836 return NULL;
26837 }
26838
26839
26840 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26841 PyObject *obj;
26842 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26843 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
26844 return SWIG_Py_Void();
26845 }
26846
26847 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26848 return SWIG_Python_InitShadowInstance(args);
26849 }
26850
26851 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26852 PyObject *resultobj = 0;
26853 wxPyApp *result = 0 ;
26854
26855 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
26856 {
26857 PyThreadState* __tstate = wxPyBeginAllowThreads();
26858 result = (wxPyApp *)new_wxPyApp();
26859 wxPyEndAllowThreads(__tstate);
26860 if (PyErr_Occurred()) SWIG_fail;
26861 }
26862 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
26863 return resultobj;
26864 fail:
26865 return NULL;
26866 }
26867
26868
26869 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26870 PyObject *resultobj = 0;
26871 wxPyApp *arg1 = (wxPyApp *) 0 ;
26872 void *argp1 = 0 ;
26873 int res1 = 0 ;
26874 PyObject *swig_obj[1] ;
26875
26876 if (!args) SWIG_fail;
26877 swig_obj[0] = args;
26878 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
26879 if (!SWIG_IsOK(res1)) {
26880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
26881 }
26882 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26883 {
26884 PyThreadState* __tstate = wxPyBeginAllowThreads();
26885 delete arg1;
26886
26887 wxPyEndAllowThreads(__tstate);
26888 if (PyErr_Occurred()) SWIG_fail;
26889 }
26890 resultobj = SWIG_Py_Void();
26891 return resultobj;
26892 fail:
26893 return NULL;
26894 }
26895
26896
26897 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26898 PyObject *resultobj = 0;
26899 wxPyApp *arg1 = (wxPyApp *) 0 ;
26900 PyObject *arg2 = (PyObject *) 0 ;
26901 PyObject *arg3 = (PyObject *) 0 ;
26902 bool arg4 ;
26903 void *argp1 = 0 ;
26904 int res1 = 0 ;
26905 bool val4 ;
26906 int ecode4 = 0 ;
26907 PyObject * obj0 = 0 ;
26908 PyObject * obj1 = 0 ;
26909 PyObject * obj2 = 0 ;
26910 PyObject * obj3 = 0 ;
26911 char * kwnames[] = {
26912 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
26913 };
26914
26915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
26916 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26917 if (!SWIG_IsOK(res1)) {
26918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
26919 }
26920 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26921 arg2 = obj1;
26922 arg3 = obj2;
26923 ecode4 = SWIG_AsVal_bool(obj3, &val4);
26924 if (!SWIG_IsOK(ecode4)) {
26925 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
26926 }
26927 arg4 = static_cast< bool >(val4);
26928 {
26929 PyThreadState* __tstate = wxPyBeginAllowThreads();
26930 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
26931 wxPyEndAllowThreads(__tstate);
26932 if (PyErr_Occurred()) SWIG_fail;
26933 }
26934 resultobj = SWIG_Py_Void();
26935 return resultobj;
26936 fail:
26937 return NULL;
26938 }
26939
26940
26941 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26942 PyObject *resultobj = 0;
26943 wxPyApp *arg1 = (wxPyApp *) 0 ;
26944 wxString result;
26945 void *argp1 = 0 ;
26946 int res1 = 0 ;
26947 PyObject *swig_obj[1] ;
26948
26949 if (!args) SWIG_fail;
26950 swig_obj[0] = args;
26951 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26952 if (!SWIG_IsOK(res1)) {
26953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
26954 }
26955 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26956 {
26957 PyThreadState* __tstate = wxPyBeginAllowThreads();
26958 result = ((wxPyApp const *)arg1)->GetAppName();
26959 wxPyEndAllowThreads(__tstate);
26960 if (PyErr_Occurred()) SWIG_fail;
26961 }
26962 {
26963 #if wxUSE_UNICODE
26964 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26965 #else
26966 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26967 #endif
26968 }
26969 return resultobj;
26970 fail:
26971 return NULL;
26972 }
26973
26974
26975 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26976 PyObject *resultobj = 0;
26977 wxPyApp *arg1 = (wxPyApp *) 0 ;
26978 wxString *arg2 = 0 ;
26979 void *argp1 = 0 ;
26980 int res1 = 0 ;
26981 bool temp2 = false ;
26982 PyObject * obj0 = 0 ;
26983 PyObject * obj1 = 0 ;
26984 char * kwnames[] = {
26985 (char *) "self",(char *) "name", NULL
26986 };
26987
26988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
26989 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26990 if (!SWIG_IsOK(res1)) {
26991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
26992 }
26993 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26994 {
26995 arg2 = wxString_in_helper(obj1);
26996 if (arg2 == NULL) SWIG_fail;
26997 temp2 = true;
26998 }
26999 {
27000 PyThreadState* __tstate = wxPyBeginAllowThreads();
27001 (arg1)->SetAppName((wxString const &)*arg2);
27002 wxPyEndAllowThreads(__tstate);
27003 if (PyErr_Occurred()) SWIG_fail;
27004 }
27005 resultobj = SWIG_Py_Void();
27006 {
27007 if (temp2)
27008 delete arg2;
27009 }
27010 return resultobj;
27011 fail:
27012 {
27013 if (temp2)
27014 delete arg2;
27015 }
27016 return NULL;
27017 }
27018
27019
27020 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27021 PyObject *resultobj = 0;
27022 wxPyApp *arg1 = (wxPyApp *) 0 ;
27023 wxString result;
27024 void *argp1 = 0 ;
27025 int res1 = 0 ;
27026 PyObject *swig_obj[1] ;
27027
27028 if (!args) SWIG_fail;
27029 swig_obj[0] = args;
27030 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27031 if (!SWIG_IsOK(res1)) {
27032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27033 }
27034 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27035 {
27036 PyThreadState* __tstate = wxPyBeginAllowThreads();
27037 result = ((wxPyApp const *)arg1)->GetClassName();
27038 wxPyEndAllowThreads(__tstate);
27039 if (PyErr_Occurred()) SWIG_fail;
27040 }
27041 {
27042 #if wxUSE_UNICODE
27043 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27044 #else
27045 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27046 #endif
27047 }
27048 return resultobj;
27049 fail:
27050 return NULL;
27051 }
27052
27053
27054 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27055 PyObject *resultobj = 0;
27056 wxPyApp *arg1 = (wxPyApp *) 0 ;
27057 wxString *arg2 = 0 ;
27058 void *argp1 = 0 ;
27059 int res1 = 0 ;
27060 bool temp2 = false ;
27061 PyObject * obj0 = 0 ;
27062 PyObject * obj1 = 0 ;
27063 char * kwnames[] = {
27064 (char *) "self",(char *) "name", NULL
27065 };
27066
27067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
27068 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27069 if (!SWIG_IsOK(res1)) {
27070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27071 }
27072 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27073 {
27074 arg2 = wxString_in_helper(obj1);
27075 if (arg2 == NULL) SWIG_fail;
27076 temp2 = true;
27077 }
27078 {
27079 PyThreadState* __tstate = wxPyBeginAllowThreads();
27080 (arg1)->SetClassName((wxString const &)*arg2);
27081 wxPyEndAllowThreads(__tstate);
27082 if (PyErr_Occurred()) SWIG_fail;
27083 }
27084 resultobj = SWIG_Py_Void();
27085 {
27086 if (temp2)
27087 delete arg2;
27088 }
27089 return resultobj;
27090 fail:
27091 {
27092 if (temp2)
27093 delete arg2;
27094 }
27095 return NULL;
27096 }
27097
27098
27099 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27100 PyObject *resultobj = 0;
27101 wxPyApp *arg1 = (wxPyApp *) 0 ;
27102 wxString *result = 0 ;
27103 void *argp1 = 0 ;
27104 int res1 = 0 ;
27105 PyObject *swig_obj[1] ;
27106
27107 if (!args) SWIG_fail;
27108 swig_obj[0] = args;
27109 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27110 if (!SWIG_IsOK(res1)) {
27111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27112 }
27113 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27114 {
27115 PyThreadState* __tstate = wxPyBeginAllowThreads();
27116 {
27117 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
27118 result = (wxString *) &_result_ref;
27119 }
27120 wxPyEndAllowThreads(__tstate);
27121 if (PyErr_Occurred()) SWIG_fail;
27122 }
27123 {
27124 #if wxUSE_UNICODE
27125 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
27126 #else
27127 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
27128 #endif
27129 }
27130 return resultobj;
27131 fail:
27132 return NULL;
27133 }
27134
27135
27136 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27137 PyObject *resultobj = 0;
27138 wxPyApp *arg1 = (wxPyApp *) 0 ;
27139 wxString *arg2 = 0 ;
27140 void *argp1 = 0 ;
27141 int res1 = 0 ;
27142 bool temp2 = false ;
27143 PyObject * obj0 = 0 ;
27144 PyObject * obj1 = 0 ;
27145 char * kwnames[] = {
27146 (char *) "self",(char *) "name", NULL
27147 };
27148
27149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
27150 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27151 if (!SWIG_IsOK(res1)) {
27152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27153 }
27154 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27155 {
27156 arg2 = wxString_in_helper(obj1);
27157 if (arg2 == NULL) SWIG_fail;
27158 temp2 = true;
27159 }
27160 {
27161 PyThreadState* __tstate = wxPyBeginAllowThreads();
27162 (arg1)->SetVendorName((wxString const &)*arg2);
27163 wxPyEndAllowThreads(__tstate);
27164 if (PyErr_Occurred()) SWIG_fail;
27165 }
27166 resultobj = SWIG_Py_Void();
27167 {
27168 if (temp2)
27169 delete arg2;
27170 }
27171 return resultobj;
27172 fail:
27173 {
27174 if (temp2)
27175 delete arg2;
27176 }
27177 return NULL;
27178 }
27179
27180
27181 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27182 PyObject *resultobj = 0;
27183 wxPyApp *arg1 = (wxPyApp *) 0 ;
27184 wxAppTraits *result = 0 ;
27185 void *argp1 = 0 ;
27186 int res1 = 0 ;
27187 PyObject *swig_obj[1] ;
27188
27189 if (!args) SWIG_fail;
27190 swig_obj[0] = args;
27191 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27192 if (!SWIG_IsOK(res1)) {
27193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
27194 }
27195 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27196 {
27197 PyThreadState* __tstate = wxPyBeginAllowThreads();
27198 result = (wxAppTraits *)(arg1)->GetTraits();
27199 wxPyEndAllowThreads(__tstate);
27200 if (PyErr_Occurred()) SWIG_fail;
27201 }
27202 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
27203 return resultobj;
27204 fail:
27205 return NULL;
27206 }
27207
27208
27209 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27210 PyObject *resultobj = 0;
27211 wxPyApp *arg1 = (wxPyApp *) 0 ;
27212 void *argp1 = 0 ;
27213 int res1 = 0 ;
27214 PyObject *swig_obj[1] ;
27215
27216 if (!args) SWIG_fail;
27217 swig_obj[0] = args;
27218 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27219 if (!SWIG_IsOK(res1)) {
27220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27221 }
27222 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27223 {
27224 PyThreadState* __tstate = wxPyBeginAllowThreads();
27225 (arg1)->ProcessPendingEvents();
27226 wxPyEndAllowThreads(__tstate);
27227 if (PyErr_Occurred()) SWIG_fail;
27228 }
27229 resultobj = SWIG_Py_Void();
27230 return resultobj;
27231 fail:
27232 return NULL;
27233 }
27234
27235
27236 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27237 PyObject *resultobj = 0;
27238 wxPyApp *arg1 = (wxPyApp *) 0 ;
27239 bool arg2 = (bool) false ;
27240 bool result;
27241 void *argp1 = 0 ;
27242 int res1 = 0 ;
27243 bool val2 ;
27244 int ecode2 = 0 ;
27245 PyObject * obj0 = 0 ;
27246 PyObject * obj1 = 0 ;
27247 char * kwnames[] = {
27248 (char *) "self",(char *) "onlyIfNeeded", NULL
27249 };
27250
27251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
27252 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27253 if (!SWIG_IsOK(res1)) {
27254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
27255 }
27256 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27257 if (obj1) {
27258 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27259 if (!SWIG_IsOK(ecode2)) {
27260 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
27261 }
27262 arg2 = static_cast< bool >(val2);
27263 }
27264 {
27265 PyThreadState* __tstate = wxPyBeginAllowThreads();
27266 result = (bool)(arg1)->Yield(arg2);
27267 wxPyEndAllowThreads(__tstate);
27268 if (PyErr_Occurred()) SWIG_fail;
27269 }
27270 {
27271 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27272 }
27273 return resultobj;
27274 fail:
27275 return NULL;
27276 }
27277
27278
27279 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27280 PyObject *resultobj = 0;
27281 wxPyApp *arg1 = (wxPyApp *) 0 ;
27282 void *argp1 = 0 ;
27283 int res1 = 0 ;
27284 PyObject *swig_obj[1] ;
27285
27286 if (!args) SWIG_fail;
27287 swig_obj[0] = args;
27288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27289 if (!SWIG_IsOK(res1)) {
27290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27291 }
27292 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27293 {
27294 PyThreadState* __tstate = wxPyBeginAllowThreads();
27295 (arg1)->WakeUpIdle();
27296 wxPyEndAllowThreads(__tstate);
27297 if (PyErr_Occurred()) SWIG_fail;
27298 }
27299 resultobj = SWIG_Py_Void();
27300 return resultobj;
27301 fail:
27302 return NULL;
27303 }
27304
27305
27306 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27307 PyObject *resultobj = 0;
27308 bool result;
27309
27310 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
27311 {
27312 PyThreadState* __tstate = wxPyBeginAllowThreads();
27313 result = (bool)wxPyApp::IsMainLoopRunning();
27314 wxPyEndAllowThreads(__tstate);
27315 if (PyErr_Occurred()) SWIG_fail;
27316 }
27317 {
27318 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27319 }
27320 return resultobj;
27321 fail:
27322 return NULL;
27323 }
27324
27325
27326 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27327 PyObject *resultobj = 0;
27328 wxPyApp *arg1 = (wxPyApp *) 0 ;
27329 int result;
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_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27339 }
27340 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27341 {
27342 PyThreadState* __tstate = wxPyBeginAllowThreads();
27343 result = (int)(arg1)->MainLoop();
27344 wxPyEndAllowThreads(__tstate);
27345 if (PyErr_Occurred()) SWIG_fail;
27346 }
27347 resultobj = SWIG_From_int(static_cast< int >(result));
27348 return resultobj;
27349 fail:
27350 return NULL;
27351 }
27352
27353
27354 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27355 PyObject *resultobj = 0;
27356 wxPyApp *arg1 = (wxPyApp *) 0 ;
27357 void *argp1 = 0 ;
27358 int res1 = 0 ;
27359 PyObject *swig_obj[1] ;
27360
27361 if (!args) SWIG_fail;
27362 swig_obj[0] = args;
27363 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27364 if (!SWIG_IsOK(res1)) {
27365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
27366 }
27367 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27368 {
27369 PyThreadState* __tstate = wxPyBeginAllowThreads();
27370 (arg1)->Exit();
27371 wxPyEndAllowThreads(__tstate);
27372 if (PyErr_Occurred()) SWIG_fail;
27373 }
27374 resultobj = SWIG_Py_Void();
27375 return resultobj;
27376 fail:
27377 return NULL;
27378 }
27379
27380
27381 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27382 PyObject *resultobj = 0;
27383 wxPyApp *arg1 = (wxPyApp *) 0 ;
27384 void *argp1 = 0 ;
27385 int res1 = 0 ;
27386 PyObject *swig_obj[1] ;
27387
27388 if (!args) SWIG_fail;
27389 swig_obj[0] = args;
27390 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27391 if (!SWIG_IsOK(res1)) {
27392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27393 }
27394 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27395 {
27396 PyThreadState* __tstate = wxPyBeginAllowThreads();
27397 (arg1)->ExitMainLoop();
27398 wxPyEndAllowThreads(__tstate);
27399 if (PyErr_Occurred()) SWIG_fail;
27400 }
27401 resultobj = SWIG_Py_Void();
27402 return resultobj;
27403 fail:
27404 return NULL;
27405 }
27406
27407
27408 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27409 PyObject *resultobj = 0;
27410 wxPyApp *arg1 = (wxPyApp *) 0 ;
27411 bool result;
27412 void *argp1 = 0 ;
27413 int res1 = 0 ;
27414 PyObject *swig_obj[1] ;
27415
27416 if (!args) SWIG_fail;
27417 swig_obj[0] = args;
27418 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27419 if (!SWIG_IsOK(res1)) {
27420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
27421 }
27422 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27423 {
27424 PyThreadState* __tstate = wxPyBeginAllowThreads();
27425 result = (bool)(arg1)->Pending();
27426 wxPyEndAllowThreads(__tstate);
27427 if (PyErr_Occurred()) SWIG_fail;
27428 }
27429 {
27430 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27431 }
27432 return resultobj;
27433 fail:
27434 return NULL;
27435 }
27436
27437
27438 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27439 PyObject *resultobj = 0;
27440 wxPyApp *arg1 = (wxPyApp *) 0 ;
27441 bool result;
27442 void *argp1 = 0 ;
27443 int res1 = 0 ;
27444 PyObject *swig_obj[1] ;
27445
27446 if (!args) SWIG_fail;
27447 swig_obj[0] = args;
27448 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27449 if (!SWIG_IsOK(res1)) {
27450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
27451 }
27452 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27453 {
27454 PyThreadState* __tstate = wxPyBeginAllowThreads();
27455 result = (bool)(arg1)->Dispatch();
27456 wxPyEndAllowThreads(__tstate);
27457 if (PyErr_Occurred()) SWIG_fail;
27458 }
27459 {
27460 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27461 }
27462 return resultobj;
27463 fail:
27464 return NULL;
27465 }
27466
27467
27468 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27469 PyObject *resultobj = 0;
27470 wxPyApp *arg1 = (wxPyApp *) 0 ;
27471 bool result;
27472 void *argp1 = 0 ;
27473 int res1 = 0 ;
27474 PyObject *swig_obj[1] ;
27475
27476 if (!args) SWIG_fail;
27477 swig_obj[0] = args;
27478 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27479 if (!SWIG_IsOK(res1)) {
27480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27481 }
27482 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27483 {
27484 PyThreadState* __tstate = wxPyBeginAllowThreads();
27485 result = (bool)(arg1)->ProcessIdle();
27486 wxPyEndAllowThreads(__tstate);
27487 if (PyErr_Occurred()) SWIG_fail;
27488 }
27489 {
27490 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27491 }
27492 return resultobj;
27493 fail:
27494 return NULL;
27495 }
27496
27497
27498 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27499 PyObject *resultobj = 0;
27500 wxPyApp *arg1 = (wxPyApp *) 0 ;
27501 wxWindow *arg2 = (wxWindow *) 0 ;
27502 wxIdleEvent *arg3 = 0 ;
27503 bool result;
27504 void *argp1 = 0 ;
27505 int res1 = 0 ;
27506 void *argp2 = 0 ;
27507 int res2 = 0 ;
27508 void *argp3 = 0 ;
27509 int res3 = 0 ;
27510 PyObject * obj0 = 0 ;
27511 PyObject * obj1 = 0 ;
27512 PyObject * obj2 = 0 ;
27513 char * kwnames[] = {
27514 (char *) "self",(char *) "win",(char *) "event", NULL
27515 };
27516
27517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27518 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27519 if (!SWIG_IsOK(res1)) {
27520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27521 }
27522 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27523 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27524 if (!SWIG_IsOK(res2)) {
27525 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
27526 }
27527 arg2 = reinterpret_cast< wxWindow * >(argp2);
27528 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
27529 if (!SWIG_IsOK(res3)) {
27530 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27531 }
27532 if (!argp3) {
27533 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27534 }
27535 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
27536 {
27537 PyThreadState* __tstate = wxPyBeginAllowThreads();
27538 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
27539 wxPyEndAllowThreads(__tstate);
27540 if (PyErr_Occurred()) SWIG_fail;
27541 }
27542 {
27543 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27544 }
27545 return resultobj;
27546 fail:
27547 return NULL;
27548 }
27549
27550
27551 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27552 PyObject *resultobj = 0;
27553 wxPyApp *arg1 = (wxPyApp *) 0 ;
27554 bool result;
27555 void *argp1 = 0 ;
27556 int res1 = 0 ;
27557 PyObject *swig_obj[1] ;
27558
27559 if (!args) SWIG_fail;
27560 swig_obj[0] = args;
27561 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27562 if (!SWIG_IsOK(res1)) {
27563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27564 }
27565 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27566 {
27567 PyThreadState* __tstate = wxPyBeginAllowThreads();
27568 result = (bool)((wxPyApp const *)arg1)->IsActive();
27569 wxPyEndAllowThreads(__tstate);
27570 if (PyErr_Occurred()) SWIG_fail;
27571 }
27572 {
27573 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27574 }
27575 return resultobj;
27576 fail:
27577 return NULL;
27578 }
27579
27580
27581 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27582 PyObject *resultobj = 0;
27583 wxPyApp *arg1 = (wxPyApp *) 0 ;
27584 wxWindow *arg2 = (wxWindow *) 0 ;
27585 void *argp1 = 0 ;
27586 int res1 = 0 ;
27587 void *argp2 = 0 ;
27588 int res2 = 0 ;
27589 PyObject * obj0 = 0 ;
27590 PyObject * obj1 = 0 ;
27591 char * kwnames[] = {
27592 (char *) "self",(char *) "win", NULL
27593 };
27594
27595 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
27596 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27597 if (!SWIG_IsOK(res1)) {
27598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
27599 }
27600 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27601 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27602 if (!SWIG_IsOK(res2)) {
27603 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
27604 }
27605 arg2 = reinterpret_cast< wxWindow * >(argp2);
27606 {
27607 PyThreadState* __tstate = wxPyBeginAllowThreads();
27608 (arg1)->SetTopWindow(arg2);
27609 wxPyEndAllowThreads(__tstate);
27610 if (PyErr_Occurred()) SWIG_fail;
27611 }
27612 resultobj = SWIG_Py_Void();
27613 return resultobj;
27614 fail:
27615 return NULL;
27616 }
27617
27618
27619 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27620 PyObject *resultobj = 0;
27621 wxPyApp *arg1 = (wxPyApp *) 0 ;
27622 wxWindow *result = 0 ;
27623 void *argp1 = 0 ;
27624 int res1 = 0 ;
27625 PyObject *swig_obj[1] ;
27626
27627 if (!args) SWIG_fail;
27628 swig_obj[0] = args;
27629 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27630 if (!SWIG_IsOK(res1)) {
27631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27632 }
27633 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27634 {
27635 PyThreadState* __tstate = wxPyBeginAllowThreads();
27636 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
27637 wxPyEndAllowThreads(__tstate);
27638 if (PyErr_Occurred()) SWIG_fail;
27639 }
27640 {
27641 resultobj = wxPyMake_wxObject(result, (bool)0);
27642 }
27643 return resultobj;
27644 fail:
27645 return NULL;
27646 }
27647
27648
27649 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27650 PyObject *resultobj = 0;
27651 wxPyApp *arg1 = (wxPyApp *) 0 ;
27652 bool arg2 ;
27653 void *argp1 = 0 ;
27654 int res1 = 0 ;
27655 bool val2 ;
27656 int ecode2 = 0 ;
27657 PyObject * obj0 = 0 ;
27658 PyObject * obj1 = 0 ;
27659 char * kwnames[] = {
27660 (char *) "self",(char *) "flag", NULL
27661 };
27662
27663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
27664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27665 if (!SWIG_IsOK(res1)) {
27666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
27667 }
27668 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27669 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27670 if (!SWIG_IsOK(ecode2)) {
27671 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
27672 }
27673 arg2 = static_cast< bool >(val2);
27674 {
27675 PyThreadState* __tstate = wxPyBeginAllowThreads();
27676 (arg1)->SetExitOnFrameDelete(arg2);
27677 wxPyEndAllowThreads(__tstate);
27678 if (PyErr_Occurred()) SWIG_fail;
27679 }
27680 resultobj = SWIG_Py_Void();
27681 return resultobj;
27682 fail:
27683 return NULL;
27684 }
27685
27686
27687 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27688 PyObject *resultobj = 0;
27689 wxPyApp *arg1 = (wxPyApp *) 0 ;
27690 bool result;
27691 void *argp1 = 0 ;
27692 int res1 = 0 ;
27693 PyObject *swig_obj[1] ;
27694
27695 if (!args) SWIG_fail;
27696 swig_obj[0] = args;
27697 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27698 if (!SWIG_IsOK(res1)) {
27699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27700 }
27701 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27702 {
27703 PyThreadState* __tstate = wxPyBeginAllowThreads();
27704 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
27705 wxPyEndAllowThreads(__tstate);
27706 if (PyErr_Occurred()) SWIG_fail;
27707 }
27708 {
27709 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27710 }
27711 return resultobj;
27712 fail:
27713 return NULL;
27714 }
27715
27716
27717 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27718 PyObject *resultobj = 0;
27719 wxPyApp *arg1 = (wxPyApp *) 0 ;
27720 bool arg2 ;
27721 void *argp1 = 0 ;
27722 int res1 = 0 ;
27723 bool val2 ;
27724 int ecode2 = 0 ;
27725 PyObject * obj0 = 0 ;
27726 PyObject * obj1 = 0 ;
27727 char * kwnames[] = {
27728 (char *) "self",(char *) "flag", NULL
27729 };
27730
27731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) SWIG_fail;
27732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27733 if (!SWIG_IsOK(res1)) {
27734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
27735 }
27736 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27737 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27738 if (!SWIG_IsOK(ecode2)) {
27739 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
27740 }
27741 arg2 = static_cast< bool >(val2);
27742 {
27743 PyThreadState* __tstate = wxPyBeginAllowThreads();
27744 (arg1)->SetUseBestVisual(arg2);
27745 wxPyEndAllowThreads(__tstate);
27746 if (PyErr_Occurred()) SWIG_fail;
27747 }
27748 resultobj = SWIG_Py_Void();
27749 return resultobj;
27750 fail:
27751 return NULL;
27752 }
27753
27754
27755 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27756 PyObject *resultobj = 0;
27757 wxPyApp *arg1 = (wxPyApp *) 0 ;
27758 bool result;
27759 void *argp1 = 0 ;
27760 int res1 = 0 ;
27761 PyObject *swig_obj[1] ;
27762
27763 if (!args) SWIG_fail;
27764 swig_obj[0] = args;
27765 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27766 if (!SWIG_IsOK(res1)) {
27767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27768 }
27769 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27770 {
27771 PyThreadState* __tstate = wxPyBeginAllowThreads();
27772 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
27773 wxPyEndAllowThreads(__tstate);
27774 if (PyErr_Occurred()) SWIG_fail;
27775 }
27776 {
27777 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27778 }
27779 return resultobj;
27780 fail:
27781 return NULL;
27782 }
27783
27784
27785 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27786 PyObject *resultobj = 0;
27787 wxPyApp *arg1 = (wxPyApp *) 0 ;
27788 int arg2 ;
27789 void *argp1 = 0 ;
27790 int res1 = 0 ;
27791 int val2 ;
27792 int ecode2 = 0 ;
27793 PyObject * obj0 = 0 ;
27794 PyObject * obj1 = 0 ;
27795 char * kwnames[] = {
27796 (char *) "self",(char *) "mode", NULL
27797 };
27798
27799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
27800 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27801 if (!SWIG_IsOK(res1)) {
27802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27803 }
27804 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27805 ecode2 = SWIG_AsVal_int(obj1, &val2);
27806 if (!SWIG_IsOK(ecode2)) {
27807 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
27808 }
27809 arg2 = static_cast< int >(val2);
27810 {
27811 PyThreadState* __tstate = wxPyBeginAllowThreads();
27812 (arg1)->SetPrintMode(arg2);
27813 wxPyEndAllowThreads(__tstate);
27814 if (PyErr_Occurred()) SWIG_fail;
27815 }
27816 resultobj = SWIG_Py_Void();
27817 return resultobj;
27818 fail:
27819 return NULL;
27820 }
27821
27822
27823 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27824 PyObject *resultobj = 0;
27825 wxPyApp *arg1 = (wxPyApp *) 0 ;
27826 int result;
27827 void *argp1 = 0 ;
27828 int res1 = 0 ;
27829 PyObject *swig_obj[1] ;
27830
27831 if (!args) SWIG_fail;
27832 swig_obj[0] = args;
27833 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27834 if (!SWIG_IsOK(res1)) {
27835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27836 }
27837 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27838 {
27839 PyThreadState* __tstate = wxPyBeginAllowThreads();
27840 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
27841 wxPyEndAllowThreads(__tstate);
27842 if (PyErr_Occurred()) SWIG_fail;
27843 }
27844 resultobj = SWIG_From_int(static_cast< int >(result));
27845 return resultobj;
27846 fail:
27847 return NULL;
27848 }
27849
27850
27851 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27852 PyObject *resultobj = 0;
27853 wxPyApp *arg1 = (wxPyApp *) 0 ;
27854 int arg2 ;
27855 void *argp1 = 0 ;
27856 int res1 = 0 ;
27857 int val2 ;
27858 int ecode2 = 0 ;
27859 PyObject * obj0 = 0 ;
27860 PyObject * obj1 = 0 ;
27861 char * kwnames[] = {
27862 (char *) "self",(char *) "mode", NULL
27863 };
27864
27865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
27866 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27867 if (!SWIG_IsOK(res1)) {
27868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27869 }
27870 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27871 ecode2 = SWIG_AsVal_int(obj1, &val2);
27872 if (!SWIG_IsOK(ecode2)) {
27873 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
27874 }
27875 arg2 = static_cast< int >(val2);
27876 {
27877 PyThreadState* __tstate = wxPyBeginAllowThreads();
27878 (arg1)->SetAssertMode(arg2);
27879 wxPyEndAllowThreads(__tstate);
27880 if (PyErr_Occurred()) SWIG_fail;
27881 }
27882 resultobj = SWIG_Py_Void();
27883 return resultobj;
27884 fail:
27885 return NULL;
27886 }
27887
27888
27889 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27890 PyObject *resultobj = 0;
27891 wxPyApp *arg1 = (wxPyApp *) 0 ;
27892 int result;
27893 void *argp1 = 0 ;
27894 int res1 = 0 ;
27895 PyObject *swig_obj[1] ;
27896
27897 if (!args) SWIG_fail;
27898 swig_obj[0] = args;
27899 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27900 if (!SWIG_IsOK(res1)) {
27901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27902 }
27903 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27904 {
27905 PyThreadState* __tstate = wxPyBeginAllowThreads();
27906 result = (int)(arg1)->GetAssertMode();
27907 wxPyEndAllowThreads(__tstate);
27908 if (PyErr_Occurred()) SWIG_fail;
27909 }
27910 resultobj = SWIG_From_int(static_cast< int >(result));
27911 return resultobj;
27912 fail:
27913 return NULL;
27914 }
27915
27916
27917 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27918 PyObject *resultobj = 0;
27919 bool result;
27920
27921 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
27922 {
27923 PyThreadState* __tstate = wxPyBeginAllowThreads();
27924 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
27925 wxPyEndAllowThreads(__tstate);
27926 if (PyErr_Occurred()) SWIG_fail;
27927 }
27928 {
27929 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27930 }
27931 return resultobj;
27932 fail:
27933 return NULL;
27934 }
27935
27936
27937 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27938 PyObject *resultobj = 0;
27939 long result;
27940
27941 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
27942 {
27943 PyThreadState* __tstate = wxPyBeginAllowThreads();
27944 result = (long)wxPyApp::GetMacAboutMenuItemId();
27945 wxPyEndAllowThreads(__tstate);
27946 if (PyErr_Occurred()) SWIG_fail;
27947 }
27948 resultobj = SWIG_From_long(static_cast< long >(result));
27949 return resultobj;
27950 fail:
27951 return NULL;
27952 }
27953
27954
27955 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27956 PyObject *resultobj = 0;
27957 long result;
27958
27959 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
27960 {
27961 PyThreadState* __tstate = wxPyBeginAllowThreads();
27962 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
27963 wxPyEndAllowThreads(__tstate);
27964 if (PyErr_Occurred()) SWIG_fail;
27965 }
27966 resultobj = SWIG_From_long(static_cast< long >(result));
27967 return resultobj;
27968 fail:
27969 return NULL;
27970 }
27971
27972
27973 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27974 PyObject *resultobj = 0;
27975 long result;
27976
27977 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
27978 {
27979 PyThreadState* __tstate = wxPyBeginAllowThreads();
27980 result = (long)wxPyApp::GetMacExitMenuItemId();
27981 wxPyEndAllowThreads(__tstate);
27982 if (PyErr_Occurred()) SWIG_fail;
27983 }
27984 resultobj = SWIG_From_long(static_cast< long >(result));
27985 return resultobj;
27986 fail:
27987 return NULL;
27988 }
27989
27990
27991 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27992 PyObject *resultobj = 0;
27993 wxString result;
27994
27995 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
27996 {
27997 PyThreadState* __tstate = wxPyBeginAllowThreads();
27998 result = wxPyApp::GetMacHelpMenuTitleName();
27999 wxPyEndAllowThreads(__tstate);
28000 if (PyErr_Occurred()) SWIG_fail;
28001 }
28002 {
28003 #if wxUSE_UNICODE
28004 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28005 #else
28006 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28007 #endif
28008 }
28009 return resultobj;
28010 fail:
28011 return NULL;
28012 }
28013
28014
28015 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28016 PyObject *resultobj = 0;
28017 bool arg1 ;
28018 bool val1 ;
28019 int ecode1 = 0 ;
28020 PyObject * obj0 = 0 ;
28021 char * kwnames[] = {
28022 (char *) "val", NULL
28023 };
28024
28025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
28026 ecode1 = SWIG_AsVal_bool(obj0, &val1);
28027 if (!SWIG_IsOK(ecode1)) {
28028 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
28029 }
28030 arg1 = static_cast< bool >(val1);
28031 {
28032 PyThreadState* __tstate = wxPyBeginAllowThreads();
28033 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
28034 wxPyEndAllowThreads(__tstate);
28035 if (PyErr_Occurred()) SWIG_fail;
28036 }
28037 resultobj = SWIG_Py_Void();
28038 return resultobj;
28039 fail:
28040 return NULL;
28041 }
28042
28043
28044 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28045 PyObject *resultobj = 0;
28046 long arg1 ;
28047 long val1 ;
28048 int ecode1 = 0 ;
28049 PyObject * obj0 = 0 ;
28050 char * kwnames[] = {
28051 (char *) "val", NULL
28052 };
28053
28054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
28055 ecode1 = SWIG_AsVal_long(obj0, &val1);
28056 if (!SWIG_IsOK(ecode1)) {
28057 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
28058 }
28059 arg1 = static_cast< long >(val1);
28060 {
28061 PyThreadState* __tstate = wxPyBeginAllowThreads();
28062 wxPyApp::SetMacAboutMenuItemId(arg1);
28063 wxPyEndAllowThreads(__tstate);
28064 if (PyErr_Occurred()) SWIG_fail;
28065 }
28066 resultobj = SWIG_Py_Void();
28067 return resultobj;
28068 fail:
28069 return NULL;
28070 }
28071
28072
28073 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28074 PyObject *resultobj = 0;
28075 long arg1 ;
28076 long val1 ;
28077 int ecode1 = 0 ;
28078 PyObject * obj0 = 0 ;
28079 char * kwnames[] = {
28080 (char *) "val", NULL
28081 };
28082
28083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
28084 ecode1 = SWIG_AsVal_long(obj0, &val1);
28085 if (!SWIG_IsOK(ecode1)) {
28086 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
28087 }
28088 arg1 = static_cast< long >(val1);
28089 {
28090 PyThreadState* __tstate = wxPyBeginAllowThreads();
28091 wxPyApp::SetMacPreferencesMenuItemId(arg1);
28092 wxPyEndAllowThreads(__tstate);
28093 if (PyErr_Occurred()) SWIG_fail;
28094 }
28095 resultobj = SWIG_Py_Void();
28096 return resultobj;
28097 fail:
28098 return NULL;
28099 }
28100
28101
28102 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28103 PyObject *resultobj = 0;
28104 long arg1 ;
28105 long val1 ;
28106 int ecode1 = 0 ;
28107 PyObject * obj0 = 0 ;
28108 char * kwnames[] = {
28109 (char *) "val", NULL
28110 };
28111
28112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
28113 ecode1 = SWIG_AsVal_long(obj0, &val1);
28114 if (!SWIG_IsOK(ecode1)) {
28115 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
28116 }
28117 arg1 = static_cast< long >(val1);
28118 {
28119 PyThreadState* __tstate = wxPyBeginAllowThreads();
28120 wxPyApp::SetMacExitMenuItemId(arg1);
28121 wxPyEndAllowThreads(__tstate);
28122 if (PyErr_Occurred()) SWIG_fail;
28123 }
28124 resultobj = SWIG_Py_Void();
28125 return resultobj;
28126 fail:
28127 return NULL;
28128 }
28129
28130
28131 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28132 PyObject *resultobj = 0;
28133 wxString *arg1 = 0 ;
28134 bool temp1 = false ;
28135 PyObject * obj0 = 0 ;
28136 char * kwnames[] = {
28137 (char *) "val", NULL
28138 };
28139
28140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
28141 {
28142 arg1 = wxString_in_helper(obj0);
28143 if (arg1 == NULL) SWIG_fail;
28144 temp1 = true;
28145 }
28146 {
28147 PyThreadState* __tstate = wxPyBeginAllowThreads();
28148 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
28149 wxPyEndAllowThreads(__tstate);
28150 if (PyErr_Occurred()) SWIG_fail;
28151 }
28152 resultobj = SWIG_Py_Void();
28153 {
28154 if (temp1)
28155 delete arg1;
28156 }
28157 return resultobj;
28158 fail:
28159 {
28160 if (temp1)
28161 delete arg1;
28162 }
28163 return NULL;
28164 }
28165
28166
28167 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28168 PyObject *resultobj = 0;
28169 wxPyApp *arg1 = (wxPyApp *) 0 ;
28170 void *argp1 = 0 ;
28171 int res1 = 0 ;
28172 PyObject *swig_obj[1] ;
28173
28174 if (!args) SWIG_fail;
28175 swig_obj[0] = args;
28176 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28177 if (!SWIG_IsOK(res1)) {
28178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
28179 }
28180 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28181 {
28182 PyThreadState* __tstate = wxPyBeginAllowThreads();
28183 (arg1)->_BootstrapApp();
28184 wxPyEndAllowThreads(__tstate);
28185 if (PyErr_Occurred()) SWIG_fail;
28186 }
28187 resultobj = SWIG_Py_Void();
28188 return resultobj;
28189 fail:
28190 return NULL;
28191 }
28192
28193
28194 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28195 PyObject *resultobj = 0;
28196 int result;
28197
28198 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
28199 {
28200 PyThreadState* __tstate = wxPyBeginAllowThreads();
28201 result = (int)wxPyApp_GetComCtl32Version();
28202 wxPyEndAllowThreads(__tstate);
28203 if (PyErr_Occurred()) SWIG_fail;
28204 }
28205 resultobj = SWIG_From_int(static_cast< int >(result));
28206 return resultobj;
28207 fail:
28208 return NULL;
28209 }
28210
28211
28212 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28213 PyObject *obj;
28214 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28215 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
28216 return SWIG_Py_Void();
28217 }
28218
28219 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28220 return SWIG_Python_InitShadowInstance(args);
28221 }
28222
28223 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28224 PyObject *resultobj = 0;
28225
28226 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
28227 {
28228 PyThreadState* __tstate = wxPyBeginAllowThreads();
28229 wxExit();
28230 wxPyEndAllowThreads(__tstate);
28231 if (PyErr_Occurred()) SWIG_fail;
28232 }
28233 resultobj = SWIG_Py_Void();
28234 return resultobj;
28235 fail:
28236 return NULL;
28237 }
28238
28239
28240 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28241 PyObject *resultobj = 0;
28242 bool result;
28243
28244 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
28245 {
28246 PyThreadState* __tstate = wxPyBeginAllowThreads();
28247 result = (bool)wxYield();
28248 wxPyEndAllowThreads(__tstate);
28249 if (PyErr_Occurred()) SWIG_fail;
28250 }
28251 {
28252 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28253 }
28254 return resultobj;
28255 fail:
28256 return NULL;
28257 }
28258
28259
28260 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28261 PyObject *resultobj = 0;
28262 bool result;
28263
28264 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
28265 {
28266 PyThreadState* __tstate = wxPyBeginAllowThreads();
28267 result = (bool)wxYieldIfNeeded();
28268 wxPyEndAllowThreads(__tstate);
28269 if (PyErr_Occurred()) SWIG_fail;
28270 }
28271 {
28272 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28273 }
28274 return resultobj;
28275 fail:
28276 return NULL;
28277 }
28278
28279
28280 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28281 PyObject *resultobj = 0;
28282 wxWindow *arg1 = (wxWindow *) NULL ;
28283 bool arg2 = (bool) false ;
28284 bool result;
28285 void *argp1 = 0 ;
28286 int res1 = 0 ;
28287 bool val2 ;
28288 int ecode2 = 0 ;
28289 PyObject * obj0 = 0 ;
28290 PyObject * obj1 = 0 ;
28291 char * kwnames[] = {
28292 (char *) "win",(char *) "onlyIfNeeded", NULL
28293 };
28294
28295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
28296 if (obj0) {
28297 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28298 if (!SWIG_IsOK(res1)) {
28299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
28300 }
28301 arg1 = reinterpret_cast< wxWindow * >(argp1);
28302 }
28303 if (obj1) {
28304 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28305 if (!SWIG_IsOK(ecode2)) {
28306 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
28307 }
28308 arg2 = static_cast< bool >(val2);
28309 }
28310 {
28311 PyThreadState* __tstate = wxPyBeginAllowThreads();
28312 result = (bool)wxSafeYield(arg1,arg2);
28313 wxPyEndAllowThreads(__tstate);
28314 if (PyErr_Occurred()) SWIG_fail;
28315 }
28316 {
28317 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28318 }
28319 return resultobj;
28320 fail:
28321 return NULL;
28322 }
28323
28324
28325 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28326 PyObject *resultobj = 0;
28327
28328 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
28329 {
28330 PyThreadState* __tstate = wxPyBeginAllowThreads();
28331 wxWakeUpIdle();
28332 wxPyEndAllowThreads(__tstate);
28333 if (PyErr_Occurred()) SWIG_fail;
28334 }
28335 resultobj = SWIG_Py_Void();
28336 return resultobj;
28337 fail:
28338 return NULL;
28339 }
28340
28341
28342 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28343 PyObject *resultobj = 0;
28344 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
28345 wxEvent *arg2 = 0 ;
28346 void *argp1 = 0 ;
28347 int res1 = 0 ;
28348 void *argp2 = 0 ;
28349 int res2 = 0 ;
28350 PyObject * obj0 = 0 ;
28351 PyObject * obj1 = 0 ;
28352 char * kwnames[] = {
28353 (char *) "dest",(char *) "event", NULL
28354 };
28355
28356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28357 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
28358 if (!SWIG_IsOK(res1)) {
28359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
28360 }
28361 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
28362 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
28363 if (!SWIG_IsOK(res2)) {
28364 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28365 }
28366 if (!argp2) {
28367 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28368 }
28369 arg2 = reinterpret_cast< wxEvent * >(argp2);
28370 {
28371 PyThreadState* __tstate = wxPyBeginAllowThreads();
28372 wxPostEvent(arg1,*arg2);
28373 wxPyEndAllowThreads(__tstate);
28374 if (PyErr_Occurred()) SWIG_fail;
28375 }
28376 resultobj = SWIG_Py_Void();
28377 return resultobj;
28378 fail:
28379 return NULL;
28380 }
28381
28382
28383 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28384 PyObject *resultobj = 0;
28385
28386 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
28387 {
28388 PyThreadState* __tstate = wxPyBeginAllowThreads();
28389 wxApp_CleanUp();
28390 wxPyEndAllowThreads(__tstate);
28391 if (PyErr_Occurred()) SWIG_fail;
28392 }
28393 resultobj = SWIG_Py_Void();
28394 return resultobj;
28395 fail:
28396 return NULL;
28397 }
28398
28399
28400 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28401 PyObject *resultobj = 0;
28402 wxPyApp *result = 0 ;
28403
28404 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
28405 {
28406 PyThreadState* __tstate = wxPyBeginAllowThreads();
28407 result = (wxPyApp *)wxPyGetApp();
28408 wxPyEndAllowThreads(__tstate);
28409 if (PyErr_Occurred()) SWIG_fail;
28410 }
28411 {
28412 resultobj = wxPyMake_wxObject(result, 0);
28413 }
28414 return resultobj;
28415 fail:
28416 return NULL;
28417 }
28418
28419
28420 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28421 PyObject *resultobj = 0;
28422 char *arg1 = (char *) 0 ;
28423 int res1 ;
28424 char *buf1 = 0 ;
28425 int alloc1 = 0 ;
28426 PyObject * obj0 = 0 ;
28427 char * kwnames[] = {
28428 (char *) "encoding", NULL
28429 };
28430
28431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
28432 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
28433 if (!SWIG_IsOK(res1)) {
28434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
28435 }
28436 arg1 = buf1;
28437 {
28438 PyThreadState* __tstate = wxPyBeginAllowThreads();
28439 wxSetDefaultPyEncoding((char const *)arg1);
28440 wxPyEndAllowThreads(__tstate);
28441 if (PyErr_Occurred()) SWIG_fail;
28442 }
28443 resultobj = SWIG_Py_Void();
28444 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28445 return resultobj;
28446 fail:
28447 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28448 return NULL;
28449 }
28450
28451
28452 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28453 PyObject *resultobj = 0;
28454 char *result = 0 ;
28455
28456 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
28457 {
28458 PyThreadState* __tstate = wxPyBeginAllowThreads();
28459 result = (char *)wxGetDefaultPyEncoding();
28460 wxPyEndAllowThreads(__tstate);
28461 if (PyErr_Occurred()) SWIG_fail;
28462 }
28463 resultobj = SWIG_FromCharPtr(result);
28464 return resultobj;
28465 fail:
28466 return NULL;
28467 }
28468
28469
28470 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28471 PyObject *resultobj = 0;
28472 wxEventLoop *result = 0 ;
28473
28474 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
28475 {
28476 PyThreadState* __tstate = wxPyBeginAllowThreads();
28477 result = (wxEventLoop *)new wxEventLoop();
28478 wxPyEndAllowThreads(__tstate);
28479 if (PyErr_Occurred()) SWIG_fail;
28480 }
28481 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
28482 return resultobj;
28483 fail:
28484 return NULL;
28485 }
28486
28487
28488 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28489 PyObject *resultobj = 0;
28490 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28491 void *argp1 = 0 ;
28492 int res1 = 0 ;
28493 PyObject *swig_obj[1] ;
28494
28495 if (!args) SWIG_fail;
28496 swig_obj[0] = args;
28497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
28498 if (!SWIG_IsOK(res1)) {
28499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28500 }
28501 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28502 {
28503 PyThreadState* __tstate = wxPyBeginAllowThreads();
28504 delete arg1;
28505
28506 wxPyEndAllowThreads(__tstate);
28507 if (PyErr_Occurred()) SWIG_fail;
28508 }
28509 resultobj = SWIG_Py_Void();
28510 return resultobj;
28511 fail:
28512 return NULL;
28513 }
28514
28515
28516 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28517 PyObject *resultobj = 0;
28518 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28519 int result;
28520 void *argp1 = 0 ;
28521 int res1 = 0 ;
28522 PyObject *swig_obj[1] ;
28523
28524 if (!args) SWIG_fail;
28525 swig_obj[0] = args;
28526 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28527 if (!SWIG_IsOK(res1)) {
28528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28529 }
28530 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28531 {
28532 PyThreadState* __tstate = wxPyBeginAllowThreads();
28533 result = (int)(arg1)->Run();
28534 wxPyEndAllowThreads(__tstate);
28535 if (PyErr_Occurred()) SWIG_fail;
28536 }
28537 resultobj = SWIG_From_int(static_cast< int >(result));
28538 return resultobj;
28539 fail:
28540 return NULL;
28541 }
28542
28543
28544 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28545 PyObject *resultobj = 0;
28546 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28547 int arg2 = (int) 0 ;
28548 void *argp1 = 0 ;
28549 int res1 = 0 ;
28550 int val2 ;
28551 int ecode2 = 0 ;
28552 PyObject * obj0 = 0 ;
28553 PyObject * obj1 = 0 ;
28554 char * kwnames[] = {
28555 (char *) "self",(char *) "rc", NULL
28556 };
28557
28558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
28559 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28560 if (!SWIG_IsOK(res1)) {
28561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28562 }
28563 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28564 if (obj1) {
28565 ecode2 = SWIG_AsVal_int(obj1, &val2);
28566 if (!SWIG_IsOK(ecode2)) {
28567 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
28568 }
28569 arg2 = static_cast< int >(val2);
28570 }
28571 {
28572 PyThreadState* __tstate = wxPyBeginAllowThreads();
28573 (arg1)->Exit(arg2);
28574 wxPyEndAllowThreads(__tstate);
28575 if (PyErr_Occurred()) SWIG_fail;
28576 }
28577 resultobj = SWIG_Py_Void();
28578 return resultobj;
28579 fail:
28580 return NULL;
28581 }
28582
28583
28584 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28585 PyObject *resultobj = 0;
28586 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28587 bool result;
28588 void *argp1 = 0 ;
28589 int res1 = 0 ;
28590 PyObject *swig_obj[1] ;
28591
28592 if (!args) SWIG_fail;
28593 swig_obj[0] = args;
28594 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28595 if (!SWIG_IsOK(res1)) {
28596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28597 }
28598 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28599 {
28600 PyThreadState* __tstate = wxPyBeginAllowThreads();
28601 result = (bool)((wxEventLoop const *)arg1)->Pending();
28602 wxPyEndAllowThreads(__tstate);
28603 if (PyErr_Occurred()) SWIG_fail;
28604 }
28605 {
28606 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28607 }
28608 return resultobj;
28609 fail:
28610 return NULL;
28611 }
28612
28613
28614 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28615 PyObject *resultobj = 0;
28616 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28617 bool result;
28618 void *argp1 = 0 ;
28619 int res1 = 0 ;
28620 PyObject *swig_obj[1] ;
28621
28622 if (!args) SWIG_fail;
28623 swig_obj[0] = args;
28624 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28625 if (!SWIG_IsOK(res1)) {
28626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28627 }
28628 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28629 {
28630 PyThreadState* __tstate = wxPyBeginAllowThreads();
28631 result = (bool)(arg1)->Dispatch();
28632 wxPyEndAllowThreads(__tstate);
28633 if (PyErr_Occurred()) SWIG_fail;
28634 }
28635 {
28636 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28637 }
28638 return resultobj;
28639 fail:
28640 return NULL;
28641 }
28642
28643
28644 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28645 PyObject *resultobj = 0;
28646 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28647 bool result;
28648 void *argp1 = 0 ;
28649 int res1 = 0 ;
28650 PyObject *swig_obj[1] ;
28651
28652 if (!args) SWIG_fail;
28653 swig_obj[0] = args;
28654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28655 if (!SWIG_IsOK(res1)) {
28656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28657 }
28658 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28659 {
28660 PyThreadState* __tstate = wxPyBeginAllowThreads();
28661 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
28662 wxPyEndAllowThreads(__tstate);
28663 if (PyErr_Occurred()) SWIG_fail;
28664 }
28665 {
28666 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28667 }
28668 return resultobj;
28669 fail:
28670 return NULL;
28671 }
28672
28673
28674 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28675 PyObject *resultobj = 0;
28676 wxEventLoop *result = 0 ;
28677
28678 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
28679 {
28680 PyThreadState* __tstate = wxPyBeginAllowThreads();
28681 result = (wxEventLoop *)wxEventLoop::GetActive();
28682 wxPyEndAllowThreads(__tstate);
28683 if (PyErr_Occurred()) SWIG_fail;
28684 }
28685 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
28686 return resultobj;
28687 fail:
28688 return NULL;
28689 }
28690
28691
28692 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28693 PyObject *resultobj = 0;
28694 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28695 void *argp1 = 0 ;
28696 int res1 = 0 ;
28697 PyObject * obj0 = 0 ;
28698 char * kwnames[] = {
28699 (char *) "loop", NULL
28700 };
28701
28702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
28703 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28704 if (!SWIG_IsOK(res1)) {
28705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28706 }
28707 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28708 {
28709 PyThreadState* __tstate = wxPyBeginAllowThreads();
28710 wxEventLoop::SetActive(arg1);
28711 wxPyEndAllowThreads(__tstate);
28712 if (PyErr_Occurred()) SWIG_fail;
28713 }
28714 resultobj = SWIG_Py_Void();
28715 return resultobj;
28716 fail:
28717 return NULL;
28718 }
28719
28720
28721 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28722 PyObject *obj;
28723 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28724 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
28725 return SWIG_Py_Void();
28726 }
28727
28728 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28729 return SWIG_Python_InitShadowInstance(args);
28730 }
28731
28732 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28733 PyObject *resultobj = 0;
28734 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28735 wxEventLoopActivator *result = 0 ;
28736 void *argp1 = 0 ;
28737 int res1 = 0 ;
28738 PyObject * obj0 = 0 ;
28739 char * kwnames[] = {
28740 (char *) "evtLoop", NULL
28741 };
28742
28743 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
28744 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28745 if (!SWIG_IsOK(res1)) {
28746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28747 }
28748 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28749 {
28750 PyThreadState* __tstate = wxPyBeginAllowThreads();
28751 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
28752 wxPyEndAllowThreads(__tstate);
28753 if (PyErr_Occurred()) SWIG_fail;
28754 }
28755 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
28756 return resultobj;
28757 fail:
28758 return NULL;
28759 }
28760
28761
28762 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28763 PyObject *resultobj = 0;
28764 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
28765 void *argp1 = 0 ;
28766 int res1 = 0 ;
28767 PyObject *swig_obj[1] ;
28768
28769 if (!args) SWIG_fail;
28770 swig_obj[0] = args;
28771 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
28772 if (!SWIG_IsOK(res1)) {
28773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
28774 }
28775 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
28776 {
28777 PyThreadState* __tstate = wxPyBeginAllowThreads();
28778 delete arg1;
28779
28780 wxPyEndAllowThreads(__tstate);
28781 if (PyErr_Occurred()) SWIG_fail;
28782 }
28783 resultobj = SWIG_Py_Void();
28784 return resultobj;
28785 fail:
28786 return NULL;
28787 }
28788
28789
28790 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28791 PyObject *obj;
28792 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28793 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
28794 return SWIG_Py_Void();
28795 }
28796
28797 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28798 return SWIG_Python_InitShadowInstance(args);
28799 }
28800
28801 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28802 PyObject *resultobj = 0;
28803 int arg1 = (int) 0 ;
28804 int arg2 = (int) 0 ;
28805 int arg3 = (int) 0 ;
28806 wxAcceleratorEntry *result = 0 ;
28807 int val1 ;
28808 int ecode1 = 0 ;
28809 int val2 ;
28810 int ecode2 = 0 ;
28811 int val3 ;
28812 int ecode3 = 0 ;
28813 PyObject * obj0 = 0 ;
28814 PyObject * obj1 = 0 ;
28815 PyObject * obj2 = 0 ;
28816 char * kwnames[] = {
28817 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
28818 };
28819
28820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28821 if (obj0) {
28822 ecode1 = SWIG_AsVal_int(obj0, &val1);
28823 if (!SWIG_IsOK(ecode1)) {
28824 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
28825 }
28826 arg1 = static_cast< int >(val1);
28827 }
28828 if (obj1) {
28829 ecode2 = SWIG_AsVal_int(obj1, &val2);
28830 if (!SWIG_IsOK(ecode2)) {
28831 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
28832 }
28833 arg2 = static_cast< int >(val2);
28834 }
28835 if (obj2) {
28836 ecode3 = SWIG_AsVal_int(obj2, &val3);
28837 if (!SWIG_IsOK(ecode3)) {
28838 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
28839 }
28840 arg3 = static_cast< int >(val3);
28841 }
28842 {
28843 PyThreadState* __tstate = wxPyBeginAllowThreads();
28844 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
28845 wxPyEndAllowThreads(__tstate);
28846 if (PyErr_Occurred()) SWIG_fail;
28847 }
28848 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
28849 return resultobj;
28850 fail:
28851 return NULL;
28852 }
28853
28854
28855 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28856 PyObject *resultobj = 0;
28857 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28858 void *argp1 = 0 ;
28859 int res1 = 0 ;
28860 PyObject *swig_obj[1] ;
28861
28862 if (!args) SWIG_fail;
28863 swig_obj[0] = args;
28864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
28865 if (!SWIG_IsOK(res1)) {
28866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28867 }
28868 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28869 {
28870 PyThreadState* __tstate = wxPyBeginAllowThreads();
28871 delete arg1;
28872
28873 wxPyEndAllowThreads(__tstate);
28874 if (PyErr_Occurred()) SWIG_fail;
28875 }
28876 resultobj = SWIG_Py_Void();
28877 return resultobj;
28878 fail:
28879 return NULL;
28880 }
28881
28882
28883 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28884 PyObject *resultobj = 0;
28885 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28886 int arg2 ;
28887 int arg3 ;
28888 int arg4 ;
28889 void *argp1 = 0 ;
28890 int res1 = 0 ;
28891 int val2 ;
28892 int ecode2 = 0 ;
28893 int val3 ;
28894 int ecode3 = 0 ;
28895 int val4 ;
28896 int ecode4 = 0 ;
28897 PyObject * obj0 = 0 ;
28898 PyObject * obj1 = 0 ;
28899 PyObject * obj2 = 0 ;
28900 PyObject * obj3 = 0 ;
28901 char * kwnames[] = {
28902 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
28903 };
28904
28905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28906 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28907 if (!SWIG_IsOK(res1)) {
28908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28909 }
28910 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28911 ecode2 = SWIG_AsVal_int(obj1, &val2);
28912 if (!SWIG_IsOK(ecode2)) {
28913 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
28914 }
28915 arg2 = static_cast< int >(val2);
28916 ecode3 = SWIG_AsVal_int(obj2, &val3);
28917 if (!SWIG_IsOK(ecode3)) {
28918 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
28919 }
28920 arg3 = static_cast< int >(val3);
28921 ecode4 = SWIG_AsVal_int(obj3, &val4);
28922 if (!SWIG_IsOK(ecode4)) {
28923 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
28924 }
28925 arg4 = static_cast< int >(val4);
28926 {
28927 PyThreadState* __tstate = wxPyBeginAllowThreads();
28928 (arg1)->Set(arg2,arg3,arg4);
28929 wxPyEndAllowThreads(__tstate);
28930 if (PyErr_Occurred()) SWIG_fail;
28931 }
28932 resultobj = SWIG_Py_Void();
28933 return resultobj;
28934 fail:
28935 return NULL;
28936 }
28937
28938
28939 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28940 PyObject *resultobj = 0;
28941 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28942 int result;
28943 void *argp1 = 0 ;
28944 int res1 = 0 ;
28945 PyObject *swig_obj[1] ;
28946
28947 if (!args) SWIG_fail;
28948 swig_obj[0] = args;
28949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28950 if (!SWIG_IsOK(res1)) {
28951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28952 }
28953 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28954 {
28955 PyThreadState* __tstate = wxPyBeginAllowThreads();
28956 result = (int)(arg1)->GetFlags();
28957 wxPyEndAllowThreads(__tstate);
28958 if (PyErr_Occurred()) SWIG_fail;
28959 }
28960 resultobj = SWIG_From_int(static_cast< int >(result));
28961 return resultobj;
28962 fail:
28963 return NULL;
28964 }
28965
28966
28967 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28968 PyObject *resultobj = 0;
28969 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28970 int result;
28971 void *argp1 = 0 ;
28972 int res1 = 0 ;
28973 PyObject *swig_obj[1] ;
28974
28975 if (!args) SWIG_fail;
28976 swig_obj[0] = args;
28977 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28978 if (!SWIG_IsOK(res1)) {
28979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28980 }
28981 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28982 {
28983 PyThreadState* __tstate = wxPyBeginAllowThreads();
28984 result = (int)(arg1)->GetKeyCode();
28985 wxPyEndAllowThreads(__tstate);
28986 if (PyErr_Occurred()) SWIG_fail;
28987 }
28988 resultobj = SWIG_From_int(static_cast< int >(result));
28989 return resultobj;
28990 fail:
28991 return NULL;
28992 }
28993
28994
28995 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28996 PyObject *resultobj = 0;
28997 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28998 int result;
28999 void *argp1 = 0 ;
29000 int res1 = 0 ;
29001 PyObject *swig_obj[1] ;
29002
29003 if (!args) SWIG_fail;
29004 swig_obj[0] = args;
29005 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29006 if (!SWIG_IsOK(res1)) {
29007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29008 }
29009 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29010 {
29011 PyThreadState* __tstate = wxPyBeginAllowThreads();
29012 result = (int)(arg1)->GetCommand();
29013 wxPyEndAllowThreads(__tstate);
29014 if (PyErr_Occurred()) SWIG_fail;
29015 }
29016 resultobj = SWIG_From_int(static_cast< int >(result));
29017 return resultobj;
29018 fail:
29019 return NULL;
29020 }
29021
29022
29023 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29024 PyObject *obj;
29025 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29026 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
29027 return SWIG_Py_Void();
29028 }
29029
29030 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29031 return SWIG_Python_InitShadowInstance(args);
29032 }
29033
29034 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29035 PyObject *resultobj = 0;
29036 int arg1 ;
29037 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
29038 wxAcceleratorTable *result = 0 ;
29039 PyObject * obj0 = 0 ;
29040 char * kwnames[] = {
29041 (char *) "n", NULL
29042 };
29043
29044 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
29045 {
29046 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
29047 if (arg2) arg1 = PyList_Size(obj0);
29048 else arg1 = 0;
29049 }
29050 {
29051 PyThreadState* __tstate = wxPyBeginAllowThreads();
29052 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
29053 wxPyEndAllowThreads(__tstate);
29054 if (PyErr_Occurred()) SWIG_fail;
29055 }
29056 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
29057 return resultobj;
29058 fail:
29059 return NULL;
29060 }
29061
29062
29063 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29064 PyObject *resultobj = 0;
29065 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29066 void *argp1 = 0 ;
29067 int res1 = 0 ;
29068 PyObject *swig_obj[1] ;
29069
29070 if (!args) SWIG_fail;
29071 swig_obj[0] = args;
29072 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
29073 if (!SWIG_IsOK(res1)) {
29074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
29075 }
29076 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29077 {
29078 PyThreadState* __tstate = wxPyBeginAllowThreads();
29079 delete arg1;
29080
29081 wxPyEndAllowThreads(__tstate);
29082 if (PyErr_Occurred()) SWIG_fail;
29083 }
29084 resultobj = SWIG_Py_Void();
29085 return resultobj;
29086 fail:
29087 return NULL;
29088 }
29089
29090
29091 SWIGINTERN PyObject *_wrap_AcceleratorTable_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29092 PyObject *resultobj = 0;
29093 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29094 bool result;
29095 void *argp1 = 0 ;
29096 int res1 = 0 ;
29097 PyObject *swig_obj[1] ;
29098
29099 if (!args) SWIG_fail;
29100 swig_obj[0] = args;
29101 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
29102 if (!SWIG_IsOK(res1)) {
29103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_Ok" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
29104 }
29105 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29106 {
29107 PyThreadState* __tstate = wxPyBeginAllowThreads();
29108 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
29109 wxPyEndAllowThreads(__tstate);
29110 if (PyErr_Occurred()) SWIG_fail;
29111 }
29112 {
29113 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29114 }
29115 return resultobj;
29116 fail:
29117 return NULL;
29118 }
29119
29120
29121 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29122 PyObject *obj;
29123 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29124 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
29125 return SWIG_Py_Void();
29126 }
29127
29128 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29129 return SWIG_Python_InitShadowInstance(args);
29130 }
29131
29132 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
29133 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
29134 return 1;
29135 }
29136
29137
29138 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
29139 PyObject *pyobj = 0;
29140
29141 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
29142 return pyobj;
29143 }
29144
29145
29146 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29147 PyObject *resultobj = 0;
29148 wxString *arg1 = 0 ;
29149 wxAcceleratorEntry *result = 0 ;
29150 bool temp1 = false ;
29151 PyObject * obj0 = 0 ;
29152 char * kwnames[] = {
29153 (char *) "label", NULL
29154 };
29155
29156 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
29157 {
29158 arg1 = wxString_in_helper(obj0);
29159 if (arg1 == NULL) SWIG_fail;
29160 temp1 = true;
29161 }
29162 {
29163 PyThreadState* __tstate = wxPyBeginAllowThreads();
29164 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
29165 wxPyEndAllowThreads(__tstate);
29166 if (PyErr_Occurred()) SWIG_fail;
29167 }
29168 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29169 {
29170 if (temp1)
29171 delete arg1;
29172 }
29173 return resultobj;
29174 fail:
29175 {
29176 if (temp1)
29177 delete arg1;
29178 }
29179 return NULL;
29180 }
29181
29182
29183 SWIGINTERN int PanelNameStr_set(PyObject *) {
29184 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
29185 return 1;
29186 }
29187
29188
29189 SWIGINTERN PyObject *PanelNameStr_get(void) {
29190 PyObject *pyobj = 0;
29191
29192 {
29193 #if wxUSE_UNICODE
29194 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29195 #else
29196 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29197 #endif
29198 }
29199 return pyobj;
29200 }
29201
29202
29203 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29204 PyObject *resultobj = 0;
29205 wxVisualAttributes *result = 0 ;
29206
29207 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
29208 {
29209 PyThreadState* __tstate = wxPyBeginAllowThreads();
29210 result = (wxVisualAttributes *)new_wxVisualAttributes();
29211 wxPyEndAllowThreads(__tstate);
29212 if (PyErr_Occurred()) SWIG_fail;
29213 }
29214 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
29215 return resultobj;
29216 fail:
29217 return NULL;
29218 }
29219
29220
29221 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29222 PyObject *resultobj = 0;
29223 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29224 void *argp1 = 0 ;
29225 int res1 = 0 ;
29226 PyObject *swig_obj[1] ;
29227
29228 if (!args) SWIG_fail;
29229 swig_obj[0] = args;
29230 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
29231 if (!SWIG_IsOK(res1)) {
29232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29233 }
29234 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29235 {
29236 PyThreadState* __tstate = wxPyBeginAllowThreads();
29237 delete_wxVisualAttributes(arg1);
29238
29239 wxPyEndAllowThreads(__tstate);
29240 if (PyErr_Occurred()) SWIG_fail;
29241 }
29242 resultobj = SWIG_Py_Void();
29243 return resultobj;
29244 fail:
29245 return NULL;
29246 }
29247
29248
29249 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29250 PyObject *resultobj = 0;
29251 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29252 wxFont *arg2 = (wxFont *) 0 ;
29253 void *argp1 = 0 ;
29254 int res1 = 0 ;
29255 void *argp2 = 0 ;
29256 int res2 = 0 ;
29257 PyObject *swig_obj[2] ;
29258
29259 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
29260 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29261 if (!SWIG_IsOK(res1)) {
29262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29263 }
29264 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29265 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
29266 if (!SWIG_IsOK(res2)) {
29267 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
29268 }
29269 arg2 = reinterpret_cast< wxFont * >(argp2);
29270 if (arg1) (arg1)->font = *arg2;
29271
29272 resultobj = SWIG_Py_Void();
29273 return resultobj;
29274 fail:
29275 return NULL;
29276 }
29277
29278
29279 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29280 PyObject *resultobj = 0;
29281 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29282 wxFont *result = 0 ;
29283 void *argp1 = 0 ;
29284 int res1 = 0 ;
29285 PyObject *swig_obj[1] ;
29286
29287 if (!args) SWIG_fail;
29288 swig_obj[0] = args;
29289 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29290 if (!SWIG_IsOK(res1)) {
29291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29292 }
29293 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29294 result = (wxFont *)& ((arg1)->font);
29295 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
29296 return resultobj;
29297 fail:
29298 return NULL;
29299 }
29300
29301
29302 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29303 PyObject *resultobj = 0;
29304 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29305 wxColour *arg2 = (wxColour *) 0 ;
29306 void *argp1 = 0 ;
29307 int res1 = 0 ;
29308 void *argp2 = 0 ;
29309 int res2 = 0 ;
29310 PyObject *swig_obj[2] ;
29311
29312 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
29313 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29314 if (!SWIG_IsOK(res1)) {
29315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29316 }
29317 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29318 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29319 if (!SWIG_IsOK(res2)) {
29320 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29321 }
29322 arg2 = reinterpret_cast< wxColour * >(argp2);
29323 if (arg1) (arg1)->colFg = *arg2;
29324
29325 resultobj = SWIG_Py_Void();
29326 return resultobj;
29327 fail:
29328 return NULL;
29329 }
29330
29331
29332 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29333 PyObject *resultobj = 0;
29334 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29335 wxColour *result = 0 ;
29336 void *argp1 = 0 ;
29337 int res1 = 0 ;
29338 PyObject *swig_obj[1] ;
29339
29340 if (!args) SWIG_fail;
29341 swig_obj[0] = args;
29342 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29343 if (!SWIG_IsOK(res1)) {
29344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29345 }
29346 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29347 result = (wxColour *)& ((arg1)->colFg);
29348 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29349 return resultobj;
29350 fail:
29351 return NULL;
29352 }
29353
29354
29355 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29356 PyObject *resultobj = 0;
29357 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29358 wxColour *arg2 = (wxColour *) 0 ;
29359 void *argp1 = 0 ;
29360 int res1 = 0 ;
29361 void *argp2 = 0 ;
29362 int res2 = 0 ;
29363 PyObject *swig_obj[2] ;
29364
29365 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
29366 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29367 if (!SWIG_IsOK(res1)) {
29368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29369 }
29370 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29371 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29372 if (!SWIG_IsOK(res2)) {
29373 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29374 }
29375 arg2 = reinterpret_cast< wxColour * >(argp2);
29376 if (arg1) (arg1)->colBg = *arg2;
29377
29378 resultobj = SWIG_Py_Void();
29379 return resultobj;
29380 fail:
29381 return NULL;
29382 }
29383
29384
29385 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29386 PyObject *resultobj = 0;
29387 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29388 wxColour *result = 0 ;
29389 void *argp1 = 0 ;
29390 int res1 = 0 ;
29391 PyObject *swig_obj[1] ;
29392
29393 if (!args) SWIG_fail;
29394 swig_obj[0] = args;
29395 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29396 if (!SWIG_IsOK(res1)) {
29397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29398 }
29399 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29400 result = (wxColour *)& ((arg1)->colBg);
29401 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29402 return resultobj;
29403 fail:
29404 return NULL;
29405 }
29406
29407
29408 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29409 PyObject *obj;
29410 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29411 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
29412 return SWIG_Py_Void();
29413 }
29414
29415 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29416 return SWIG_Python_InitShadowInstance(args);
29417 }
29418
29419 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29420 PyObject *resultobj = 0;
29421 wxWindow *arg1 = (wxWindow *) 0 ;
29422 int arg2 = (int) (int)-1 ;
29423 wxPoint const &arg3_defvalue = wxDefaultPosition ;
29424 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
29425 wxSize const &arg4_defvalue = wxDefaultSize ;
29426 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
29427 long arg5 = (long) 0 ;
29428 wxString const &arg6_defvalue = wxPyPanelNameStr ;
29429 wxString *arg6 = (wxString *) &arg6_defvalue ;
29430 wxWindow *result = 0 ;
29431 void *argp1 = 0 ;
29432 int res1 = 0 ;
29433 int val2 ;
29434 int ecode2 = 0 ;
29435 wxPoint temp3 ;
29436 wxSize temp4 ;
29437 long val5 ;
29438 int ecode5 = 0 ;
29439 bool temp6 = false ;
29440 PyObject * obj0 = 0 ;
29441 PyObject * obj1 = 0 ;
29442 PyObject * obj2 = 0 ;
29443 PyObject * obj3 = 0 ;
29444 PyObject * obj4 = 0 ;
29445 PyObject * obj5 = 0 ;
29446 char * kwnames[] = {
29447 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29448 };
29449
29450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
29451 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29452 if (!SWIG_IsOK(res1)) {
29453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
29454 }
29455 arg1 = reinterpret_cast< wxWindow * >(argp1);
29456 if (obj1) {
29457 ecode2 = SWIG_AsVal_int(obj1, &val2);
29458 if (!SWIG_IsOK(ecode2)) {
29459 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
29460 }
29461 arg2 = static_cast< int >(val2);
29462 }
29463 if (obj2) {
29464 {
29465 arg3 = &temp3;
29466 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29467 }
29468 }
29469 if (obj3) {
29470 {
29471 arg4 = &temp4;
29472 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
29473 }
29474 }
29475 if (obj4) {
29476 ecode5 = SWIG_AsVal_long(obj4, &val5);
29477 if (!SWIG_IsOK(ecode5)) {
29478 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
29479 }
29480 arg5 = static_cast< long >(val5);
29481 }
29482 if (obj5) {
29483 {
29484 arg6 = wxString_in_helper(obj5);
29485 if (arg6 == NULL) SWIG_fail;
29486 temp6 = true;
29487 }
29488 }
29489 {
29490 if (!wxPyCheckForApp()) SWIG_fail;
29491 PyThreadState* __tstate = wxPyBeginAllowThreads();
29492 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
29493 wxPyEndAllowThreads(__tstate);
29494 if (PyErr_Occurred()) SWIG_fail;
29495 }
29496 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
29497 {
29498 if (temp6)
29499 delete arg6;
29500 }
29501 return resultobj;
29502 fail:
29503 {
29504 if (temp6)
29505 delete arg6;
29506 }
29507 return NULL;
29508 }
29509
29510
29511 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29512 PyObject *resultobj = 0;
29513 wxWindow *result = 0 ;
29514
29515 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
29516 {
29517 if (!wxPyCheckForApp()) SWIG_fail;
29518 PyThreadState* __tstate = wxPyBeginAllowThreads();
29519 result = (wxWindow *)new wxWindow();
29520 wxPyEndAllowThreads(__tstate);
29521 if (PyErr_Occurred()) SWIG_fail;
29522 }
29523 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
29524 return resultobj;
29525 fail:
29526 return NULL;
29527 }
29528
29529
29530 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29531 PyObject *resultobj = 0;
29532 wxWindow *arg1 = (wxWindow *) 0 ;
29533 wxWindow *arg2 = (wxWindow *) 0 ;
29534 int arg3 = (int) (int)-1 ;
29535 wxPoint const &arg4_defvalue = wxDefaultPosition ;
29536 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
29537 wxSize const &arg5_defvalue = wxDefaultSize ;
29538 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
29539 long arg6 = (long) 0 ;
29540 wxString const &arg7_defvalue = wxPyPanelNameStr ;
29541 wxString *arg7 = (wxString *) &arg7_defvalue ;
29542 bool result;
29543 void *argp1 = 0 ;
29544 int res1 = 0 ;
29545 void *argp2 = 0 ;
29546 int res2 = 0 ;
29547 int val3 ;
29548 int ecode3 = 0 ;
29549 wxPoint temp4 ;
29550 wxSize temp5 ;
29551 long val6 ;
29552 int ecode6 = 0 ;
29553 bool temp7 = false ;
29554 PyObject * obj0 = 0 ;
29555 PyObject * obj1 = 0 ;
29556 PyObject * obj2 = 0 ;
29557 PyObject * obj3 = 0 ;
29558 PyObject * obj4 = 0 ;
29559 PyObject * obj5 = 0 ;
29560 PyObject * obj6 = 0 ;
29561 char * kwnames[] = {
29562 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29563 };
29564
29565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
29566 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29567 if (!SWIG_IsOK(res1)) {
29568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
29569 }
29570 arg1 = reinterpret_cast< wxWindow * >(argp1);
29571 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
29572 if (!SWIG_IsOK(res2)) {
29573 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
29574 }
29575 arg2 = reinterpret_cast< wxWindow * >(argp2);
29576 if (obj2) {
29577 ecode3 = SWIG_AsVal_int(obj2, &val3);
29578 if (!SWIG_IsOK(ecode3)) {
29579 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
29580 }
29581 arg3 = static_cast< int >(val3);
29582 }
29583 if (obj3) {
29584 {
29585 arg4 = &temp4;
29586 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
29587 }
29588 }
29589 if (obj4) {
29590 {
29591 arg5 = &temp5;
29592 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
29593 }
29594 }
29595 if (obj5) {
29596 ecode6 = SWIG_AsVal_long(obj5, &val6);
29597 if (!SWIG_IsOK(ecode6)) {
29598 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
29599 }
29600 arg6 = static_cast< long >(val6);
29601 }
29602 if (obj6) {
29603 {
29604 arg7 = wxString_in_helper(obj6);
29605 if (arg7 == NULL) SWIG_fail;
29606 temp7 = true;
29607 }
29608 }
29609 {
29610 PyThreadState* __tstate = wxPyBeginAllowThreads();
29611 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
29612 wxPyEndAllowThreads(__tstate);
29613 if (PyErr_Occurred()) SWIG_fail;
29614 }
29615 {
29616 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29617 }
29618 {
29619 if (temp7)
29620 delete arg7;
29621 }
29622 return resultobj;
29623 fail:
29624 {
29625 if (temp7)
29626 delete arg7;
29627 }
29628 return NULL;
29629 }
29630
29631
29632 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29633 PyObject *resultobj = 0;
29634 wxWindow *arg1 = (wxWindow *) 0 ;
29635 bool arg2 = (bool) false ;
29636 bool result;
29637 void *argp1 = 0 ;
29638 int res1 = 0 ;
29639 bool val2 ;
29640 int ecode2 = 0 ;
29641 PyObject * obj0 = 0 ;
29642 PyObject * obj1 = 0 ;
29643 char * kwnames[] = {
29644 (char *) "self",(char *) "force", NULL
29645 };
29646
29647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
29648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29649 if (!SWIG_IsOK(res1)) {
29650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
29651 }
29652 arg1 = reinterpret_cast< wxWindow * >(argp1);
29653 if (obj1) {
29654 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29655 if (!SWIG_IsOK(ecode2)) {
29656 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
29657 }
29658 arg2 = static_cast< bool >(val2);
29659 }
29660 {
29661 PyThreadState* __tstate = wxPyBeginAllowThreads();
29662 result = (bool)(arg1)->Close(arg2);
29663 wxPyEndAllowThreads(__tstate);
29664 if (PyErr_Occurred()) SWIG_fail;
29665 }
29666 {
29667 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29668 }
29669 return resultobj;
29670 fail:
29671 return NULL;
29672 }
29673
29674
29675 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29676 PyObject *resultobj = 0;
29677 wxWindow *arg1 = (wxWindow *) 0 ;
29678 bool result;
29679 void *argp1 = 0 ;
29680 int res1 = 0 ;
29681 PyObject *swig_obj[1] ;
29682
29683 if (!args) SWIG_fail;
29684 swig_obj[0] = args;
29685 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29686 if (!SWIG_IsOK(res1)) {
29687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
29688 }
29689 arg1 = reinterpret_cast< wxWindow * >(argp1);
29690 {
29691 PyThreadState* __tstate = wxPyBeginAllowThreads();
29692 result = (bool)(arg1)->Destroy();
29693 wxPyEndAllowThreads(__tstate);
29694 if (PyErr_Occurred()) SWIG_fail;
29695 }
29696 {
29697 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29698 }
29699 return resultobj;
29700 fail:
29701 return NULL;
29702 }
29703
29704
29705 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29706 PyObject *resultobj = 0;
29707 wxWindow *arg1 = (wxWindow *) 0 ;
29708 bool result;
29709 void *argp1 = 0 ;
29710 int res1 = 0 ;
29711 PyObject *swig_obj[1] ;
29712
29713 if (!args) SWIG_fail;
29714 swig_obj[0] = args;
29715 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29716 if (!SWIG_IsOK(res1)) {
29717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
29718 }
29719 arg1 = reinterpret_cast< wxWindow * >(argp1);
29720 {
29721 PyThreadState* __tstate = wxPyBeginAllowThreads();
29722 result = (bool)(arg1)->DestroyChildren();
29723 wxPyEndAllowThreads(__tstate);
29724 if (PyErr_Occurred()) SWIG_fail;
29725 }
29726 {
29727 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29728 }
29729 return resultobj;
29730 fail:
29731 return NULL;
29732 }
29733
29734
29735 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29736 PyObject *resultobj = 0;
29737 wxWindow *arg1 = (wxWindow *) 0 ;
29738 bool result;
29739 void *argp1 = 0 ;
29740 int res1 = 0 ;
29741 PyObject *swig_obj[1] ;
29742
29743 if (!args) SWIG_fail;
29744 swig_obj[0] = args;
29745 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29746 if (!SWIG_IsOK(res1)) {
29747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
29748 }
29749 arg1 = reinterpret_cast< wxWindow * >(argp1);
29750 {
29751 PyThreadState* __tstate = wxPyBeginAllowThreads();
29752 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
29753 wxPyEndAllowThreads(__tstate);
29754 if (PyErr_Occurred()) SWIG_fail;
29755 }
29756 {
29757 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29758 }
29759 return resultobj;
29760 fail:
29761 return NULL;
29762 }
29763
29764
29765 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29766 PyObject *resultobj = 0;
29767 wxWindow *arg1 = (wxWindow *) 0 ;
29768 wxString *arg2 = 0 ;
29769 void *argp1 = 0 ;
29770 int res1 = 0 ;
29771 bool temp2 = false ;
29772 PyObject * obj0 = 0 ;
29773 PyObject * obj1 = 0 ;
29774 char * kwnames[] = {
29775 (char *) "self",(char *) "label", NULL
29776 };
29777
29778 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
29779 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29780 if (!SWIG_IsOK(res1)) {
29781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
29782 }
29783 arg1 = reinterpret_cast< wxWindow * >(argp1);
29784 {
29785 arg2 = wxString_in_helper(obj1);
29786 if (arg2 == NULL) SWIG_fail;
29787 temp2 = true;
29788 }
29789 {
29790 PyThreadState* __tstate = wxPyBeginAllowThreads();
29791 (arg1)->SetLabel((wxString const &)*arg2);
29792 wxPyEndAllowThreads(__tstate);
29793 if (PyErr_Occurred()) SWIG_fail;
29794 }
29795 resultobj = SWIG_Py_Void();
29796 {
29797 if (temp2)
29798 delete arg2;
29799 }
29800 return resultobj;
29801 fail:
29802 {
29803 if (temp2)
29804 delete arg2;
29805 }
29806 return NULL;
29807 }
29808
29809
29810 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29811 PyObject *resultobj = 0;
29812 wxWindow *arg1 = (wxWindow *) 0 ;
29813 wxString result;
29814 void *argp1 = 0 ;
29815 int res1 = 0 ;
29816 PyObject *swig_obj[1] ;
29817
29818 if (!args) SWIG_fail;
29819 swig_obj[0] = args;
29820 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29821 if (!SWIG_IsOK(res1)) {
29822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
29823 }
29824 arg1 = reinterpret_cast< wxWindow * >(argp1);
29825 {
29826 PyThreadState* __tstate = wxPyBeginAllowThreads();
29827 result = ((wxWindow const *)arg1)->GetLabel();
29828 wxPyEndAllowThreads(__tstate);
29829 if (PyErr_Occurred()) SWIG_fail;
29830 }
29831 {
29832 #if wxUSE_UNICODE
29833 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29834 #else
29835 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29836 #endif
29837 }
29838 return resultobj;
29839 fail:
29840 return NULL;
29841 }
29842
29843
29844 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29845 PyObject *resultobj = 0;
29846 wxWindow *arg1 = (wxWindow *) 0 ;
29847 wxString *arg2 = 0 ;
29848 void *argp1 = 0 ;
29849 int res1 = 0 ;
29850 bool temp2 = false ;
29851 PyObject * obj0 = 0 ;
29852 PyObject * obj1 = 0 ;
29853 char * kwnames[] = {
29854 (char *) "self",(char *) "name", NULL
29855 };
29856
29857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
29858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29859 if (!SWIG_IsOK(res1)) {
29860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
29861 }
29862 arg1 = reinterpret_cast< wxWindow * >(argp1);
29863 {
29864 arg2 = wxString_in_helper(obj1);
29865 if (arg2 == NULL) SWIG_fail;
29866 temp2 = true;
29867 }
29868 {
29869 PyThreadState* __tstate = wxPyBeginAllowThreads();
29870 (arg1)->SetName((wxString const &)*arg2);
29871 wxPyEndAllowThreads(__tstate);
29872 if (PyErr_Occurred()) SWIG_fail;
29873 }
29874 resultobj = SWIG_Py_Void();
29875 {
29876 if (temp2)
29877 delete arg2;
29878 }
29879 return resultobj;
29880 fail:
29881 {
29882 if (temp2)
29883 delete arg2;
29884 }
29885 return NULL;
29886 }
29887
29888
29889 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29890 PyObject *resultobj = 0;
29891 wxWindow *arg1 = (wxWindow *) 0 ;
29892 wxString result;
29893 void *argp1 = 0 ;
29894 int res1 = 0 ;
29895 PyObject *swig_obj[1] ;
29896
29897 if (!args) SWIG_fail;
29898 swig_obj[0] = args;
29899 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29900 if (!SWIG_IsOK(res1)) {
29901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
29902 }
29903 arg1 = reinterpret_cast< wxWindow * >(argp1);
29904 {
29905 PyThreadState* __tstate = wxPyBeginAllowThreads();
29906 result = ((wxWindow const *)arg1)->GetName();
29907 wxPyEndAllowThreads(__tstate);
29908 if (PyErr_Occurred()) SWIG_fail;
29909 }
29910 {
29911 #if wxUSE_UNICODE
29912 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29913 #else
29914 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29915 #endif
29916 }
29917 return resultobj;
29918 fail:
29919 return NULL;
29920 }
29921
29922
29923 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29924 PyObject *resultobj = 0;
29925 wxWindow *arg1 = (wxWindow *) 0 ;
29926 wxWindowVariant arg2 ;
29927 void *argp1 = 0 ;
29928 int res1 = 0 ;
29929 int val2 ;
29930 int ecode2 = 0 ;
29931 PyObject * obj0 = 0 ;
29932 PyObject * obj1 = 0 ;
29933 char * kwnames[] = {
29934 (char *) "self",(char *) "variant", NULL
29935 };
29936
29937 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
29938 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29939 if (!SWIG_IsOK(res1)) {
29940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
29941 }
29942 arg1 = reinterpret_cast< wxWindow * >(argp1);
29943 ecode2 = SWIG_AsVal_int(obj1, &val2);
29944 if (!SWIG_IsOK(ecode2)) {
29945 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
29946 }
29947 arg2 = static_cast< wxWindowVariant >(val2);
29948 {
29949 PyThreadState* __tstate = wxPyBeginAllowThreads();
29950 (arg1)->SetWindowVariant(arg2);
29951 wxPyEndAllowThreads(__tstate);
29952 if (PyErr_Occurred()) SWIG_fail;
29953 }
29954 resultobj = SWIG_Py_Void();
29955 return resultobj;
29956 fail:
29957 return NULL;
29958 }
29959
29960
29961 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29962 PyObject *resultobj = 0;
29963 wxWindow *arg1 = (wxWindow *) 0 ;
29964 wxWindowVariant result;
29965 void *argp1 = 0 ;
29966 int res1 = 0 ;
29967 PyObject *swig_obj[1] ;
29968
29969 if (!args) SWIG_fail;
29970 swig_obj[0] = args;
29971 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29972 if (!SWIG_IsOK(res1)) {
29973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
29974 }
29975 arg1 = reinterpret_cast< wxWindow * >(argp1);
29976 {
29977 PyThreadState* __tstate = wxPyBeginAllowThreads();
29978 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
29979 wxPyEndAllowThreads(__tstate);
29980 if (PyErr_Occurred()) SWIG_fail;
29981 }
29982 resultobj = SWIG_From_int(static_cast< int >(result));
29983 return resultobj;
29984 fail:
29985 return NULL;
29986 }
29987
29988
29989 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29990 PyObject *resultobj = 0;
29991 wxWindow *arg1 = (wxWindow *) 0 ;
29992 int arg2 ;
29993 void *argp1 = 0 ;
29994 int res1 = 0 ;
29995 int val2 ;
29996 int ecode2 = 0 ;
29997 PyObject * obj0 = 0 ;
29998 PyObject * obj1 = 0 ;
29999 char * kwnames[] = {
30000 (char *) "self",(char *) "winid", NULL
30001 };
30002
30003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
30004 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30005 if (!SWIG_IsOK(res1)) {
30006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
30007 }
30008 arg1 = reinterpret_cast< wxWindow * >(argp1);
30009 ecode2 = SWIG_AsVal_int(obj1, &val2);
30010 if (!SWIG_IsOK(ecode2)) {
30011 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
30012 }
30013 arg2 = static_cast< int >(val2);
30014 {
30015 PyThreadState* __tstate = wxPyBeginAllowThreads();
30016 (arg1)->SetId(arg2);
30017 wxPyEndAllowThreads(__tstate);
30018 if (PyErr_Occurred()) SWIG_fail;
30019 }
30020 resultobj = SWIG_Py_Void();
30021 return resultobj;
30022 fail:
30023 return NULL;
30024 }
30025
30026
30027 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30028 PyObject *resultobj = 0;
30029 wxWindow *arg1 = (wxWindow *) 0 ;
30030 int result;
30031 void *argp1 = 0 ;
30032 int res1 = 0 ;
30033 PyObject *swig_obj[1] ;
30034
30035 if (!args) SWIG_fail;
30036 swig_obj[0] = args;
30037 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30038 if (!SWIG_IsOK(res1)) {
30039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
30040 }
30041 arg1 = reinterpret_cast< wxWindow * >(argp1);
30042 {
30043 PyThreadState* __tstate = wxPyBeginAllowThreads();
30044 result = (int)((wxWindow const *)arg1)->GetId();
30045 wxPyEndAllowThreads(__tstate);
30046 if (PyErr_Occurred()) SWIG_fail;
30047 }
30048 resultobj = SWIG_From_int(static_cast< int >(result));
30049 return resultobj;
30050 fail:
30051 return NULL;
30052 }
30053
30054
30055 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30056 PyObject *resultobj = 0;
30057 int result;
30058
30059 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
30060 {
30061 PyThreadState* __tstate = wxPyBeginAllowThreads();
30062 result = (int)wxWindow::NewControlId();
30063 wxPyEndAllowThreads(__tstate);
30064 if (PyErr_Occurred()) SWIG_fail;
30065 }
30066 resultobj = SWIG_From_int(static_cast< int >(result));
30067 return resultobj;
30068 fail:
30069 return NULL;
30070 }
30071
30072
30073 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30074 PyObject *resultobj = 0;
30075 int arg1 ;
30076 int result;
30077 int val1 ;
30078 int ecode1 = 0 ;
30079 PyObject * obj0 = 0 ;
30080 char * kwnames[] = {
30081 (char *) "winid", NULL
30082 };
30083
30084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
30085 ecode1 = SWIG_AsVal_int(obj0, &val1);
30086 if (!SWIG_IsOK(ecode1)) {
30087 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
30088 }
30089 arg1 = static_cast< int >(val1);
30090 {
30091 PyThreadState* __tstate = wxPyBeginAllowThreads();
30092 result = (int)wxWindow::NextControlId(arg1);
30093 wxPyEndAllowThreads(__tstate);
30094 if (PyErr_Occurred()) SWIG_fail;
30095 }
30096 resultobj = SWIG_From_int(static_cast< int >(result));
30097 return resultobj;
30098 fail:
30099 return NULL;
30100 }
30101
30102
30103 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30104 PyObject *resultobj = 0;
30105 int arg1 ;
30106 int result;
30107 int val1 ;
30108 int ecode1 = 0 ;
30109 PyObject * obj0 = 0 ;
30110 char * kwnames[] = {
30111 (char *) "winid", NULL
30112 };
30113
30114 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
30115 ecode1 = SWIG_AsVal_int(obj0, &val1);
30116 if (!SWIG_IsOK(ecode1)) {
30117 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
30118 }
30119 arg1 = static_cast< int >(val1);
30120 {
30121 PyThreadState* __tstate = wxPyBeginAllowThreads();
30122 result = (int)wxWindow::PrevControlId(arg1);
30123 wxPyEndAllowThreads(__tstate);
30124 if (PyErr_Occurred()) SWIG_fail;
30125 }
30126 resultobj = SWIG_From_int(static_cast< int >(result));
30127 return resultobj;
30128 fail:
30129 return NULL;
30130 }
30131
30132
30133 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30134 PyObject *resultobj = 0;
30135 wxWindow *arg1 = (wxWindow *) 0 ;
30136 wxSize *arg2 = 0 ;
30137 void *argp1 = 0 ;
30138 int res1 = 0 ;
30139 wxSize temp2 ;
30140 PyObject * obj0 = 0 ;
30141 PyObject * obj1 = 0 ;
30142 char * kwnames[] = {
30143 (char *) "self",(char *) "size", NULL
30144 };
30145
30146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
30147 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30148 if (!SWIG_IsOK(res1)) {
30149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30150 }
30151 arg1 = reinterpret_cast< wxWindow * >(argp1);
30152 {
30153 arg2 = &temp2;
30154 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30155 }
30156 {
30157 PyThreadState* __tstate = wxPyBeginAllowThreads();
30158 (arg1)->SetSize((wxSize const &)*arg2);
30159 wxPyEndAllowThreads(__tstate);
30160 if (PyErr_Occurred()) SWIG_fail;
30161 }
30162 resultobj = SWIG_Py_Void();
30163 return resultobj;
30164 fail:
30165 return NULL;
30166 }
30167
30168
30169 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30170 PyObject *resultobj = 0;
30171 wxWindow *arg1 = (wxWindow *) 0 ;
30172 int arg2 ;
30173 int arg3 ;
30174 int arg4 ;
30175 int arg5 ;
30176 int arg6 = (int) wxSIZE_AUTO ;
30177 void *argp1 = 0 ;
30178 int res1 = 0 ;
30179 int val2 ;
30180 int ecode2 = 0 ;
30181 int val3 ;
30182 int ecode3 = 0 ;
30183 int val4 ;
30184 int ecode4 = 0 ;
30185 int val5 ;
30186 int ecode5 = 0 ;
30187 int val6 ;
30188 int ecode6 = 0 ;
30189 PyObject * obj0 = 0 ;
30190 PyObject * obj1 = 0 ;
30191 PyObject * obj2 = 0 ;
30192 PyObject * obj3 = 0 ;
30193 PyObject * obj4 = 0 ;
30194 PyObject * obj5 = 0 ;
30195 char * kwnames[] = {
30196 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
30197 };
30198
30199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
30200 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30201 if (!SWIG_IsOK(res1)) {
30202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
30203 }
30204 arg1 = reinterpret_cast< wxWindow * >(argp1);
30205 ecode2 = SWIG_AsVal_int(obj1, &val2);
30206 if (!SWIG_IsOK(ecode2)) {
30207 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
30208 }
30209 arg2 = static_cast< int >(val2);
30210 ecode3 = SWIG_AsVal_int(obj2, &val3);
30211 if (!SWIG_IsOK(ecode3)) {
30212 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
30213 }
30214 arg3 = static_cast< int >(val3);
30215 ecode4 = SWIG_AsVal_int(obj3, &val4);
30216 if (!SWIG_IsOK(ecode4)) {
30217 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
30218 }
30219 arg4 = static_cast< int >(val4);
30220 ecode5 = SWIG_AsVal_int(obj4, &val5);
30221 if (!SWIG_IsOK(ecode5)) {
30222 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
30223 }
30224 arg5 = static_cast< int >(val5);
30225 if (obj5) {
30226 ecode6 = SWIG_AsVal_int(obj5, &val6);
30227 if (!SWIG_IsOK(ecode6)) {
30228 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
30229 }
30230 arg6 = static_cast< int >(val6);
30231 }
30232 {
30233 PyThreadState* __tstate = wxPyBeginAllowThreads();
30234 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
30235 wxPyEndAllowThreads(__tstate);
30236 if (PyErr_Occurred()) SWIG_fail;
30237 }
30238 resultobj = SWIG_Py_Void();
30239 return resultobj;
30240 fail:
30241 return NULL;
30242 }
30243
30244
30245 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30246 PyObject *resultobj = 0;
30247 wxWindow *arg1 = (wxWindow *) 0 ;
30248 wxRect *arg2 = 0 ;
30249 int arg3 = (int) wxSIZE_AUTO ;
30250 void *argp1 = 0 ;
30251 int res1 = 0 ;
30252 wxRect temp2 ;
30253 int val3 ;
30254 int ecode3 = 0 ;
30255 PyObject * obj0 = 0 ;
30256 PyObject * obj1 = 0 ;
30257 PyObject * obj2 = 0 ;
30258 char * kwnames[] = {
30259 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
30260 };
30261
30262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30263 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30264 if (!SWIG_IsOK(res1)) {
30265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30266 }
30267 arg1 = reinterpret_cast< wxWindow * >(argp1);
30268 {
30269 arg2 = &temp2;
30270 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30271 }
30272 if (obj2) {
30273 ecode3 = SWIG_AsVal_int(obj2, &val3);
30274 if (!SWIG_IsOK(ecode3)) {
30275 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
30276 }
30277 arg3 = static_cast< int >(val3);
30278 }
30279 {
30280 PyThreadState* __tstate = wxPyBeginAllowThreads();
30281 (arg1)->SetSize((wxRect const &)*arg2,arg3);
30282 wxPyEndAllowThreads(__tstate);
30283 if (PyErr_Occurred()) SWIG_fail;
30284 }
30285 resultobj = SWIG_Py_Void();
30286 return resultobj;
30287 fail:
30288 return NULL;
30289 }
30290
30291
30292 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30293 PyObject *resultobj = 0;
30294 wxWindow *arg1 = (wxWindow *) 0 ;
30295 int arg2 ;
30296 int arg3 ;
30297 void *argp1 = 0 ;
30298 int res1 = 0 ;
30299 int val2 ;
30300 int ecode2 = 0 ;
30301 int val3 ;
30302 int ecode3 = 0 ;
30303 PyObject * obj0 = 0 ;
30304 PyObject * obj1 = 0 ;
30305 PyObject * obj2 = 0 ;
30306 char * kwnames[] = {
30307 (char *) "self",(char *) "width",(char *) "height", NULL
30308 };
30309
30310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30311 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30312 if (!SWIG_IsOK(res1)) {
30313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30314 }
30315 arg1 = reinterpret_cast< wxWindow * >(argp1);
30316 ecode2 = SWIG_AsVal_int(obj1, &val2);
30317 if (!SWIG_IsOK(ecode2)) {
30318 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
30319 }
30320 arg2 = static_cast< int >(val2);
30321 ecode3 = SWIG_AsVal_int(obj2, &val3);
30322 if (!SWIG_IsOK(ecode3)) {
30323 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
30324 }
30325 arg3 = static_cast< int >(val3);
30326 {
30327 PyThreadState* __tstate = wxPyBeginAllowThreads();
30328 (arg1)->SetSize(arg2,arg3);
30329 wxPyEndAllowThreads(__tstate);
30330 if (PyErr_Occurred()) SWIG_fail;
30331 }
30332 resultobj = SWIG_Py_Void();
30333 return resultobj;
30334 fail:
30335 return NULL;
30336 }
30337
30338
30339 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30340 PyObject *resultobj = 0;
30341 wxWindow *arg1 = (wxWindow *) 0 ;
30342 wxPoint *arg2 = 0 ;
30343 int arg3 = (int) wxSIZE_USE_EXISTING ;
30344 void *argp1 = 0 ;
30345 int res1 = 0 ;
30346 wxPoint temp2 ;
30347 int val3 ;
30348 int ecode3 = 0 ;
30349 PyObject * obj0 = 0 ;
30350 PyObject * obj1 = 0 ;
30351 PyObject * obj2 = 0 ;
30352 char * kwnames[] = {
30353 (char *) "self",(char *) "pt",(char *) "flags", NULL
30354 };
30355
30356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30357 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30358 if (!SWIG_IsOK(res1)) {
30359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
30360 }
30361 arg1 = reinterpret_cast< wxWindow * >(argp1);
30362 {
30363 arg2 = &temp2;
30364 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30365 }
30366 if (obj2) {
30367 ecode3 = SWIG_AsVal_int(obj2, &val3);
30368 if (!SWIG_IsOK(ecode3)) {
30369 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
30370 }
30371 arg3 = static_cast< int >(val3);
30372 }
30373 {
30374 PyThreadState* __tstate = wxPyBeginAllowThreads();
30375 (arg1)->Move((wxPoint const &)*arg2,arg3);
30376 wxPyEndAllowThreads(__tstate);
30377 if (PyErr_Occurred()) SWIG_fail;
30378 }
30379 resultobj = SWIG_Py_Void();
30380 return resultobj;
30381 fail:
30382 return NULL;
30383 }
30384
30385
30386 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30387 PyObject *resultobj = 0;
30388 wxWindow *arg1 = (wxWindow *) 0 ;
30389 int arg2 ;
30390 int arg3 ;
30391 int arg4 = (int) wxSIZE_USE_EXISTING ;
30392 void *argp1 = 0 ;
30393 int res1 = 0 ;
30394 int val2 ;
30395 int ecode2 = 0 ;
30396 int val3 ;
30397 int ecode3 = 0 ;
30398 int val4 ;
30399 int ecode4 = 0 ;
30400 PyObject * obj0 = 0 ;
30401 PyObject * obj1 = 0 ;
30402 PyObject * obj2 = 0 ;
30403 PyObject * obj3 = 0 ;
30404 char * kwnames[] = {
30405 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
30406 };
30407
30408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30409 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30410 if (!SWIG_IsOK(res1)) {
30411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
30412 }
30413 arg1 = reinterpret_cast< wxWindow * >(argp1);
30414 ecode2 = SWIG_AsVal_int(obj1, &val2);
30415 if (!SWIG_IsOK(ecode2)) {
30416 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
30417 }
30418 arg2 = static_cast< int >(val2);
30419 ecode3 = SWIG_AsVal_int(obj2, &val3);
30420 if (!SWIG_IsOK(ecode3)) {
30421 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
30422 }
30423 arg3 = static_cast< int >(val3);
30424 if (obj3) {
30425 ecode4 = SWIG_AsVal_int(obj3, &val4);
30426 if (!SWIG_IsOK(ecode4)) {
30427 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
30428 }
30429 arg4 = static_cast< int >(val4);
30430 }
30431 {
30432 PyThreadState* __tstate = wxPyBeginAllowThreads();
30433 (arg1)->Move(arg2,arg3,arg4);
30434 wxPyEndAllowThreads(__tstate);
30435 if (PyErr_Occurred()) SWIG_fail;
30436 }
30437 resultobj = SWIG_Py_Void();
30438 return resultobj;
30439 fail:
30440 return NULL;
30441 }
30442
30443
30444 SWIGINTERN PyObject *_wrap_Window_SetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30445 PyObject *resultobj = 0;
30446 wxWindow *arg1 = (wxWindow *) 0 ;
30447 wxSize const &arg2_defvalue = wxDefaultSize ;
30448 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
30449 void *argp1 = 0 ;
30450 int res1 = 0 ;
30451 wxSize temp2 ;
30452 PyObject * obj0 = 0 ;
30453 PyObject * obj1 = 0 ;
30454 char * kwnames[] = {
30455 (char *) "self",(char *) "size", NULL
30456 };
30457
30458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) SWIG_fail;
30459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30460 if (!SWIG_IsOK(res1)) {
30461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30462 }
30463 arg1 = reinterpret_cast< wxWindow * >(argp1);
30464 if (obj1) {
30465 {
30466 arg2 = &temp2;
30467 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30468 }
30469 }
30470 {
30471 PyThreadState* __tstate = wxPyBeginAllowThreads();
30472 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
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_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30484 PyObject *resultobj = 0;
30485 wxWindow *arg1 = (wxWindow *) 0 ;
30486 void *argp1 = 0 ;
30487 int res1 = 0 ;
30488 PyObject *swig_obj[1] ;
30489
30490 if (!args) SWIG_fail;
30491 swig_obj[0] = args;
30492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30493 if (!SWIG_IsOK(res1)) {
30494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
30495 }
30496 arg1 = reinterpret_cast< wxWindow * >(argp1);
30497 {
30498 PyThreadState* __tstate = wxPyBeginAllowThreads();
30499 (arg1)->Raise();
30500 wxPyEndAllowThreads(__tstate);
30501 if (PyErr_Occurred()) SWIG_fail;
30502 }
30503 resultobj = SWIG_Py_Void();
30504 return resultobj;
30505 fail:
30506 return NULL;
30507 }
30508
30509
30510 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30511 PyObject *resultobj = 0;
30512 wxWindow *arg1 = (wxWindow *) 0 ;
30513 void *argp1 = 0 ;
30514 int res1 = 0 ;
30515 PyObject *swig_obj[1] ;
30516
30517 if (!args) SWIG_fail;
30518 swig_obj[0] = args;
30519 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30520 if (!SWIG_IsOK(res1)) {
30521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
30522 }
30523 arg1 = reinterpret_cast< wxWindow * >(argp1);
30524 {
30525 PyThreadState* __tstate = wxPyBeginAllowThreads();
30526 (arg1)->Lower();
30527 wxPyEndAllowThreads(__tstate);
30528 if (PyErr_Occurred()) SWIG_fail;
30529 }
30530 resultobj = SWIG_Py_Void();
30531 return resultobj;
30532 fail:
30533 return NULL;
30534 }
30535
30536
30537 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30538 PyObject *resultobj = 0;
30539 wxWindow *arg1 = (wxWindow *) 0 ;
30540 wxSize *arg2 = 0 ;
30541 void *argp1 = 0 ;
30542 int res1 = 0 ;
30543 wxSize temp2 ;
30544 PyObject * obj0 = 0 ;
30545 PyObject * obj1 = 0 ;
30546 char * kwnames[] = {
30547 (char *) "self",(char *) "size", NULL
30548 };
30549
30550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
30551 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30552 if (!SWIG_IsOK(res1)) {
30553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30554 }
30555 arg1 = reinterpret_cast< wxWindow * >(argp1);
30556 {
30557 arg2 = &temp2;
30558 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30559 }
30560 {
30561 PyThreadState* __tstate = wxPyBeginAllowThreads();
30562 (arg1)->SetClientSize((wxSize const &)*arg2);
30563 wxPyEndAllowThreads(__tstate);
30564 if (PyErr_Occurred()) SWIG_fail;
30565 }
30566 resultobj = SWIG_Py_Void();
30567 return resultobj;
30568 fail:
30569 return NULL;
30570 }
30571
30572
30573 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30574 PyObject *resultobj = 0;
30575 wxWindow *arg1 = (wxWindow *) 0 ;
30576 int arg2 ;
30577 int arg3 ;
30578 void *argp1 = 0 ;
30579 int res1 = 0 ;
30580 int val2 ;
30581 int ecode2 = 0 ;
30582 int val3 ;
30583 int ecode3 = 0 ;
30584 PyObject * obj0 = 0 ;
30585 PyObject * obj1 = 0 ;
30586 PyObject * obj2 = 0 ;
30587 char * kwnames[] = {
30588 (char *) "self",(char *) "width",(char *) "height", NULL
30589 };
30590
30591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30593 if (!SWIG_IsOK(res1)) {
30594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30595 }
30596 arg1 = reinterpret_cast< wxWindow * >(argp1);
30597 ecode2 = SWIG_AsVal_int(obj1, &val2);
30598 if (!SWIG_IsOK(ecode2)) {
30599 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
30600 }
30601 arg2 = static_cast< int >(val2);
30602 ecode3 = SWIG_AsVal_int(obj2, &val3);
30603 if (!SWIG_IsOK(ecode3)) {
30604 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
30605 }
30606 arg3 = static_cast< int >(val3);
30607 {
30608 PyThreadState* __tstate = wxPyBeginAllowThreads();
30609 (arg1)->SetClientSize(arg2,arg3);
30610 wxPyEndAllowThreads(__tstate);
30611 if (PyErr_Occurred()) SWIG_fail;
30612 }
30613 resultobj = SWIG_Py_Void();
30614 return resultobj;
30615 fail:
30616 return NULL;
30617 }
30618
30619
30620 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30621 PyObject *resultobj = 0;
30622 wxWindow *arg1 = (wxWindow *) 0 ;
30623 wxRect *arg2 = 0 ;
30624 void *argp1 = 0 ;
30625 int res1 = 0 ;
30626 wxRect temp2 ;
30627 PyObject * obj0 = 0 ;
30628 PyObject * obj1 = 0 ;
30629 char * kwnames[] = {
30630 (char *) "self",(char *) "rect", NULL
30631 };
30632
30633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
30634 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30635 if (!SWIG_IsOK(res1)) {
30636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30637 }
30638 arg1 = reinterpret_cast< wxWindow * >(argp1);
30639 {
30640 arg2 = &temp2;
30641 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30642 }
30643 {
30644 PyThreadState* __tstate = wxPyBeginAllowThreads();
30645 (arg1)->SetClientSize((wxRect const &)*arg2);
30646 wxPyEndAllowThreads(__tstate);
30647 if (PyErr_Occurred()) SWIG_fail;
30648 }
30649 resultobj = SWIG_Py_Void();
30650 return resultobj;
30651 fail:
30652 return NULL;
30653 }
30654
30655
30656 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30657 PyObject *resultobj = 0;
30658 wxWindow *arg1 = (wxWindow *) 0 ;
30659 wxPoint result;
30660 void *argp1 = 0 ;
30661 int res1 = 0 ;
30662 PyObject *swig_obj[1] ;
30663
30664 if (!args) SWIG_fail;
30665 swig_obj[0] = args;
30666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30667 if (!SWIG_IsOK(res1)) {
30668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
30669 }
30670 arg1 = reinterpret_cast< wxWindow * >(argp1);
30671 {
30672 PyThreadState* __tstate = wxPyBeginAllowThreads();
30673 result = ((wxWindow const *)arg1)->GetPosition();
30674 wxPyEndAllowThreads(__tstate);
30675 if (PyErr_Occurred()) SWIG_fail;
30676 }
30677 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30678 return resultobj;
30679 fail:
30680 return NULL;
30681 }
30682
30683
30684 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30685 PyObject *resultobj = 0;
30686 wxWindow *arg1 = (wxWindow *) 0 ;
30687 int *arg2 = (int *) 0 ;
30688 int *arg3 = (int *) 0 ;
30689 void *argp1 = 0 ;
30690 int res1 = 0 ;
30691 int temp2 ;
30692 int res2 = SWIG_TMPOBJ ;
30693 int temp3 ;
30694 int res3 = SWIG_TMPOBJ ;
30695 PyObject *swig_obj[1] ;
30696
30697 arg2 = &temp2;
30698 arg3 = &temp3;
30699 if (!args) SWIG_fail;
30700 swig_obj[0] = args;
30701 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30702 if (!SWIG_IsOK(res1)) {
30703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30704 }
30705 arg1 = reinterpret_cast< wxWindow * >(argp1);
30706 {
30707 PyThreadState* __tstate = wxPyBeginAllowThreads();
30708 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
30709 wxPyEndAllowThreads(__tstate);
30710 if (PyErr_Occurred()) SWIG_fail;
30711 }
30712 resultobj = SWIG_Py_Void();
30713 if (SWIG_IsTmpObj(res2)) {
30714 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30715 } else {
30716 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30717 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30718 }
30719 if (SWIG_IsTmpObj(res3)) {
30720 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30721 } else {
30722 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30723 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30724 }
30725 return resultobj;
30726 fail:
30727 return NULL;
30728 }
30729
30730
30731 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30732 PyObject *resultobj = 0;
30733 wxWindow *arg1 = (wxWindow *) 0 ;
30734 wxPoint result;
30735 void *argp1 = 0 ;
30736 int res1 = 0 ;
30737 PyObject *swig_obj[1] ;
30738
30739 if (!args) SWIG_fail;
30740 swig_obj[0] = args;
30741 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30742 if (!SWIG_IsOK(res1)) {
30743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
30744 }
30745 arg1 = reinterpret_cast< wxWindow * >(argp1);
30746 {
30747 PyThreadState* __tstate = wxPyBeginAllowThreads();
30748 result = ((wxWindow const *)arg1)->GetScreenPosition();
30749 wxPyEndAllowThreads(__tstate);
30750 if (PyErr_Occurred()) SWIG_fail;
30751 }
30752 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30753 return resultobj;
30754 fail:
30755 return NULL;
30756 }
30757
30758
30759 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30760 PyObject *resultobj = 0;
30761 wxWindow *arg1 = (wxWindow *) 0 ;
30762 int *arg2 = (int *) 0 ;
30763 int *arg3 = (int *) 0 ;
30764 void *argp1 = 0 ;
30765 int res1 = 0 ;
30766 int temp2 ;
30767 int res2 = SWIG_TMPOBJ ;
30768 int temp3 ;
30769 int res3 = SWIG_TMPOBJ ;
30770 PyObject *swig_obj[1] ;
30771
30772 arg2 = &temp2;
30773 arg3 = &temp3;
30774 if (!args) SWIG_fail;
30775 swig_obj[0] = args;
30776 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30777 if (!SWIG_IsOK(res1)) {
30778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30779 }
30780 arg1 = reinterpret_cast< wxWindow * >(argp1);
30781 {
30782 PyThreadState* __tstate = wxPyBeginAllowThreads();
30783 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
30784 wxPyEndAllowThreads(__tstate);
30785 if (PyErr_Occurred()) SWIG_fail;
30786 }
30787 resultobj = SWIG_Py_Void();
30788 if (SWIG_IsTmpObj(res2)) {
30789 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30790 } else {
30791 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30792 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30793 }
30794 if (SWIG_IsTmpObj(res3)) {
30795 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30796 } else {
30797 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30798 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30799 }
30800 return resultobj;
30801 fail:
30802 return NULL;
30803 }
30804
30805
30806 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30807 PyObject *resultobj = 0;
30808 wxWindow *arg1 = (wxWindow *) 0 ;
30809 wxRect result;
30810 void *argp1 = 0 ;
30811 int res1 = 0 ;
30812 PyObject *swig_obj[1] ;
30813
30814 if (!args) SWIG_fail;
30815 swig_obj[0] = args;
30816 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30817 if (!SWIG_IsOK(res1)) {
30818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
30819 }
30820 arg1 = reinterpret_cast< wxWindow * >(argp1);
30821 {
30822 PyThreadState* __tstate = wxPyBeginAllowThreads();
30823 result = ((wxWindow const *)arg1)->GetScreenRect();
30824 wxPyEndAllowThreads(__tstate);
30825 if (PyErr_Occurred()) SWIG_fail;
30826 }
30827 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
30828 return resultobj;
30829 fail:
30830 return NULL;
30831 }
30832
30833
30834 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30835 PyObject *resultobj = 0;
30836 wxWindow *arg1 = (wxWindow *) 0 ;
30837 wxSize result;
30838 void *argp1 = 0 ;
30839 int res1 = 0 ;
30840 PyObject *swig_obj[1] ;
30841
30842 if (!args) SWIG_fail;
30843 swig_obj[0] = args;
30844 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30845 if (!SWIG_IsOK(res1)) {
30846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
30847 }
30848 arg1 = reinterpret_cast< wxWindow * >(argp1);
30849 {
30850 PyThreadState* __tstate = wxPyBeginAllowThreads();
30851 result = ((wxWindow const *)arg1)->GetSize();
30852 wxPyEndAllowThreads(__tstate);
30853 if (PyErr_Occurred()) SWIG_fail;
30854 }
30855 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
30856 return resultobj;
30857 fail:
30858 return NULL;
30859 }
30860
30861
30862 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30863 PyObject *resultobj = 0;
30864 wxWindow *arg1 = (wxWindow *) 0 ;
30865 int *arg2 = (int *) 0 ;
30866 int *arg3 = (int *) 0 ;
30867 void *argp1 = 0 ;
30868 int res1 = 0 ;
30869 int temp2 ;
30870 int res2 = SWIG_TMPOBJ ;
30871 int temp3 ;
30872 int res3 = SWIG_TMPOBJ ;
30873 PyObject *swig_obj[1] ;
30874
30875 arg2 = &temp2;
30876 arg3 = &temp3;
30877 if (!args) SWIG_fail;
30878 swig_obj[0] = args;
30879 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30880 if (!SWIG_IsOK(res1)) {
30881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30882 }
30883 arg1 = reinterpret_cast< wxWindow * >(argp1);
30884 {
30885 PyThreadState* __tstate = wxPyBeginAllowThreads();
30886 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
30887 wxPyEndAllowThreads(__tstate);
30888 if (PyErr_Occurred()) SWIG_fail;
30889 }
30890 resultobj = SWIG_Py_Void();
30891 if (SWIG_IsTmpObj(res2)) {
30892 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30893 } else {
30894 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30895 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30896 }
30897 if (SWIG_IsTmpObj(res3)) {
30898 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30899 } else {
30900 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30901 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30902 }
30903 return resultobj;
30904 fail:
30905 return NULL;
30906 }
30907
30908
30909 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30910 PyObject *resultobj = 0;
30911 wxWindow *arg1 = (wxWindow *) 0 ;
30912 wxRect result;
30913 void *argp1 = 0 ;
30914 int res1 = 0 ;
30915 PyObject *swig_obj[1] ;
30916
30917 if (!args) SWIG_fail;
30918 swig_obj[0] = args;
30919 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30920 if (!SWIG_IsOK(res1)) {
30921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
30922 }
30923 arg1 = reinterpret_cast< wxWindow * >(argp1);
30924 {
30925 PyThreadState* __tstate = wxPyBeginAllowThreads();
30926 result = ((wxWindow const *)arg1)->GetRect();
30927 wxPyEndAllowThreads(__tstate);
30928 if (PyErr_Occurred()) SWIG_fail;
30929 }
30930 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
30931 return resultobj;
30932 fail:
30933 return NULL;
30934 }
30935
30936
30937 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30938 PyObject *resultobj = 0;
30939 wxWindow *arg1 = (wxWindow *) 0 ;
30940 wxSize result;
30941 void *argp1 = 0 ;
30942 int res1 = 0 ;
30943 PyObject *swig_obj[1] ;
30944
30945 if (!args) SWIG_fail;
30946 swig_obj[0] = args;
30947 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30948 if (!SWIG_IsOK(res1)) {
30949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
30950 }
30951 arg1 = reinterpret_cast< wxWindow * >(argp1);
30952 {
30953 PyThreadState* __tstate = wxPyBeginAllowThreads();
30954 result = ((wxWindow const *)arg1)->GetClientSize();
30955 wxPyEndAllowThreads(__tstate);
30956 if (PyErr_Occurred()) SWIG_fail;
30957 }
30958 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
30959 return resultobj;
30960 fail:
30961 return NULL;
30962 }
30963
30964
30965 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30966 PyObject *resultobj = 0;
30967 wxWindow *arg1 = (wxWindow *) 0 ;
30968 int *arg2 = (int *) 0 ;
30969 int *arg3 = (int *) 0 ;
30970 void *argp1 = 0 ;
30971 int res1 = 0 ;
30972 int temp2 ;
30973 int res2 = SWIG_TMPOBJ ;
30974 int temp3 ;
30975 int res3 = SWIG_TMPOBJ ;
30976 PyObject *swig_obj[1] ;
30977
30978 arg2 = &temp2;
30979 arg3 = &temp3;
30980 if (!args) SWIG_fail;
30981 swig_obj[0] = args;
30982 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30983 if (!SWIG_IsOK(res1)) {
30984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30985 }
30986 arg1 = reinterpret_cast< wxWindow * >(argp1);
30987 {
30988 PyThreadState* __tstate = wxPyBeginAllowThreads();
30989 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
30990 wxPyEndAllowThreads(__tstate);
30991 if (PyErr_Occurred()) SWIG_fail;
30992 }
30993 resultobj = SWIG_Py_Void();
30994 if (SWIG_IsTmpObj(res2)) {
30995 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30996 } else {
30997 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30998 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30999 }
31000 if (SWIG_IsTmpObj(res3)) {
31001 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31002 } else {
31003 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31004 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31005 }
31006 return resultobj;
31007 fail:
31008 return NULL;
31009 }
31010
31011
31012 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31013 PyObject *resultobj = 0;
31014 wxWindow *arg1 = (wxWindow *) 0 ;
31015 wxPoint result;
31016 void *argp1 = 0 ;
31017 int res1 = 0 ;
31018 PyObject *swig_obj[1] ;
31019
31020 if (!args) SWIG_fail;
31021 swig_obj[0] = args;
31022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31023 if (!SWIG_IsOK(res1)) {
31024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
31025 }
31026 arg1 = reinterpret_cast< wxWindow * >(argp1);
31027 {
31028 PyThreadState* __tstate = wxPyBeginAllowThreads();
31029 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
31030 wxPyEndAllowThreads(__tstate);
31031 if (PyErr_Occurred()) SWIG_fail;
31032 }
31033 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31034 return resultobj;
31035 fail:
31036 return NULL;
31037 }
31038
31039
31040 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31041 PyObject *resultobj = 0;
31042 wxWindow *arg1 = (wxWindow *) 0 ;
31043 wxRect result;
31044 void *argp1 = 0 ;
31045 int res1 = 0 ;
31046 PyObject *swig_obj[1] ;
31047
31048 if (!args) SWIG_fail;
31049 swig_obj[0] = args;
31050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31051 if (!SWIG_IsOK(res1)) {
31052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31053 }
31054 arg1 = reinterpret_cast< wxWindow * >(argp1);
31055 {
31056 PyThreadState* __tstate = wxPyBeginAllowThreads();
31057 result = ((wxWindow const *)arg1)->GetClientRect();
31058 wxPyEndAllowThreads(__tstate);
31059 if (PyErr_Occurred()) SWIG_fail;
31060 }
31061 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31062 return resultobj;
31063 fail:
31064 return NULL;
31065 }
31066
31067
31068 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31069 PyObject *resultobj = 0;
31070 wxWindow *arg1 = (wxWindow *) 0 ;
31071 wxSize result;
31072 void *argp1 = 0 ;
31073 int res1 = 0 ;
31074 PyObject *swig_obj[1] ;
31075
31076 if (!args) SWIG_fail;
31077 swig_obj[0] = args;
31078 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31079 if (!SWIG_IsOK(res1)) {
31080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31081 }
31082 arg1 = reinterpret_cast< wxWindow * >(argp1);
31083 {
31084 PyThreadState* __tstate = wxPyBeginAllowThreads();
31085 result = ((wxWindow const *)arg1)->GetBestSize();
31086 wxPyEndAllowThreads(__tstate);
31087 if (PyErr_Occurred()) SWIG_fail;
31088 }
31089 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31090 return resultobj;
31091 fail:
31092 return NULL;
31093 }
31094
31095
31096 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31097 PyObject *resultobj = 0;
31098 wxWindow *arg1 = (wxWindow *) 0 ;
31099 int *arg2 = (int *) 0 ;
31100 int *arg3 = (int *) 0 ;
31101 void *argp1 = 0 ;
31102 int res1 = 0 ;
31103 int temp2 ;
31104 int res2 = SWIG_TMPOBJ ;
31105 int temp3 ;
31106 int res3 = SWIG_TMPOBJ ;
31107 PyObject *swig_obj[1] ;
31108
31109 arg2 = &temp2;
31110 arg3 = &temp3;
31111 if (!args) SWIG_fail;
31112 swig_obj[0] = args;
31113 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31114 if (!SWIG_IsOK(res1)) {
31115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31116 }
31117 arg1 = reinterpret_cast< wxWindow * >(argp1);
31118 {
31119 PyThreadState* __tstate = wxPyBeginAllowThreads();
31120 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
31121 wxPyEndAllowThreads(__tstate);
31122 if (PyErr_Occurred()) SWIG_fail;
31123 }
31124 resultobj = SWIG_Py_Void();
31125 if (SWIG_IsTmpObj(res2)) {
31126 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31127 } else {
31128 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31129 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31130 }
31131 if (SWIG_IsTmpObj(res3)) {
31132 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31133 } else {
31134 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31135 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31136 }
31137 return resultobj;
31138 fail:
31139 return NULL;
31140 }
31141
31142
31143 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31144 PyObject *resultobj = 0;
31145 wxWindow *arg1 = (wxWindow *) 0 ;
31146 void *argp1 = 0 ;
31147 int res1 = 0 ;
31148 PyObject *swig_obj[1] ;
31149
31150 if (!args) SWIG_fail;
31151 swig_obj[0] = args;
31152 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31153 if (!SWIG_IsOK(res1)) {
31154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31155 }
31156 arg1 = reinterpret_cast< wxWindow * >(argp1);
31157 {
31158 PyThreadState* __tstate = wxPyBeginAllowThreads();
31159 (arg1)->InvalidateBestSize();
31160 wxPyEndAllowThreads(__tstate);
31161 if (PyErr_Occurred()) SWIG_fail;
31162 }
31163 resultobj = SWIG_Py_Void();
31164 return resultobj;
31165 fail:
31166 return NULL;
31167 }
31168
31169
31170 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31171 PyObject *resultobj = 0;
31172 wxWindow *arg1 = (wxWindow *) 0 ;
31173 wxSize *arg2 = 0 ;
31174 void *argp1 = 0 ;
31175 int res1 = 0 ;
31176 wxSize temp2 ;
31177 PyObject * obj0 = 0 ;
31178 PyObject * obj1 = 0 ;
31179 char * kwnames[] = {
31180 (char *) "self",(char *) "size", NULL
31181 };
31182
31183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
31184 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31185 if (!SWIG_IsOK(res1)) {
31186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31187 }
31188 arg1 = reinterpret_cast< wxWindow * >(argp1);
31189 {
31190 arg2 = &temp2;
31191 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31192 }
31193 {
31194 PyThreadState* __tstate = wxPyBeginAllowThreads();
31195 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
31196 wxPyEndAllowThreads(__tstate);
31197 if (PyErr_Occurred()) SWIG_fail;
31198 }
31199 resultobj = SWIG_Py_Void();
31200 return resultobj;
31201 fail:
31202 return NULL;
31203 }
31204
31205
31206 SWIGINTERN PyObject *_wrap_Window_GetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31207 PyObject *resultobj = 0;
31208 wxWindow *arg1 = (wxWindow *) 0 ;
31209 wxSize result;
31210 void *argp1 = 0 ;
31211 int res1 = 0 ;
31212 PyObject *swig_obj[1] ;
31213
31214 if (!args) SWIG_fail;
31215 swig_obj[0] = args;
31216 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31217 if (!SWIG_IsOK(res1)) {
31218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31219 }
31220 arg1 = reinterpret_cast< wxWindow * >(argp1);
31221 {
31222 PyThreadState* __tstate = wxPyBeginAllowThreads();
31223 result = ((wxWindow const *)arg1)->GetBestFittingSize();
31224 wxPyEndAllowThreads(__tstate);
31225 if (PyErr_Occurred()) SWIG_fail;
31226 }
31227 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31228 return resultobj;
31229 fail:
31230 return NULL;
31231 }
31232
31233
31234 SWIGINTERN PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31235 PyObject *resultobj = 0;
31236 wxWindow *arg1 = (wxWindow *) 0 ;
31237 wxSize result;
31238 void *argp1 = 0 ;
31239 int res1 = 0 ;
31240 PyObject *swig_obj[1] ;
31241
31242 if (!args) SWIG_fail;
31243 swig_obj[0] = args;
31244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31245 if (!SWIG_IsOK(res1)) {
31246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAdjustedBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31247 }
31248 arg1 = reinterpret_cast< wxWindow * >(argp1);
31249 {
31250 PyThreadState* __tstate = wxPyBeginAllowThreads();
31251 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
31252 wxPyEndAllowThreads(__tstate);
31253 if (PyErr_Occurred()) SWIG_fail;
31254 }
31255 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31256 return resultobj;
31257 fail:
31258 return NULL;
31259 }
31260
31261
31262 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31263 PyObject *resultobj = 0;
31264 wxWindow *arg1 = (wxWindow *) 0 ;
31265 int arg2 = (int) wxBOTH ;
31266 void *argp1 = 0 ;
31267 int res1 = 0 ;
31268 int val2 ;
31269 int ecode2 = 0 ;
31270 PyObject * obj0 = 0 ;
31271 PyObject * obj1 = 0 ;
31272 char * kwnames[] = {
31273 (char *) "self",(char *) "direction", NULL
31274 };
31275
31276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
31277 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31278 if (!SWIG_IsOK(res1)) {
31279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
31280 }
31281 arg1 = reinterpret_cast< wxWindow * >(argp1);
31282 if (obj1) {
31283 ecode2 = SWIG_AsVal_int(obj1, &val2);
31284 if (!SWIG_IsOK(ecode2)) {
31285 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
31286 }
31287 arg2 = static_cast< int >(val2);
31288 }
31289 {
31290 PyThreadState* __tstate = wxPyBeginAllowThreads();
31291 (arg1)->Center(arg2);
31292 wxPyEndAllowThreads(__tstate);
31293 if (PyErr_Occurred()) SWIG_fail;
31294 }
31295 resultobj = SWIG_Py_Void();
31296 return resultobj;
31297 fail:
31298 return NULL;
31299 }
31300
31301
31302 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31303 PyObject *resultobj = 0;
31304 wxWindow *arg1 = (wxWindow *) 0 ;
31305 int arg2 = (int) wxBOTH ;
31306 void *argp1 = 0 ;
31307 int res1 = 0 ;
31308 int val2 ;
31309 int ecode2 = 0 ;
31310 PyObject * obj0 = 0 ;
31311 PyObject * obj1 = 0 ;
31312 char * kwnames[] = {
31313 (char *) "self",(char *) "dir", NULL
31314 };
31315
31316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
31317 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31318 if (!SWIG_IsOK(res1)) {
31319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
31320 }
31321 arg1 = reinterpret_cast< wxWindow * >(argp1);
31322 if (obj1) {
31323 ecode2 = SWIG_AsVal_int(obj1, &val2);
31324 if (!SWIG_IsOK(ecode2)) {
31325 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
31326 }
31327 arg2 = static_cast< int >(val2);
31328 }
31329 {
31330 PyThreadState* __tstate = wxPyBeginAllowThreads();
31331 (arg1)->CenterOnParent(arg2);
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_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31343 PyObject *resultobj = 0;
31344 wxWindow *arg1 = (wxWindow *) 0 ;
31345 void *argp1 = 0 ;
31346 int res1 = 0 ;
31347 PyObject *swig_obj[1] ;
31348
31349 if (!args) SWIG_fail;
31350 swig_obj[0] = args;
31351 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31352 if (!SWIG_IsOK(res1)) {
31353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
31354 }
31355 arg1 = reinterpret_cast< wxWindow * >(argp1);
31356 {
31357 PyThreadState* __tstate = wxPyBeginAllowThreads();
31358 (arg1)->Fit();
31359 wxPyEndAllowThreads(__tstate);
31360 if (PyErr_Occurred()) SWIG_fail;
31361 }
31362 resultobj = SWIG_Py_Void();
31363 return resultobj;
31364 fail:
31365 return NULL;
31366 }
31367
31368
31369 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31370 PyObject *resultobj = 0;
31371 wxWindow *arg1 = (wxWindow *) 0 ;
31372 void *argp1 = 0 ;
31373 int res1 = 0 ;
31374 PyObject *swig_obj[1] ;
31375
31376 if (!args) SWIG_fail;
31377 swig_obj[0] = args;
31378 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31379 if (!SWIG_IsOK(res1)) {
31380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
31381 }
31382 arg1 = reinterpret_cast< wxWindow * >(argp1);
31383 {
31384 PyThreadState* __tstate = wxPyBeginAllowThreads();
31385 (arg1)->FitInside();
31386 wxPyEndAllowThreads(__tstate);
31387 if (PyErr_Occurred()) SWIG_fail;
31388 }
31389 resultobj = SWIG_Py_Void();
31390 return resultobj;
31391 fail:
31392 return NULL;
31393 }
31394
31395
31396 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31397 PyObject *resultobj = 0;
31398 wxWindow *arg1 = (wxWindow *) 0 ;
31399 int arg2 ;
31400 int arg3 ;
31401 int arg4 = (int) -1 ;
31402 int arg5 = (int) -1 ;
31403 int arg6 = (int) -1 ;
31404 int arg7 = (int) -1 ;
31405 void *argp1 = 0 ;
31406 int res1 = 0 ;
31407 int val2 ;
31408 int ecode2 = 0 ;
31409 int val3 ;
31410 int ecode3 = 0 ;
31411 int val4 ;
31412 int ecode4 = 0 ;
31413 int val5 ;
31414 int ecode5 = 0 ;
31415 int val6 ;
31416 int ecode6 = 0 ;
31417 int val7 ;
31418 int ecode7 = 0 ;
31419 PyObject * obj0 = 0 ;
31420 PyObject * obj1 = 0 ;
31421 PyObject * obj2 = 0 ;
31422 PyObject * obj3 = 0 ;
31423 PyObject * obj4 = 0 ;
31424 PyObject * obj5 = 0 ;
31425 PyObject * obj6 = 0 ;
31426 char * kwnames[] = {
31427 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
31428 };
31429
31430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
31431 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31432 if (!SWIG_IsOK(res1)) {
31433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31434 }
31435 arg1 = reinterpret_cast< wxWindow * >(argp1);
31436 ecode2 = SWIG_AsVal_int(obj1, &val2);
31437 if (!SWIG_IsOK(ecode2)) {
31438 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
31439 }
31440 arg2 = static_cast< int >(val2);
31441 ecode3 = SWIG_AsVal_int(obj2, &val3);
31442 if (!SWIG_IsOK(ecode3)) {
31443 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
31444 }
31445 arg3 = static_cast< int >(val3);
31446 if (obj3) {
31447 ecode4 = SWIG_AsVal_int(obj3, &val4);
31448 if (!SWIG_IsOK(ecode4)) {
31449 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
31450 }
31451 arg4 = static_cast< int >(val4);
31452 }
31453 if (obj4) {
31454 ecode5 = SWIG_AsVal_int(obj4, &val5);
31455 if (!SWIG_IsOK(ecode5)) {
31456 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
31457 }
31458 arg5 = static_cast< int >(val5);
31459 }
31460 if (obj5) {
31461 ecode6 = SWIG_AsVal_int(obj5, &val6);
31462 if (!SWIG_IsOK(ecode6)) {
31463 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
31464 }
31465 arg6 = static_cast< int >(val6);
31466 }
31467 if (obj6) {
31468 ecode7 = SWIG_AsVal_int(obj6, &val7);
31469 if (!SWIG_IsOK(ecode7)) {
31470 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
31471 }
31472 arg7 = static_cast< int >(val7);
31473 }
31474 {
31475 PyThreadState* __tstate = wxPyBeginAllowThreads();
31476 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
31477 wxPyEndAllowThreads(__tstate);
31478 if (PyErr_Occurred()) SWIG_fail;
31479 }
31480 resultobj = SWIG_Py_Void();
31481 return resultobj;
31482 fail:
31483 return NULL;
31484 }
31485
31486
31487 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31488 PyObject *resultobj = 0;
31489 wxWindow *arg1 = (wxWindow *) 0 ;
31490 wxSize *arg2 = 0 ;
31491 wxSize const &arg3_defvalue = wxDefaultSize ;
31492 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31493 wxSize const &arg4_defvalue = wxDefaultSize ;
31494 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
31495 void *argp1 = 0 ;
31496 int res1 = 0 ;
31497 wxSize temp2 ;
31498 wxSize temp3 ;
31499 wxSize temp4 ;
31500 PyObject * obj0 = 0 ;
31501 PyObject * obj1 = 0 ;
31502 PyObject * obj2 = 0 ;
31503 PyObject * obj3 = 0 ;
31504 char * kwnames[] = {
31505 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
31506 };
31507
31508 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
31509 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31510 if (!SWIG_IsOK(res1)) {
31511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31512 }
31513 arg1 = reinterpret_cast< wxWindow * >(argp1);
31514 {
31515 arg2 = &temp2;
31516 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31517 }
31518 if (obj2) {
31519 {
31520 arg3 = &temp3;
31521 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31522 }
31523 }
31524 if (obj3) {
31525 {
31526 arg4 = &temp4;
31527 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
31528 }
31529 }
31530 {
31531 PyThreadState* __tstate = wxPyBeginAllowThreads();
31532 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
31533 wxPyEndAllowThreads(__tstate);
31534 if (PyErr_Occurred()) SWIG_fail;
31535 }
31536 resultobj = SWIG_Py_Void();
31537 return resultobj;
31538 fail:
31539 return NULL;
31540 }
31541
31542
31543 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31544 PyObject *resultobj = 0;
31545 wxWindow *arg1 = (wxWindow *) 0 ;
31546 int arg2 ;
31547 int arg3 ;
31548 int arg4 = (int) -1 ;
31549 int arg5 = (int) -1 ;
31550 void *argp1 = 0 ;
31551 int res1 = 0 ;
31552 int val2 ;
31553 int ecode2 = 0 ;
31554 int val3 ;
31555 int ecode3 = 0 ;
31556 int val4 ;
31557 int ecode4 = 0 ;
31558 int val5 ;
31559 int ecode5 = 0 ;
31560 PyObject * obj0 = 0 ;
31561 PyObject * obj1 = 0 ;
31562 PyObject * obj2 = 0 ;
31563 PyObject * obj3 = 0 ;
31564 PyObject * obj4 = 0 ;
31565 char * kwnames[] = {
31566 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
31567 };
31568
31569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
31570 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31571 if (!SWIG_IsOK(res1)) {
31572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31573 }
31574 arg1 = reinterpret_cast< wxWindow * >(argp1);
31575 ecode2 = SWIG_AsVal_int(obj1, &val2);
31576 if (!SWIG_IsOK(ecode2)) {
31577 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
31578 }
31579 arg2 = static_cast< int >(val2);
31580 ecode3 = SWIG_AsVal_int(obj2, &val3);
31581 if (!SWIG_IsOK(ecode3)) {
31582 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
31583 }
31584 arg3 = static_cast< int >(val3);
31585 if (obj3) {
31586 ecode4 = SWIG_AsVal_int(obj3, &val4);
31587 if (!SWIG_IsOK(ecode4)) {
31588 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
31589 }
31590 arg4 = static_cast< int >(val4);
31591 }
31592 if (obj4) {
31593 ecode5 = SWIG_AsVal_int(obj4, &val5);
31594 if (!SWIG_IsOK(ecode5)) {
31595 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
31596 }
31597 arg5 = static_cast< int >(val5);
31598 }
31599 {
31600 PyThreadState* __tstate = wxPyBeginAllowThreads();
31601 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
31602 wxPyEndAllowThreads(__tstate);
31603 if (PyErr_Occurred()) SWIG_fail;
31604 }
31605 resultobj = SWIG_Py_Void();
31606 return resultobj;
31607 fail:
31608 return NULL;
31609 }
31610
31611
31612 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31613 PyObject *resultobj = 0;
31614 wxWindow *arg1 = (wxWindow *) 0 ;
31615 wxSize *arg2 = 0 ;
31616 wxSize const &arg3_defvalue = wxDefaultSize ;
31617 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31618 void *argp1 = 0 ;
31619 int res1 = 0 ;
31620 wxSize temp2 ;
31621 wxSize temp3 ;
31622 PyObject * obj0 = 0 ;
31623 PyObject * obj1 = 0 ;
31624 PyObject * obj2 = 0 ;
31625 char * kwnames[] = {
31626 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
31627 };
31628
31629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31630 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31631 if (!SWIG_IsOK(res1)) {
31632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31633 }
31634 arg1 = reinterpret_cast< wxWindow * >(argp1);
31635 {
31636 arg2 = &temp2;
31637 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31638 }
31639 if (obj2) {
31640 {
31641 arg3 = &temp3;
31642 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31643 }
31644 }
31645 {
31646 PyThreadState* __tstate = wxPyBeginAllowThreads();
31647 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
31648 wxPyEndAllowThreads(__tstate);
31649 if (PyErr_Occurred()) SWIG_fail;
31650 }
31651 resultobj = SWIG_Py_Void();
31652 return resultobj;
31653 fail:
31654 return NULL;
31655 }
31656
31657
31658 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31659 PyObject *resultobj = 0;
31660 wxWindow *arg1 = (wxWindow *) 0 ;
31661 wxSize result;
31662 void *argp1 = 0 ;
31663 int res1 = 0 ;
31664 PyObject *swig_obj[1] ;
31665
31666 if (!args) SWIG_fail;
31667 swig_obj[0] = args;
31668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31669 if (!SWIG_IsOK(res1)) {
31670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31671 }
31672 arg1 = reinterpret_cast< wxWindow * >(argp1);
31673 {
31674 PyThreadState* __tstate = wxPyBeginAllowThreads();
31675 result = ((wxWindow const *)arg1)->GetMaxSize();
31676 wxPyEndAllowThreads(__tstate);
31677 if (PyErr_Occurred()) SWIG_fail;
31678 }
31679 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31680 return resultobj;
31681 fail:
31682 return NULL;
31683 }
31684
31685
31686 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31687 PyObject *resultobj = 0;
31688 wxWindow *arg1 = (wxWindow *) 0 ;
31689 wxSize result;
31690 void *argp1 = 0 ;
31691 int res1 = 0 ;
31692 PyObject *swig_obj[1] ;
31693
31694 if (!args) SWIG_fail;
31695 swig_obj[0] = args;
31696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31697 if (!SWIG_IsOK(res1)) {
31698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31699 }
31700 arg1 = reinterpret_cast< wxWindow * >(argp1);
31701 {
31702 PyThreadState* __tstate = wxPyBeginAllowThreads();
31703 result = ((wxWindow const *)arg1)->GetMinSize();
31704 wxPyEndAllowThreads(__tstate);
31705 if (PyErr_Occurred()) SWIG_fail;
31706 }
31707 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31708 return resultobj;
31709 fail:
31710 return NULL;
31711 }
31712
31713
31714 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31715 PyObject *resultobj = 0;
31716 wxWindow *arg1 = (wxWindow *) 0 ;
31717 wxSize *arg2 = 0 ;
31718 void *argp1 = 0 ;
31719 int res1 = 0 ;
31720 wxSize temp2 ;
31721 PyObject * obj0 = 0 ;
31722 PyObject * obj1 = 0 ;
31723 char * kwnames[] = {
31724 (char *) "self",(char *) "minSize", NULL
31725 };
31726
31727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
31728 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31729 if (!SWIG_IsOK(res1)) {
31730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31731 }
31732 arg1 = reinterpret_cast< wxWindow * >(argp1);
31733 {
31734 arg2 = &temp2;
31735 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31736 }
31737 {
31738 PyThreadState* __tstate = wxPyBeginAllowThreads();
31739 (arg1)->SetMinSize((wxSize const &)*arg2);
31740 wxPyEndAllowThreads(__tstate);
31741 if (PyErr_Occurred()) SWIG_fail;
31742 }
31743 resultobj = SWIG_Py_Void();
31744 return resultobj;
31745 fail:
31746 return NULL;
31747 }
31748
31749
31750 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31751 PyObject *resultobj = 0;
31752 wxWindow *arg1 = (wxWindow *) 0 ;
31753 wxSize *arg2 = 0 ;
31754 void *argp1 = 0 ;
31755 int res1 = 0 ;
31756 wxSize temp2 ;
31757 PyObject * obj0 = 0 ;
31758 PyObject * obj1 = 0 ;
31759 char * kwnames[] = {
31760 (char *) "self",(char *) "maxSize", NULL
31761 };
31762
31763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
31764 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31765 if (!SWIG_IsOK(res1)) {
31766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31767 }
31768 arg1 = reinterpret_cast< wxWindow * >(argp1);
31769 {
31770 arg2 = &temp2;
31771 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31772 }
31773 {
31774 PyThreadState* __tstate = wxPyBeginAllowThreads();
31775 (arg1)->SetMaxSize((wxSize const &)*arg2);
31776 wxPyEndAllowThreads(__tstate);
31777 if (PyErr_Occurred()) SWIG_fail;
31778 }
31779 resultobj = SWIG_Py_Void();
31780 return resultobj;
31781 fail:
31782 return NULL;
31783 }
31784
31785
31786 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31787 PyObject *resultobj = 0;
31788 wxWindow *arg1 = (wxWindow *) 0 ;
31789 int result;
31790 void *argp1 = 0 ;
31791 int res1 = 0 ;
31792 PyObject *swig_obj[1] ;
31793
31794 if (!args) SWIG_fail;
31795 swig_obj[0] = args;
31796 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31797 if (!SWIG_IsOK(res1)) {
31798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
31799 }
31800 arg1 = reinterpret_cast< wxWindow * >(argp1);
31801 {
31802 PyThreadState* __tstate = wxPyBeginAllowThreads();
31803 result = (int)((wxWindow const *)arg1)->GetMinWidth();
31804 wxPyEndAllowThreads(__tstate);
31805 if (PyErr_Occurred()) SWIG_fail;
31806 }
31807 resultobj = SWIG_From_int(static_cast< int >(result));
31808 return resultobj;
31809 fail:
31810 return NULL;
31811 }
31812
31813
31814 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31815 PyObject *resultobj = 0;
31816 wxWindow *arg1 = (wxWindow *) 0 ;
31817 int result;
31818 void *argp1 = 0 ;
31819 int res1 = 0 ;
31820 PyObject *swig_obj[1] ;
31821
31822 if (!args) SWIG_fail;
31823 swig_obj[0] = args;
31824 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31825 if (!SWIG_IsOK(res1)) {
31826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
31827 }
31828 arg1 = reinterpret_cast< wxWindow * >(argp1);
31829 {
31830 PyThreadState* __tstate = wxPyBeginAllowThreads();
31831 result = (int)((wxWindow const *)arg1)->GetMinHeight();
31832 wxPyEndAllowThreads(__tstate);
31833 if (PyErr_Occurred()) SWIG_fail;
31834 }
31835 resultobj = SWIG_From_int(static_cast< int >(result));
31836 return resultobj;
31837 fail:
31838 return NULL;
31839 }
31840
31841
31842 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31843 PyObject *resultobj = 0;
31844 wxWindow *arg1 = (wxWindow *) 0 ;
31845 int result;
31846 void *argp1 = 0 ;
31847 int res1 = 0 ;
31848 PyObject *swig_obj[1] ;
31849
31850 if (!args) SWIG_fail;
31851 swig_obj[0] = args;
31852 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31853 if (!SWIG_IsOK(res1)) {
31854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
31855 }
31856 arg1 = reinterpret_cast< wxWindow * >(argp1);
31857 {
31858 PyThreadState* __tstate = wxPyBeginAllowThreads();
31859 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
31860 wxPyEndAllowThreads(__tstate);
31861 if (PyErr_Occurred()) SWIG_fail;
31862 }
31863 resultobj = SWIG_From_int(static_cast< int >(result));
31864 return resultobj;
31865 fail:
31866 return NULL;
31867 }
31868
31869
31870 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31871 PyObject *resultobj = 0;
31872 wxWindow *arg1 = (wxWindow *) 0 ;
31873 int result;
31874 void *argp1 = 0 ;
31875 int res1 = 0 ;
31876 PyObject *swig_obj[1] ;
31877
31878 if (!args) SWIG_fail;
31879 swig_obj[0] = args;
31880 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31881 if (!SWIG_IsOK(res1)) {
31882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
31883 }
31884 arg1 = reinterpret_cast< wxWindow * >(argp1);
31885 {
31886 PyThreadState* __tstate = wxPyBeginAllowThreads();
31887 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
31888 wxPyEndAllowThreads(__tstate);
31889 if (PyErr_Occurred()) SWIG_fail;
31890 }
31891 resultobj = SWIG_From_int(static_cast< int >(result));
31892 return resultobj;
31893 fail:
31894 return NULL;
31895 }
31896
31897
31898 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31899 PyObject *resultobj = 0;
31900 wxWindow *arg1 = (wxWindow *) 0 ;
31901 wxSize *arg2 = 0 ;
31902 void *argp1 = 0 ;
31903 int res1 = 0 ;
31904 wxSize temp2 ;
31905 PyObject * obj0 = 0 ;
31906 PyObject * obj1 = 0 ;
31907 char * kwnames[] = {
31908 (char *) "self",(char *) "size", NULL
31909 };
31910
31911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
31912 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31913 if (!SWIG_IsOK(res1)) {
31914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31915 }
31916 arg1 = reinterpret_cast< wxWindow * >(argp1);
31917 {
31918 arg2 = &temp2;
31919 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31920 }
31921 {
31922 PyThreadState* __tstate = wxPyBeginAllowThreads();
31923 (arg1)->SetVirtualSize((wxSize const &)*arg2);
31924 wxPyEndAllowThreads(__tstate);
31925 if (PyErr_Occurred()) SWIG_fail;
31926 }
31927 resultobj = SWIG_Py_Void();
31928 return resultobj;
31929 fail:
31930 return NULL;
31931 }
31932
31933
31934 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31935 PyObject *resultobj = 0;
31936 wxWindow *arg1 = (wxWindow *) 0 ;
31937 int arg2 ;
31938 int arg3 ;
31939 void *argp1 = 0 ;
31940 int res1 = 0 ;
31941 int val2 ;
31942 int ecode2 = 0 ;
31943 int val3 ;
31944 int ecode3 = 0 ;
31945 PyObject * obj0 = 0 ;
31946 PyObject * obj1 = 0 ;
31947 PyObject * obj2 = 0 ;
31948 char * kwnames[] = {
31949 (char *) "self",(char *) "w",(char *) "h", NULL
31950 };
31951
31952 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31953 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31954 if (!SWIG_IsOK(res1)) {
31955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
31956 }
31957 arg1 = reinterpret_cast< wxWindow * >(argp1);
31958 ecode2 = SWIG_AsVal_int(obj1, &val2);
31959 if (!SWIG_IsOK(ecode2)) {
31960 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
31961 }
31962 arg2 = static_cast< int >(val2);
31963 ecode3 = SWIG_AsVal_int(obj2, &val3);
31964 if (!SWIG_IsOK(ecode3)) {
31965 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
31966 }
31967 arg3 = static_cast< int >(val3);
31968 {
31969 PyThreadState* __tstate = wxPyBeginAllowThreads();
31970 (arg1)->SetVirtualSize(arg2,arg3);
31971 wxPyEndAllowThreads(__tstate);
31972 if (PyErr_Occurred()) SWIG_fail;
31973 }
31974 resultobj = SWIG_Py_Void();
31975 return resultobj;
31976 fail:
31977 return NULL;
31978 }
31979
31980
31981 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31982 PyObject *resultobj = 0;
31983 wxWindow *arg1 = (wxWindow *) 0 ;
31984 wxSize result;
31985 void *argp1 = 0 ;
31986 int res1 = 0 ;
31987 PyObject *swig_obj[1] ;
31988
31989 if (!args) SWIG_fail;
31990 swig_obj[0] = args;
31991 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31992 if (!SWIG_IsOK(res1)) {
31993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31994 }
31995 arg1 = reinterpret_cast< wxWindow * >(argp1);
31996 {
31997 PyThreadState* __tstate = wxPyBeginAllowThreads();
31998 result = ((wxWindow const *)arg1)->GetVirtualSize();
31999 wxPyEndAllowThreads(__tstate);
32000 if (PyErr_Occurred()) SWIG_fail;
32001 }
32002 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32003 return resultobj;
32004 fail:
32005 return NULL;
32006 }
32007
32008
32009 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32010 PyObject *resultobj = 0;
32011 wxWindow *arg1 = (wxWindow *) 0 ;
32012 int *arg2 = (int *) 0 ;
32013 int *arg3 = (int *) 0 ;
32014 void *argp1 = 0 ;
32015 int res1 = 0 ;
32016 int temp2 ;
32017 int res2 = SWIG_TMPOBJ ;
32018 int temp3 ;
32019 int res3 = SWIG_TMPOBJ ;
32020 PyObject *swig_obj[1] ;
32021
32022 arg2 = &temp2;
32023 arg3 = &temp3;
32024 if (!args) SWIG_fail;
32025 swig_obj[0] = args;
32026 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32027 if (!SWIG_IsOK(res1)) {
32028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
32029 }
32030 arg1 = reinterpret_cast< wxWindow * >(argp1);
32031 {
32032 PyThreadState* __tstate = wxPyBeginAllowThreads();
32033 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
32034 wxPyEndAllowThreads(__tstate);
32035 if (PyErr_Occurred()) SWIG_fail;
32036 }
32037 resultobj = SWIG_Py_Void();
32038 if (SWIG_IsTmpObj(res2)) {
32039 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
32040 } else {
32041 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32042 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32043 }
32044 if (SWIG_IsTmpObj(res3)) {
32045 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32046 } else {
32047 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32048 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32049 }
32050 return resultobj;
32051 fail:
32052 return NULL;
32053 }
32054
32055
32056 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32057 PyObject *resultobj = 0;
32058 wxWindow *arg1 = (wxWindow *) 0 ;
32059 wxSize result;
32060 void *argp1 = 0 ;
32061 int res1 = 0 ;
32062 PyObject *swig_obj[1] ;
32063
32064 if (!args) SWIG_fail;
32065 swig_obj[0] = args;
32066 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32067 if (!SWIG_IsOK(res1)) {
32068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32069 }
32070 arg1 = reinterpret_cast< wxWindow * >(argp1);
32071 {
32072 PyThreadState* __tstate = wxPyBeginAllowThreads();
32073 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
32074 wxPyEndAllowThreads(__tstate);
32075 if (PyErr_Occurred()) SWIG_fail;
32076 }
32077 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32078 return resultobj;
32079 fail:
32080 return NULL;
32081 }
32082
32083
32084 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32085 PyObject *resultobj = 0;
32086 wxWindow *arg1 = (wxWindow *) 0 ;
32087 bool arg2 = (bool) true ;
32088 bool result;
32089 void *argp1 = 0 ;
32090 int res1 = 0 ;
32091 bool val2 ;
32092 int ecode2 = 0 ;
32093 PyObject * obj0 = 0 ;
32094 PyObject * obj1 = 0 ;
32095 char * kwnames[] = {
32096 (char *) "self",(char *) "show", NULL
32097 };
32098
32099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
32100 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32101 if (!SWIG_IsOK(res1)) {
32102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
32103 }
32104 arg1 = reinterpret_cast< wxWindow * >(argp1);
32105 if (obj1) {
32106 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32107 if (!SWIG_IsOK(ecode2)) {
32108 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
32109 }
32110 arg2 = static_cast< bool >(val2);
32111 }
32112 {
32113 PyThreadState* __tstate = wxPyBeginAllowThreads();
32114 result = (bool)(arg1)->Show(arg2);
32115 wxPyEndAllowThreads(__tstate);
32116 if (PyErr_Occurred()) SWIG_fail;
32117 }
32118 {
32119 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32120 }
32121 return resultobj;
32122 fail:
32123 return NULL;
32124 }
32125
32126
32127 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32128 PyObject *resultobj = 0;
32129 wxWindow *arg1 = (wxWindow *) 0 ;
32130 bool result;
32131 void *argp1 = 0 ;
32132 int res1 = 0 ;
32133 PyObject *swig_obj[1] ;
32134
32135 if (!args) SWIG_fail;
32136 swig_obj[0] = args;
32137 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32138 if (!SWIG_IsOK(res1)) {
32139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
32140 }
32141 arg1 = reinterpret_cast< wxWindow * >(argp1);
32142 {
32143 PyThreadState* __tstate = wxPyBeginAllowThreads();
32144 result = (bool)(arg1)->Hide();
32145 wxPyEndAllowThreads(__tstate);
32146 if (PyErr_Occurred()) SWIG_fail;
32147 }
32148 {
32149 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32150 }
32151 return resultobj;
32152 fail:
32153 return NULL;
32154 }
32155
32156
32157 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32158 PyObject *resultobj = 0;
32159 wxWindow *arg1 = (wxWindow *) 0 ;
32160 bool arg2 = (bool) true ;
32161 bool result;
32162 void *argp1 = 0 ;
32163 int res1 = 0 ;
32164 bool val2 ;
32165 int ecode2 = 0 ;
32166 PyObject * obj0 = 0 ;
32167 PyObject * obj1 = 0 ;
32168 char * kwnames[] = {
32169 (char *) "self",(char *) "enable", NULL
32170 };
32171
32172 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
32173 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32174 if (!SWIG_IsOK(res1)) {
32175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
32176 }
32177 arg1 = reinterpret_cast< wxWindow * >(argp1);
32178 if (obj1) {
32179 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32180 if (!SWIG_IsOK(ecode2)) {
32181 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
32182 }
32183 arg2 = static_cast< bool >(val2);
32184 }
32185 {
32186 PyThreadState* __tstate = wxPyBeginAllowThreads();
32187 result = (bool)(arg1)->Enable(arg2);
32188 wxPyEndAllowThreads(__tstate);
32189 if (PyErr_Occurred()) SWIG_fail;
32190 }
32191 {
32192 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32193 }
32194 return resultobj;
32195 fail:
32196 return NULL;
32197 }
32198
32199
32200 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32201 PyObject *resultobj = 0;
32202 wxWindow *arg1 = (wxWindow *) 0 ;
32203 bool result;
32204 void *argp1 = 0 ;
32205 int res1 = 0 ;
32206 PyObject *swig_obj[1] ;
32207
32208 if (!args) SWIG_fail;
32209 swig_obj[0] = args;
32210 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32211 if (!SWIG_IsOK(res1)) {
32212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
32213 }
32214 arg1 = reinterpret_cast< wxWindow * >(argp1);
32215 {
32216 PyThreadState* __tstate = wxPyBeginAllowThreads();
32217 result = (bool)(arg1)->Disable();
32218 wxPyEndAllowThreads(__tstate);
32219 if (PyErr_Occurred()) SWIG_fail;
32220 }
32221 {
32222 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32223 }
32224 return resultobj;
32225 fail:
32226 return NULL;
32227 }
32228
32229
32230 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32231 PyObject *resultobj = 0;
32232 wxWindow *arg1 = (wxWindow *) 0 ;
32233 bool result;
32234 void *argp1 = 0 ;
32235 int res1 = 0 ;
32236 PyObject *swig_obj[1] ;
32237
32238 if (!args) SWIG_fail;
32239 swig_obj[0] = args;
32240 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32241 if (!SWIG_IsOK(res1)) {
32242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
32243 }
32244 arg1 = reinterpret_cast< wxWindow * >(argp1);
32245 {
32246 PyThreadState* __tstate = wxPyBeginAllowThreads();
32247 result = (bool)((wxWindow const *)arg1)->IsShown();
32248 wxPyEndAllowThreads(__tstate);
32249 if (PyErr_Occurred()) SWIG_fail;
32250 }
32251 {
32252 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32253 }
32254 return resultobj;
32255 fail:
32256 return NULL;
32257 }
32258
32259
32260 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32261 PyObject *resultobj = 0;
32262 wxWindow *arg1 = (wxWindow *) 0 ;
32263 bool result;
32264 void *argp1 = 0 ;
32265 int res1 = 0 ;
32266 PyObject *swig_obj[1] ;
32267
32268 if (!args) SWIG_fail;
32269 swig_obj[0] = args;
32270 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32271 if (!SWIG_IsOK(res1)) {
32272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32273 }
32274 arg1 = reinterpret_cast< wxWindow * >(argp1);
32275 {
32276 PyThreadState* __tstate = wxPyBeginAllowThreads();
32277 result = (bool)((wxWindow const *)arg1)->IsEnabled();
32278 wxPyEndAllowThreads(__tstate);
32279 if (PyErr_Occurred()) SWIG_fail;
32280 }
32281 {
32282 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32283 }
32284 return resultobj;
32285 fail:
32286 return NULL;
32287 }
32288
32289
32290 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32291 PyObject *resultobj = 0;
32292 wxWindow *arg1 = (wxWindow *) 0 ;
32293 long arg2 ;
32294 void *argp1 = 0 ;
32295 int res1 = 0 ;
32296 long val2 ;
32297 int ecode2 = 0 ;
32298 PyObject * obj0 = 0 ;
32299 PyObject * obj1 = 0 ;
32300 char * kwnames[] = {
32301 (char *) "self",(char *) "style", NULL
32302 };
32303
32304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32305 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32306 if (!SWIG_IsOK(res1)) {
32307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
32308 }
32309 arg1 = reinterpret_cast< wxWindow * >(argp1);
32310 ecode2 = SWIG_AsVal_long(obj1, &val2);
32311 if (!SWIG_IsOK(ecode2)) {
32312 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
32313 }
32314 arg2 = static_cast< long >(val2);
32315 {
32316 PyThreadState* __tstate = wxPyBeginAllowThreads();
32317 (arg1)->SetWindowStyleFlag(arg2);
32318 wxPyEndAllowThreads(__tstate);
32319 if (PyErr_Occurred()) SWIG_fail;
32320 }
32321 resultobj = SWIG_Py_Void();
32322 return resultobj;
32323 fail:
32324 return NULL;
32325 }
32326
32327
32328 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32329 PyObject *resultobj = 0;
32330 wxWindow *arg1 = (wxWindow *) 0 ;
32331 long result;
32332 void *argp1 = 0 ;
32333 int res1 = 0 ;
32334 PyObject *swig_obj[1] ;
32335
32336 if (!args) SWIG_fail;
32337 swig_obj[0] = args;
32338 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32339 if (!SWIG_IsOK(res1)) {
32340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32341 }
32342 arg1 = reinterpret_cast< wxWindow * >(argp1);
32343 {
32344 PyThreadState* __tstate = wxPyBeginAllowThreads();
32345 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
32346 wxPyEndAllowThreads(__tstate);
32347 if (PyErr_Occurred()) SWIG_fail;
32348 }
32349 resultobj = SWIG_From_long(static_cast< long >(result));
32350 return resultobj;
32351 fail:
32352 return NULL;
32353 }
32354
32355
32356 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32357 PyObject *resultobj = 0;
32358 wxWindow *arg1 = (wxWindow *) 0 ;
32359 int arg2 ;
32360 bool result;
32361 void *argp1 = 0 ;
32362 int res1 = 0 ;
32363 int val2 ;
32364 int ecode2 = 0 ;
32365 PyObject * obj0 = 0 ;
32366 PyObject * obj1 = 0 ;
32367 char * kwnames[] = {
32368 (char *) "self",(char *) "flag", NULL
32369 };
32370
32371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32372 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32373 if (!SWIG_IsOK(res1)) {
32374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32375 }
32376 arg1 = reinterpret_cast< wxWindow * >(argp1);
32377 ecode2 = SWIG_AsVal_int(obj1, &val2);
32378 if (!SWIG_IsOK(ecode2)) {
32379 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
32380 }
32381 arg2 = static_cast< int >(val2);
32382 {
32383 PyThreadState* __tstate = wxPyBeginAllowThreads();
32384 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
32385 wxPyEndAllowThreads(__tstate);
32386 if (PyErr_Occurred()) SWIG_fail;
32387 }
32388 {
32389 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32390 }
32391 return resultobj;
32392 fail:
32393 return NULL;
32394 }
32395
32396
32397 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32398 PyObject *resultobj = 0;
32399 wxWindow *arg1 = (wxWindow *) 0 ;
32400 bool result;
32401 void *argp1 = 0 ;
32402 int res1 = 0 ;
32403 PyObject *swig_obj[1] ;
32404
32405 if (!args) SWIG_fail;
32406 swig_obj[0] = args;
32407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32408 if (!SWIG_IsOK(res1)) {
32409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
32410 }
32411 arg1 = reinterpret_cast< wxWindow * >(argp1);
32412 {
32413 PyThreadState* __tstate = wxPyBeginAllowThreads();
32414 result = (bool)((wxWindow const *)arg1)->IsRetained();
32415 wxPyEndAllowThreads(__tstate);
32416 if (PyErr_Occurred()) SWIG_fail;
32417 }
32418 {
32419 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32420 }
32421 return resultobj;
32422 fail:
32423 return NULL;
32424 }
32425
32426
32427 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32428 PyObject *resultobj = 0;
32429 wxWindow *arg1 = (wxWindow *) 0 ;
32430 long arg2 ;
32431 void *argp1 = 0 ;
32432 int res1 = 0 ;
32433 long val2 ;
32434 int ecode2 = 0 ;
32435 PyObject * obj0 = 0 ;
32436 PyObject * obj1 = 0 ;
32437 char * kwnames[] = {
32438 (char *) "self",(char *) "exStyle", NULL
32439 };
32440
32441 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
32442 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32443 if (!SWIG_IsOK(res1)) {
32444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
32445 }
32446 arg1 = reinterpret_cast< wxWindow * >(argp1);
32447 ecode2 = SWIG_AsVal_long(obj1, &val2);
32448 if (!SWIG_IsOK(ecode2)) {
32449 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
32450 }
32451 arg2 = static_cast< long >(val2);
32452 {
32453 PyThreadState* __tstate = wxPyBeginAllowThreads();
32454 (arg1)->SetExtraStyle(arg2);
32455 wxPyEndAllowThreads(__tstate);
32456 if (PyErr_Occurred()) SWIG_fail;
32457 }
32458 resultobj = SWIG_Py_Void();
32459 return resultobj;
32460 fail:
32461 return NULL;
32462 }
32463
32464
32465 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32466 PyObject *resultobj = 0;
32467 wxWindow *arg1 = (wxWindow *) 0 ;
32468 long result;
32469 void *argp1 = 0 ;
32470 int res1 = 0 ;
32471 PyObject *swig_obj[1] ;
32472
32473 if (!args) SWIG_fail;
32474 swig_obj[0] = args;
32475 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32476 if (!SWIG_IsOK(res1)) {
32477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
32478 }
32479 arg1 = reinterpret_cast< wxWindow * >(argp1);
32480 {
32481 PyThreadState* __tstate = wxPyBeginAllowThreads();
32482 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
32483 wxPyEndAllowThreads(__tstate);
32484 if (PyErr_Occurred()) SWIG_fail;
32485 }
32486 resultobj = SWIG_From_long(static_cast< long >(result));
32487 return resultobj;
32488 fail:
32489 return NULL;
32490 }
32491
32492
32493 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32494 PyObject *resultobj = 0;
32495 wxWindow *arg1 = (wxWindow *) 0 ;
32496 bool arg2 = (bool) true ;
32497 void *argp1 = 0 ;
32498 int res1 = 0 ;
32499 bool val2 ;
32500 int ecode2 = 0 ;
32501 PyObject * obj0 = 0 ;
32502 PyObject * obj1 = 0 ;
32503 char * kwnames[] = {
32504 (char *) "self",(char *) "modal", NULL
32505 };
32506
32507 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
32508 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32509 if (!SWIG_IsOK(res1)) {
32510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
32511 }
32512 arg1 = reinterpret_cast< wxWindow * >(argp1);
32513 if (obj1) {
32514 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32515 if (!SWIG_IsOK(ecode2)) {
32516 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
32517 }
32518 arg2 = static_cast< bool >(val2);
32519 }
32520 {
32521 PyThreadState* __tstate = wxPyBeginAllowThreads();
32522 (arg1)->MakeModal(arg2);
32523 wxPyEndAllowThreads(__tstate);
32524 if (PyErr_Occurred()) SWIG_fail;
32525 }
32526 resultobj = SWIG_Py_Void();
32527 return resultobj;
32528 fail:
32529 return NULL;
32530 }
32531
32532
32533 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32534 PyObject *resultobj = 0;
32535 wxWindow *arg1 = (wxWindow *) 0 ;
32536 bool arg2 ;
32537 void *argp1 = 0 ;
32538 int res1 = 0 ;
32539 bool val2 ;
32540 int ecode2 = 0 ;
32541 PyObject * obj0 = 0 ;
32542 PyObject * obj1 = 0 ;
32543 char * kwnames[] = {
32544 (char *) "self",(char *) "enableTheme", NULL
32545 };
32546
32547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
32548 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32549 if (!SWIG_IsOK(res1)) {
32550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
32551 }
32552 arg1 = reinterpret_cast< wxWindow * >(argp1);
32553 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32554 if (!SWIG_IsOK(ecode2)) {
32555 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
32556 }
32557 arg2 = static_cast< bool >(val2);
32558 {
32559 PyThreadState* __tstate = wxPyBeginAllowThreads();
32560 (arg1)->SetThemeEnabled(arg2);
32561 wxPyEndAllowThreads(__tstate);
32562 if (PyErr_Occurred()) SWIG_fail;
32563 }
32564 resultobj = SWIG_Py_Void();
32565 return resultobj;
32566 fail:
32567 return NULL;
32568 }
32569
32570
32571 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32572 PyObject *resultobj = 0;
32573 wxWindow *arg1 = (wxWindow *) 0 ;
32574 bool result;
32575 void *argp1 = 0 ;
32576 int res1 = 0 ;
32577 PyObject *swig_obj[1] ;
32578
32579 if (!args) SWIG_fail;
32580 swig_obj[0] = args;
32581 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32582 if (!SWIG_IsOK(res1)) {
32583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32584 }
32585 arg1 = reinterpret_cast< wxWindow * >(argp1);
32586 {
32587 PyThreadState* __tstate = wxPyBeginAllowThreads();
32588 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
32589 wxPyEndAllowThreads(__tstate);
32590 if (PyErr_Occurred()) SWIG_fail;
32591 }
32592 {
32593 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32594 }
32595 return resultobj;
32596 fail:
32597 return NULL;
32598 }
32599
32600
32601 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32602 PyObject *resultobj = 0;
32603 wxWindow *arg1 = (wxWindow *) 0 ;
32604 void *argp1 = 0 ;
32605 int res1 = 0 ;
32606 PyObject *swig_obj[1] ;
32607
32608 if (!args) SWIG_fail;
32609 swig_obj[0] = args;
32610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32611 if (!SWIG_IsOK(res1)) {
32612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
32613 }
32614 arg1 = reinterpret_cast< wxWindow * >(argp1);
32615 {
32616 PyThreadState* __tstate = wxPyBeginAllowThreads();
32617 (arg1)->SetFocus();
32618 wxPyEndAllowThreads(__tstate);
32619 if (PyErr_Occurred()) SWIG_fail;
32620 }
32621 resultobj = SWIG_Py_Void();
32622 return resultobj;
32623 fail:
32624 return NULL;
32625 }
32626
32627
32628 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32629 PyObject *resultobj = 0;
32630 wxWindow *arg1 = (wxWindow *) 0 ;
32631 void *argp1 = 0 ;
32632 int res1 = 0 ;
32633 PyObject *swig_obj[1] ;
32634
32635 if (!args) SWIG_fail;
32636 swig_obj[0] = args;
32637 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32638 if (!SWIG_IsOK(res1)) {
32639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
32640 }
32641 arg1 = reinterpret_cast< wxWindow * >(argp1);
32642 {
32643 PyThreadState* __tstate = wxPyBeginAllowThreads();
32644 (arg1)->SetFocusFromKbd();
32645 wxPyEndAllowThreads(__tstate);
32646 if (PyErr_Occurred()) SWIG_fail;
32647 }
32648 resultobj = SWIG_Py_Void();
32649 return resultobj;
32650 fail:
32651 return NULL;
32652 }
32653
32654
32655 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32656 PyObject *resultobj = 0;
32657 wxWindow *result = 0 ;
32658
32659 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
32660 {
32661 if (!wxPyCheckForApp()) SWIG_fail;
32662 PyThreadState* __tstate = wxPyBeginAllowThreads();
32663 result = (wxWindow *)wxWindow::FindFocus();
32664 wxPyEndAllowThreads(__tstate);
32665 if (PyErr_Occurred()) SWIG_fail;
32666 }
32667 {
32668 resultobj = wxPyMake_wxObject(result, 0);
32669 }
32670 return resultobj;
32671 fail:
32672 return NULL;
32673 }
32674
32675
32676 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32677 PyObject *resultobj = 0;
32678 wxWindow *arg1 = (wxWindow *) 0 ;
32679 bool result;
32680 void *argp1 = 0 ;
32681 int res1 = 0 ;
32682 PyObject *swig_obj[1] ;
32683
32684 if (!args) SWIG_fail;
32685 swig_obj[0] = args;
32686 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32687 if (!SWIG_IsOK(res1)) {
32688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
32689 }
32690 arg1 = reinterpret_cast< wxWindow * >(argp1);
32691 {
32692 PyThreadState* __tstate = wxPyBeginAllowThreads();
32693 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
32694 wxPyEndAllowThreads(__tstate);
32695 if (PyErr_Occurred()) SWIG_fail;
32696 }
32697 {
32698 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32699 }
32700 return resultobj;
32701 fail:
32702 return NULL;
32703 }
32704
32705
32706 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32707 PyObject *resultobj = 0;
32708 wxWindow *arg1 = (wxWindow *) 0 ;
32709 bool result;
32710 void *argp1 = 0 ;
32711 int res1 = 0 ;
32712 PyObject *swig_obj[1] ;
32713
32714 if (!args) SWIG_fail;
32715 swig_obj[0] = args;
32716 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32717 if (!SWIG_IsOK(res1)) {
32718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
32719 }
32720 arg1 = reinterpret_cast< wxWindow * >(argp1);
32721 {
32722 PyThreadState* __tstate = wxPyBeginAllowThreads();
32723 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
32724 wxPyEndAllowThreads(__tstate);
32725 if (PyErr_Occurred()) SWIG_fail;
32726 }
32727 {
32728 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32729 }
32730 return resultobj;
32731 fail:
32732 return NULL;
32733 }
32734
32735
32736 SWIGINTERN PyObject *_wrap_Window_GetDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32737 PyObject *resultobj = 0;
32738 wxWindow *arg1 = (wxWindow *) 0 ;
32739 wxWindow *result = 0 ;
32740 void *argp1 = 0 ;
32741 int res1 = 0 ;
32742 PyObject *swig_obj[1] ;
32743
32744 if (!args) SWIG_fail;
32745 swig_obj[0] = args;
32746 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32747 if (!SWIG_IsOK(res1)) {
32748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultItem" "', expected argument " "1"" of type '" "wxWindow const *""'");
32749 }
32750 arg1 = reinterpret_cast< wxWindow * >(argp1);
32751 {
32752 PyThreadState* __tstate = wxPyBeginAllowThreads();
32753 result = (wxWindow *)((wxWindow const *)arg1)->GetDefaultItem();
32754 wxPyEndAllowThreads(__tstate);
32755 if (PyErr_Occurred()) SWIG_fail;
32756 }
32757 {
32758 resultobj = wxPyMake_wxObject(result, 0);
32759 }
32760 return resultobj;
32761 fail:
32762 return NULL;
32763 }
32764
32765
32766 SWIGINTERN PyObject *_wrap_Window_SetDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32767 PyObject *resultobj = 0;
32768 wxWindow *arg1 = (wxWindow *) 0 ;
32769 wxWindow *arg2 = (wxWindow *) 0 ;
32770 wxWindow *result = 0 ;
32771 void *argp1 = 0 ;
32772 int res1 = 0 ;
32773 void *argp2 = 0 ;
32774 int res2 = 0 ;
32775 PyObject * obj0 = 0 ;
32776 PyObject * obj1 = 0 ;
32777 char * kwnames[] = {
32778 (char *) "self",(char *) "child", NULL
32779 };
32780
32781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDefaultItem",kwnames,&obj0,&obj1)) SWIG_fail;
32782 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32783 if (!SWIG_IsOK(res1)) {
32784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDefaultItem" "', expected argument " "1"" of type '" "wxWindow *""'");
32785 }
32786 arg1 = reinterpret_cast< wxWindow * >(argp1);
32787 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32788 if (!SWIG_IsOK(res2)) {
32789 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDefaultItem" "', expected argument " "2"" of type '" "wxWindow *""'");
32790 }
32791 arg2 = reinterpret_cast< wxWindow * >(argp2);
32792 {
32793 PyThreadState* __tstate = wxPyBeginAllowThreads();
32794 result = (wxWindow *)(arg1)->SetDefaultItem(arg2);
32795 wxPyEndAllowThreads(__tstate);
32796 if (PyErr_Occurred()) SWIG_fail;
32797 }
32798 {
32799 resultobj = wxPyMake_wxObject(result, 0);
32800 }
32801 return resultobj;
32802 fail:
32803 return NULL;
32804 }
32805
32806
32807 SWIGINTERN PyObject *_wrap_Window_SetTmpDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32808 PyObject *resultobj = 0;
32809 wxWindow *arg1 = (wxWindow *) 0 ;
32810 wxWindow *arg2 = (wxWindow *) 0 ;
32811 void *argp1 = 0 ;
32812 int res1 = 0 ;
32813 void *argp2 = 0 ;
32814 int res2 = 0 ;
32815 PyObject * obj0 = 0 ;
32816 PyObject * obj1 = 0 ;
32817 char * kwnames[] = {
32818 (char *) "self",(char *) "win", NULL
32819 };
32820
32821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTmpDefaultItem",kwnames,&obj0,&obj1)) SWIG_fail;
32822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32823 if (!SWIG_IsOK(res1)) {
32824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTmpDefaultItem" "', expected argument " "1"" of type '" "wxWindow *""'");
32825 }
32826 arg1 = reinterpret_cast< wxWindow * >(argp1);
32827 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32828 if (!SWIG_IsOK(res2)) {
32829 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetTmpDefaultItem" "', expected argument " "2"" of type '" "wxWindow *""'");
32830 }
32831 arg2 = reinterpret_cast< wxWindow * >(argp2);
32832 {
32833 PyThreadState* __tstate = wxPyBeginAllowThreads();
32834 (arg1)->SetTmpDefaultItem(arg2);
32835 wxPyEndAllowThreads(__tstate);
32836 if (PyErr_Occurred()) SWIG_fail;
32837 }
32838 resultobj = SWIG_Py_Void();
32839 return resultobj;
32840 fail:
32841 return NULL;
32842 }
32843
32844
32845 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32846 PyObject *resultobj = 0;
32847 wxWindow *arg1 = (wxWindow *) 0 ;
32848 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
32849 bool result;
32850 void *argp1 = 0 ;
32851 int res1 = 0 ;
32852 int val2 ;
32853 int ecode2 = 0 ;
32854 PyObject * obj0 = 0 ;
32855 PyObject * obj1 = 0 ;
32856 char * kwnames[] = {
32857 (char *) "self",(char *) "flags", NULL
32858 };
32859
32860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
32861 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32862 if (!SWIG_IsOK(res1)) {
32863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
32864 }
32865 arg1 = reinterpret_cast< wxWindow * >(argp1);
32866 if (obj1) {
32867 ecode2 = SWIG_AsVal_int(obj1, &val2);
32868 if (!SWIG_IsOK(ecode2)) {
32869 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
32870 }
32871 arg2 = static_cast< int >(val2);
32872 }
32873 {
32874 PyThreadState* __tstate = wxPyBeginAllowThreads();
32875 result = (bool)(arg1)->Navigate(arg2);
32876 wxPyEndAllowThreads(__tstate);
32877 if (PyErr_Occurred()) SWIG_fail;
32878 }
32879 {
32880 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32881 }
32882 return resultobj;
32883 fail:
32884 return NULL;
32885 }
32886
32887
32888 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32889 PyObject *resultobj = 0;
32890 wxWindow *arg1 = (wxWindow *) 0 ;
32891 wxWindow *arg2 = (wxWindow *) 0 ;
32892 void *argp1 = 0 ;
32893 int res1 = 0 ;
32894 void *argp2 = 0 ;
32895 int res2 = 0 ;
32896 PyObject * obj0 = 0 ;
32897 PyObject * obj1 = 0 ;
32898 char * kwnames[] = {
32899 (char *) "self",(char *) "win", NULL
32900 };
32901
32902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
32903 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32904 if (!SWIG_IsOK(res1)) {
32905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
32906 }
32907 arg1 = reinterpret_cast< wxWindow * >(argp1);
32908 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32909 if (!SWIG_IsOK(res2)) {
32910 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
32911 }
32912 arg2 = reinterpret_cast< wxWindow * >(argp2);
32913 {
32914 PyThreadState* __tstate = wxPyBeginAllowThreads();
32915 (arg1)->MoveAfterInTabOrder(arg2);
32916 wxPyEndAllowThreads(__tstate);
32917 if (PyErr_Occurred()) SWIG_fail;
32918 }
32919 resultobj = SWIG_Py_Void();
32920 return resultobj;
32921 fail:
32922 return NULL;
32923 }
32924
32925
32926 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32927 PyObject *resultobj = 0;
32928 wxWindow *arg1 = (wxWindow *) 0 ;
32929 wxWindow *arg2 = (wxWindow *) 0 ;
32930 void *argp1 = 0 ;
32931 int res1 = 0 ;
32932 void *argp2 = 0 ;
32933 int res2 = 0 ;
32934 PyObject * obj0 = 0 ;
32935 PyObject * obj1 = 0 ;
32936 char * kwnames[] = {
32937 (char *) "self",(char *) "win", NULL
32938 };
32939
32940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
32941 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32942 if (!SWIG_IsOK(res1)) {
32943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
32944 }
32945 arg1 = reinterpret_cast< wxWindow * >(argp1);
32946 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32947 if (!SWIG_IsOK(res2)) {
32948 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
32949 }
32950 arg2 = reinterpret_cast< wxWindow * >(argp2);
32951 {
32952 PyThreadState* __tstate = wxPyBeginAllowThreads();
32953 (arg1)->MoveBeforeInTabOrder(arg2);
32954 wxPyEndAllowThreads(__tstate);
32955 if (PyErr_Occurred()) SWIG_fail;
32956 }
32957 resultobj = SWIG_Py_Void();
32958 return resultobj;
32959 fail:
32960 return NULL;
32961 }
32962
32963
32964 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32965 PyObject *resultobj = 0;
32966 wxWindow *arg1 = (wxWindow *) 0 ;
32967 PyObject *result = 0 ;
32968 void *argp1 = 0 ;
32969 int res1 = 0 ;
32970 PyObject *swig_obj[1] ;
32971
32972 if (!args) SWIG_fail;
32973 swig_obj[0] = args;
32974 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32975 if (!SWIG_IsOK(res1)) {
32976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
32977 }
32978 arg1 = reinterpret_cast< wxWindow * >(argp1);
32979 {
32980 PyThreadState* __tstate = wxPyBeginAllowThreads();
32981 result = (PyObject *)wxWindow_GetChildren(arg1);
32982 wxPyEndAllowThreads(__tstate);
32983 if (PyErr_Occurred()) SWIG_fail;
32984 }
32985 resultobj = result;
32986 return resultobj;
32987 fail:
32988 return NULL;
32989 }
32990
32991
32992 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32993 PyObject *resultobj = 0;
32994 wxWindow *arg1 = (wxWindow *) 0 ;
32995 wxWindow *result = 0 ;
32996 void *argp1 = 0 ;
32997 int res1 = 0 ;
32998 PyObject *swig_obj[1] ;
32999
33000 if (!args) SWIG_fail;
33001 swig_obj[0] = args;
33002 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33003 if (!SWIG_IsOK(res1)) {
33004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
33005 }
33006 arg1 = reinterpret_cast< wxWindow * >(argp1);
33007 {
33008 PyThreadState* __tstate = wxPyBeginAllowThreads();
33009 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
33010 wxPyEndAllowThreads(__tstate);
33011 if (PyErr_Occurred()) SWIG_fail;
33012 }
33013 {
33014 resultobj = wxPyMake_wxObject(result, 0);
33015 }
33016 return resultobj;
33017 fail:
33018 return NULL;
33019 }
33020
33021
33022 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33023 PyObject *resultobj = 0;
33024 wxWindow *arg1 = (wxWindow *) 0 ;
33025 wxWindow *result = 0 ;
33026 void *argp1 = 0 ;
33027 int res1 = 0 ;
33028 PyObject *swig_obj[1] ;
33029
33030 if (!args) SWIG_fail;
33031 swig_obj[0] = args;
33032 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33033 if (!SWIG_IsOK(res1)) {
33034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
33035 }
33036 arg1 = reinterpret_cast< wxWindow * >(argp1);
33037 {
33038 PyThreadState* __tstate = wxPyBeginAllowThreads();
33039 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
33040 wxPyEndAllowThreads(__tstate);
33041 if (PyErr_Occurred()) SWIG_fail;
33042 }
33043 {
33044 resultobj = wxPyMake_wxObject(result, 0);
33045 }
33046 return resultobj;
33047 fail:
33048 return NULL;
33049 }
33050
33051
33052 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33053 PyObject *resultobj = 0;
33054 wxWindow *arg1 = (wxWindow *) 0 ;
33055 bool result;
33056 void *argp1 = 0 ;
33057 int res1 = 0 ;
33058 PyObject *swig_obj[1] ;
33059
33060 if (!args) SWIG_fail;
33061 swig_obj[0] = args;
33062 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33063 if (!SWIG_IsOK(res1)) {
33064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
33065 }
33066 arg1 = reinterpret_cast< wxWindow * >(argp1);
33067 {
33068 PyThreadState* __tstate = wxPyBeginAllowThreads();
33069 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
33070 wxPyEndAllowThreads(__tstate);
33071 if (PyErr_Occurred()) SWIG_fail;
33072 }
33073 {
33074 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33075 }
33076 return resultobj;
33077 fail:
33078 return NULL;
33079 }
33080
33081
33082 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33083 PyObject *resultobj = 0;
33084 wxWindow *arg1 = (wxWindow *) 0 ;
33085 wxWindow *arg2 = (wxWindow *) 0 ;
33086 bool result;
33087 void *argp1 = 0 ;
33088 int res1 = 0 ;
33089 void *argp2 = 0 ;
33090 int res2 = 0 ;
33091 PyObject * obj0 = 0 ;
33092 PyObject * obj1 = 0 ;
33093 char * kwnames[] = {
33094 (char *) "self",(char *) "newParent", NULL
33095 };
33096
33097 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
33098 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33099 if (!SWIG_IsOK(res1)) {
33100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
33101 }
33102 arg1 = reinterpret_cast< wxWindow * >(argp1);
33103 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33104 if (!SWIG_IsOK(res2)) {
33105 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
33106 }
33107 arg2 = reinterpret_cast< wxWindow * >(argp2);
33108 {
33109 PyThreadState* __tstate = wxPyBeginAllowThreads();
33110 result = (bool)(arg1)->Reparent(arg2);
33111 wxPyEndAllowThreads(__tstate);
33112 if (PyErr_Occurred()) SWIG_fail;
33113 }
33114 {
33115 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33116 }
33117 return resultobj;
33118 fail:
33119 return NULL;
33120 }
33121
33122
33123 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33124 PyObject *resultobj = 0;
33125 wxWindow *arg1 = (wxWindow *) 0 ;
33126 wxWindow *arg2 = (wxWindow *) 0 ;
33127 void *argp1 = 0 ;
33128 int res1 = 0 ;
33129 void *argp2 = 0 ;
33130 int res2 = 0 ;
33131 PyObject * obj0 = 0 ;
33132 PyObject * obj1 = 0 ;
33133 char * kwnames[] = {
33134 (char *) "self",(char *) "child", NULL
33135 };
33136
33137 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
33138 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33139 if (!SWIG_IsOK(res1)) {
33140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33141 }
33142 arg1 = reinterpret_cast< wxWindow * >(argp1);
33143 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33144 if (!SWIG_IsOK(res2)) {
33145 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33146 }
33147 arg2 = reinterpret_cast< wxWindow * >(argp2);
33148 {
33149 PyThreadState* __tstate = wxPyBeginAllowThreads();
33150 (arg1)->AddChild(arg2);
33151 wxPyEndAllowThreads(__tstate);
33152 if (PyErr_Occurred()) SWIG_fail;
33153 }
33154 resultobj = SWIG_Py_Void();
33155 return resultobj;
33156 fail:
33157 return NULL;
33158 }
33159
33160
33161 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33162 PyObject *resultobj = 0;
33163 wxWindow *arg1 = (wxWindow *) 0 ;
33164 wxWindow *arg2 = (wxWindow *) 0 ;
33165 void *argp1 = 0 ;
33166 int res1 = 0 ;
33167 void *argp2 = 0 ;
33168 int res2 = 0 ;
33169 PyObject * obj0 = 0 ;
33170 PyObject * obj1 = 0 ;
33171 char * kwnames[] = {
33172 (char *) "self",(char *) "child", NULL
33173 };
33174
33175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
33176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33177 if (!SWIG_IsOK(res1)) {
33178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33179 }
33180 arg1 = reinterpret_cast< wxWindow * >(argp1);
33181 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33182 if (!SWIG_IsOK(res2)) {
33183 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33184 }
33185 arg2 = reinterpret_cast< wxWindow * >(argp2);
33186 {
33187 PyThreadState* __tstate = wxPyBeginAllowThreads();
33188 (arg1)->RemoveChild(arg2);
33189 wxPyEndAllowThreads(__tstate);
33190 if (PyErr_Occurred()) SWIG_fail;
33191 }
33192 resultobj = SWIG_Py_Void();
33193 return resultobj;
33194 fail:
33195 return NULL;
33196 }
33197
33198
33199 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33200 PyObject *resultobj = 0;
33201 wxWindow *arg1 = (wxWindow *) 0 ;
33202 long arg2 ;
33203 wxWindow *result = 0 ;
33204 void *argp1 = 0 ;
33205 int res1 = 0 ;
33206 long val2 ;
33207 int ecode2 = 0 ;
33208 PyObject * obj0 = 0 ;
33209 PyObject * obj1 = 0 ;
33210 char * kwnames[] = {
33211 (char *) "self",(char *) "winid", NULL
33212 };
33213
33214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
33215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33216 if (!SWIG_IsOK(res1)) {
33217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
33218 }
33219 arg1 = reinterpret_cast< wxWindow * >(argp1);
33220 ecode2 = SWIG_AsVal_long(obj1, &val2);
33221 if (!SWIG_IsOK(ecode2)) {
33222 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
33223 }
33224 arg2 = static_cast< long >(val2);
33225 {
33226 PyThreadState* __tstate = wxPyBeginAllowThreads();
33227 result = (wxWindow *)(arg1)->FindWindow(arg2);
33228 wxPyEndAllowThreads(__tstate);
33229 if (PyErr_Occurred()) SWIG_fail;
33230 }
33231 {
33232 resultobj = wxPyMake_wxObject(result, 0);
33233 }
33234 return resultobj;
33235 fail:
33236 return NULL;
33237 }
33238
33239
33240 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33241 PyObject *resultobj = 0;
33242 wxWindow *arg1 = (wxWindow *) 0 ;
33243 wxString *arg2 = 0 ;
33244 wxWindow *result = 0 ;
33245 void *argp1 = 0 ;
33246 int res1 = 0 ;
33247 bool temp2 = false ;
33248 PyObject * obj0 = 0 ;
33249 PyObject * obj1 = 0 ;
33250 char * kwnames[] = {
33251 (char *) "self",(char *) "name", NULL
33252 };
33253
33254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
33255 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33256 if (!SWIG_IsOK(res1)) {
33257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
33258 }
33259 arg1 = reinterpret_cast< wxWindow * >(argp1);
33260 {
33261 arg2 = wxString_in_helper(obj1);
33262 if (arg2 == NULL) SWIG_fail;
33263 temp2 = true;
33264 }
33265 {
33266 PyThreadState* __tstate = wxPyBeginAllowThreads();
33267 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
33268 wxPyEndAllowThreads(__tstate);
33269 if (PyErr_Occurred()) SWIG_fail;
33270 }
33271 {
33272 resultobj = wxPyMake_wxObject(result, 0);
33273 }
33274 {
33275 if (temp2)
33276 delete arg2;
33277 }
33278 return resultobj;
33279 fail:
33280 {
33281 if (temp2)
33282 delete arg2;
33283 }
33284 return NULL;
33285 }
33286
33287
33288 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33289 PyObject *resultobj = 0;
33290 wxWindow *arg1 = (wxWindow *) 0 ;
33291 wxEvtHandler *result = 0 ;
33292 void *argp1 = 0 ;
33293 int res1 = 0 ;
33294 PyObject *swig_obj[1] ;
33295
33296 if (!args) SWIG_fail;
33297 swig_obj[0] = args;
33298 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33299 if (!SWIG_IsOK(res1)) {
33300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
33301 }
33302 arg1 = reinterpret_cast< wxWindow * >(argp1);
33303 {
33304 PyThreadState* __tstate = wxPyBeginAllowThreads();
33305 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
33306 wxPyEndAllowThreads(__tstate);
33307 if (PyErr_Occurred()) SWIG_fail;
33308 }
33309 {
33310 resultobj = wxPyMake_wxObject(result, 0);
33311 }
33312 return resultobj;
33313 fail:
33314 return NULL;
33315 }
33316
33317
33318 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33319 PyObject *resultobj = 0;
33320 wxWindow *arg1 = (wxWindow *) 0 ;
33321 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33322 void *argp1 = 0 ;
33323 int res1 = 0 ;
33324 void *argp2 = 0 ;
33325 int res2 = 0 ;
33326 PyObject * obj0 = 0 ;
33327 PyObject * obj1 = 0 ;
33328 char * kwnames[] = {
33329 (char *) "self",(char *) "handler", NULL
33330 };
33331
33332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33333 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33334 if (!SWIG_IsOK(res1)) {
33335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33336 }
33337 arg1 = reinterpret_cast< wxWindow * >(argp1);
33338 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33339 if (!SWIG_IsOK(res2)) {
33340 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33341 }
33342 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33343 {
33344 PyThreadState* __tstate = wxPyBeginAllowThreads();
33345 (arg1)->SetEventHandler(arg2);
33346 wxPyEndAllowThreads(__tstate);
33347 if (PyErr_Occurred()) SWIG_fail;
33348 }
33349 resultobj = SWIG_Py_Void();
33350 return resultobj;
33351 fail:
33352 return NULL;
33353 }
33354
33355
33356 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33357 PyObject *resultobj = 0;
33358 wxWindow *arg1 = (wxWindow *) 0 ;
33359 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33360 void *argp1 = 0 ;
33361 int res1 = 0 ;
33362 void *argp2 = 0 ;
33363 int res2 = 0 ;
33364 PyObject * obj0 = 0 ;
33365 PyObject * obj1 = 0 ;
33366 char * kwnames[] = {
33367 (char *) "self",(char *) "handler", NULL
33368 };
33369
33370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33371 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33372 if (!SWIG_IsOK(res1)) {
33373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33374 }
33375 arg1 = reinterpret_cast< wxWindow * >(argp1);
33376 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33377 if (!SWIG_IsOK(res2)) {
33378 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33379 }
33380 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33381 {
33382 PyThreadState* __tstate = wxPyBeginAllowThreads();
33383 (arg1)->PushEventHandler(arg2);
33384 wxPyEndAllowThreads(__tstate);
33385 if (PyErr_Occurred()) SWIG_fail;
33386 }
33387 resultobj = SWIG_Py_Void();
33388 return resultobj;
33389 fail:
33390 return NULL;
33391 }
33392
33393
33394 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33395 PyObject *resultobj = 0;
33396 wxWindow *arg1 = (wxWindow *) 0 ;
33397 bool arg2 = (bool) false ;
33398 wxEvtHandler *result = 0 ;
33399 void *argp1 = 0 ;
33400 int res1 = 0 ;
33401 bool val2 ;
33402 int ecode2 = 0 ;
33403 PyObject * obj0 = 0 ;
33404 PyObject * obj1 = 0 ;
33405 char * kwnames[] = {
33406 (char *) "self",(char *) "deleteHandler", NULL
33407 };
33408
33409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33410 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33411 if (!SWIG_IsOK(res1)) {
33412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33413 }
33414 arg1 = reinterpret_cast< wxWindow * >(argp1);
33415 if (obj1) {
33416 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33417 if (!SWIG_IsOK(ecode2)) {
33418 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
33419 }
33420 arg2 = static_cast< bool >(val2);
33421 }
33422 {
33423 PyThreadState* __tstate = wxPyBeginAllowThreads();
33424 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
33425 wxPyEndAllowThreads(__tstate);
33426 if (PyErr_Occurred()) SWIG_fail;
33427 }
33428 {
33429 resultobj = wxPyMake_wxObject(result, 0);
33430 }
33431 return resultobj;
33432 fail:
33433 return NULL;
33434 }
33435
33436
33437 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33438 PyObject *resultobj = 0;
33439 wxWindow *arg1 = (wxWindow *) 0 ;
33440 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33441 bool result;
33442 void *argp1 = 0 ;
33443 int res1 = 0 ;
33444 void *argp2 = 0 ;
33445 int res2 = 0 ;
33446 PyObject * obj0 = 0 ;
33447 PyObject * obj1 = 0 ;
33448 char * kwnames[] = {
33449 (char *) "self",(char *) "handler", NULL
33450 };
33451
33452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33453 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33454 if (!SWIG_IsOK(res1)) {
33455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33456 }
33457 arg1 = reinterpret_cast< wxWindow * >(argp1);
33458 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33459 if (!SWIG_IsOK(res2)) {
33460 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33461 }
33462 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33463 {
33464 PyThreadState* __tstate = wxPyBeginAllowThreads();
33465 result = (bool)(arg1)->RemoveEventHandler(arg2);
33466 wxPyEndAllowThreads(__tstate);
33467 if (PyErr_Occurred()) SWIG_fail;
33468 }
33469 {
33470 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33471 }
33472 return resultobj;
33473 fail:
33474 return NULL;
33475 }
33476
33477
33478 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33479 PyObject *resultobj = 0;
33480 wxWindow *arg1 = (wxWindow *) 0 ;
33481 wxValidator *arg2 = 0 ;
33482 void *argp1 = 0 ;
33483 int res1 = 0 ;
33484 void *argp2 = 0 ;
33485 int res2 = 0 ;
33486 PyObject * obj0 = 0 ;
33487 PyObject * obj1 = 0 ;
33488 char * kwnames[] = {
33489 (char *) "self",(char *) "validator", NULL
33490 };
33491
33492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
33493 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33494 if (!SWIG_IsOK(res1)) {
33495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33496 }
33497 arg1 = reinterpret_cast< wxWindow * >(argp1);
33498 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
33499 if (!SWIG_IsOK(res2)) {
33500 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33501 }
33502 if (!argp2) {
33503 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33504 }
33505 arg2 = reinterpret_cast< wxValidator * >(argp2);
33506 {
33507 PyThreadState* __tstate = wxPyBeginAllowThreads();
33508 (arg1)->SetValidator((wxValidator const &)*arg2);
33509 wxPyEndAllowThreads(__tstate);
33510 if (PyErr_Occurred()) SWIG_fail;
33511 }
33512 resultobj = SWIG_Py_Void();
33513 return resultobj;
33514 fail:
33515 return NULL;
33516 }
33517
33518
33519 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33520 PyObject *resultobj = 0;
33521 wxWindow *arg1 = (wxWindow *) 0 ;
33522 wxValidator *result = 0 ;
33523 void *argp1 = 0 ;
33524 int res1 = 0 ;
33525 PyObject *swig_obj[1] ;
33526
33527 if (!args) SWIG_fail;
33528 swig_obj[0] = args;
33529 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33530 if (!SWIG_IsOK(res1)) {
33531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33532 }
33533 arg1 = reinterpret_cast< wxWindow * >(argp1);
33534 {
33535 PyThreadState* __tstate = wxPyBeginAllowThreads();
33536 result = (wxValidator *)(arg1)->GetValidator();
33537 wxPyEndAllowThreads(__tstate);
33538 if (PyErr_Occurred()) SWIG_fail;
33539 }
33540 {
33541 resultobj = wxPyMake_wxObject(result, (bool)0);
33542 }
33543 return resultobj;
33544 fail:
33545 return NULL;
33546 }
33547
33548
33549 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33550 PyObject *resultobj = 0;
33551 wxWindow *arg1 = (wxWindow *) 0 ;
33552 bool result;
33553 void *argp1 = 0 ;
33554 int res1 = 0 ;
33555 PyObject *swig_obj[1] ;
33556
33557 if (!args) SWIG_fail;
33558 swig_obj[0] = args;
33559 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33560 if (!SWIG_IsOK(res1)) {
33561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
33562 }
33563 arg1 = reinterpret_cast< wxWindow * >(argp1);
33564 {
33565 PyThreadState* __tstate = wxPyBeginAllowThreads();
33566 result = (bool)(arg1)->Validate();
33567 wxPyEndAllowThreads(__tstate);
33568 if (PyErr_Occurred()) SWIG_fail;
33569 }
33570 {
33571 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33572 }
33573 return resultobj;
33574 fail:
33575 return NULL;
33576 }
33577
33578
33579 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33580 PyObject *resultobj = 0;
33581 wxWindow *arg1 = (wxWindow *) 0 ;
33582 bool result;
33583 void *argp1 = 0 ;
33584 int res1 = 0 ;
33585 PyObject *swig_obj[1] ;
33586
33587 if (!args) SWIG_fail;
33588 swig_obj[0] = args;
33589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33590 if (!SWIG_IsOK(res1)) {
33591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33592 }
33593 arg1 = reinterpret_cast< wxWindow * >(argp1);
33594 {
33595 PyThreadState* __tstate = wxPyBeginAllowThreads();
33596 result = (bool)(arg1)->TransferDataToWindow();
33597 wxPyEndAllowThreads(__tstate);
33598 if (PyErr_Occurred()) SWIG_fail;
33599 }
33600 {
33601 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33602 }
33603 return resultobj;
33604 fail:
33605 return NULL;
33606 }
33607
33608
33609 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33610 PyObject *resultobj = 0;
33611 wxWindow *arg1 = (wxWindow *) 0 ;
33612 bool result;
33613 void *argp1 = 0 ;
33614 int res1 = 0 ;
33615 PyObject *swig_obj[1] ;
33616
33617 if (!args) SWIG_fail;
33618 swig_obj[0] = args;
33619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33620 if (!SWIG_IsOK(res1)) {
33621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33622 }
33623 arg1 = reinterpret_cast< wxWindow * >(argp1);
33624 {
33625 PyThreadState* __tstate = wxPyBeginAllowThreads();
33626 result = (bool)(arg1)->TransferDataFromWindow();
33627 wxPyEndAllowThreads(__tstate);
33628 if (PyErr_Occurred()) SWIG_fail;
33629 }
33630 {
33631 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33632 }
33633 return resultobj;
33634 fail:
33635 return NULL;
33636 }
33637
33638
33639 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33640 PyObject *resultobj = 0;
33641 wxWindow *arg1 = (wxWindow *) 0 ;
33642 void *argp1 = 0 ;
33643 int res1 = 0 ;
33644 PyObject *swig_obj[1] ;
33645
33646 if (!args) SWIG_fail;
33647 swig_obj[0] = args;
33648 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33649 if (!SWIG_IsOK(res1)) {
33650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
33651 }
33652 arg1 = reinterpret_cast< wxWindow * >(argp1);
33653 {
33654 PyThreadState* __tstate = wxPyBeginAllowThreads();
33655 (arg1)->InitDialog();
33656 wxPyEndAllowThreads(__tstate);
33657 if (PyErr_Occurred()) SWIG_fail;
33658 }
33659 resultobj = SWIG_Py_Void();
33660 return resultobj;
33661 fail:
33662 return NULL;
33663 }
33664
33665
33666 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33667 PyObject *resultobj = 0;
33668 wxWindow *arg1 = (wxWindow *) 0 ;
33669 wxAcceleratorTable *arg2 = 0 ;
33670 void *argp1 = 0 ;
33671 int res1 = 0 ;
33672 void *argp2 = 0 ;
33673 int res2 = 0 ;
33674 PyObject * obj0 = 0 ;
33675 PyObject * obj1 = 0 ;
33676 char * kwnames[] = {
33677 (char *) "self",(char *) "accel", NULL
33678 };
33679
33680 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
33681 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33682 if (!SWIG_IsOK(res1)) {
33683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33684 }
33685 arg1 = reinterpret_cast< wxWindow * >(argp1);
33686 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
33687 if (!SWIG_IsOK(res2)) {
33688 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33689 }
33690 if (!argp2) {
33691 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33692 }
33693 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
33694 {
33695 PyThreadState* __tstate = wxPyBeginAllowThreads();
33696 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
33697 wxPyEndAllowThreads(__tstate);
33698 if (PyErr_Occurred()) SWIG_fail;
33699 }
33700 resultobj = SWIG_Py_Void();
33701 return resultobj;
33702 fail:
33703 return NULL;
33704 }
33705
33706
33707 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33708 PyObject *resultobj = 0;
33709 wxWindow *arg1 = (wxWindow *) 0 ;
33710 wxAcceleratorTable *result = 0 ;
33711 void *argp1 = 0 ;
33712 int res1 = 0 ;
33713 PyObject *swig_obj[1] ;
33714
33715 if (!args) SWIG_fail;
33716 swig_obj[0] = args;
33717 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33718 if (!SWIG_IsOK(res1)) {
33719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33720 }
33721 arg1 = reinterpret_cast< wxWindow * >(argp1);
33722 {
33723 PyThreadState* __tstate = wxPyBeginAllowThreads();
33724 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
33725 wxPyEndAllowThreads(__tstate);
33726 if (PyErr_Occurred()) SWIG_fail;
33727 }
33728 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
33729 return resultobj;
33730 fail:
33731 return NULL;
33732 }
33733
33734
33735 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33736 PyObject *resultobj = 0;
33737 wxWindow *arg1 = (wxWindow *) 0 ;
33738 int arg2 ;
33739 int arg3 ;
33740 int arg4 ;
33741 bool result;
33742 void *argp1 = 0 ;
33743 int res1 = 0 ;
33744 int val2 ;
33745 int ecode2 = 0 ;
33746 int val3 ;
33747 int ecode3 = 0 ;
33748 int val4 ;
33749 int ecode4 = 0 ;
33750 PyObject * obj0 = 0 ;
33751 PyObject * obj1 = 0 ;
33752 PyObject * obj2 = 0 ;
33753 PyObject * obj3 = 0 ;
33754 char * kwnames[] = {
33755 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
33756 };
33757
33758 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33759 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33760 if (!SWIG_IsOK(res1)) {
33761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
33762 }
33763 arg1 = reinterpret_cast< wxWindow * >(argp1);
33764 ecode2 = SWIG_AsVal_int(obj1, &val2);
33765 if (!SWIG_IsOK(ecode2)) {
33766 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
33767 }
33768 arg2 = static_cast< int >(val2);
33769 ecode3 = SWIG_AsVal_int(obj2, &val3);
33770 if (!SWIG_IsOK(ecode3)) {
33771 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
33772 }
33773 arg3 = static_cast< int >(val3);
33774 ecode4 = SWIG_AsVal_int(obj3, &val4);
33775 if (!SWIG_IsOK(ecode4)) {
33776 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
33777 }
33778 arg4 = static_cast< int >(val4);
33779 {
33780 PyThreadState* __tstate = wxPyBeginAllowThreads();
33781 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
33782 wxPyEndAllowThreads(__tstate);
33783 if (PyErr_Occurred()) SWIG_fail;
33784 }
33785 {
33786 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33787 }
33788 return resultobj;
33789 fail:
33790 return NULL;
33791 }
33792
33793
33794 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33795 PyObject *resultobj = 0;
33796 wxWindow *arg1 = (wxWindow *) 0 ;
33797 int arg2 ;
33798 bool result;
33799 void *argp1 = 0 ;
33800 int res1 = 0 ;
33801 int val2 ;
33802 int ecode2 = 0 ;
33803 PyObject * obj0 = 0 ;
33804 PyObject * obj1 = 0 ;
33805 char * kwnames[] = {
33806 (char *) "self",(char *) "hotkeyId", NULL
33807 };
33808
33809 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
33810 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33811 if (!SWIG_IsOK(res1)) {
33812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
33813 }
33814 arg1 = reinterpret_cast< wxWindow * >(argp1);
33815 ecode2 = SWIG_AsVal_int(obj1, &val2);
33816 if (!SWIG_IsOK(ecode2)) {
33817 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
33818 }
33819 arg2 = static_cast< int >(val2);
33820 {
33821 PyThreadState* __tstate = wxPyBeginAllowThreads();
33822 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
33823 wxPyEndAllowThreads(__tstate);
33824 if (PyErr_Occurred()) SWIG_fail;
33825 }
33826 {
33827 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33828 }
33829 return resultobj;
33830 fail:
33831 return NULL;
33832 }
33833
33834
33835 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33836 PyObject *resultobj = 0;
33837 wxWindow *arg1 = (wxWindow *) 0 ;
33838 wxPoint *arg2 = 0 ;
33839 wxPoint result;
33840 void *argp1 = 0 ;
33841 int res1 = 0 ;
33842 wxPoint temp2 ;
33843 PyObject * obj0 = 0 ;
33844 PyObject * obj1 = 0 ;
33845 char * kwnames[] = {
33846 (char *) "self",(char *) "pt", NULL
33847 };
33848
33849 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
33850 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33851 if (!SWIG_IsOK(res1)) {
33852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
33853 }
33854 arg1 = reinterpret_cast< wxWindow * >(argp1);
33855 {
33856 arg2 = &temp2;
33857 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33858 }
33859 {
33860 PyThreadState* __tstate = wxPyBeginAllowThreads();
33861 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
33862 wxPyEndAllowThreads(__tstate);
33863 if (PyErr_Occurred()) SWIG_fail;
33864 }
33865 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
33866 return resultobj;
33867 fail:
33868 return NULL;
33869 }
33870
33871
33872 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33873 PyObject *resultobj = 0;
33874 wxWindow *arg1 = (wxWindow *) 0 ;
33875 wxSize *arg2 = 0 ;
33876 wxSize result;
33877 void *argp1 = 0 ;
33878 int res1 = 0 ;
33879 wxSize temp2 ;
33880 PyObject * obj0 = 0 ;
33881 PyObject * obj1 = 0 ;
33882 char * kwnames[] = {
33883 (char *) "self",(char *) "sz", NULL
33884 };
33885
33886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
33887 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33888 if (!SWIG_IsOK(res1)) {
33889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
33890 }
33891 arg1 = reinterpret_cast< wxWindow * >(argp1);
33892 {
33893 arg2 = &temp2;
33894 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33895 }
33896 {
33897 PyThreadState* __tstate = wxPyBeginAllowThreads();
33898 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
33899 wxPyEndAllowThreads(__tstate);
33900 if (PyErr_Occurred()) SWIG_fail;
33901 }
33902 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33903 return resultobj;
33904 fail:
33905 return NULL;
33906 }
33907
33908
33909 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33910 PyObject *resultobj = 0;
33911 wxWindow *arg1 = (wxWindow *) 0 ;
33912 wxPoint *arg2 = 0 ;
33913 wxPoint result;
33914 void *argp1 = 0 ;
33915 int res1 = 0 ;
33916 wxPoint temp2 ;
33917 PyObject * obj0 = 0 ;
33918 PyObject * obj1 = 0 ;
33919 char * kwnames[] = {
33920 (char *) "self",(char *) "pt", NULL
33921 };
33922
33923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
33924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33925 if (!SWIG_IsOK(res1)) {
33926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
33927 }
33928 arg1 = reinterpret_cast< wxWindow * >(argp1);
33929 {
33930 arg2 = &temp2;
33931 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33932 }
33933 {
33934 PyThreadState* __tstate = wxPyBeginAllowThreads();
33935 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
33936 wxPyEndAllowThreads(__tstate);
33937 if (PyErr_Occurred()) SWIG_fail;
33938 }
33939 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
33940 return resultobj;
33941 fail:
33942 return NULL;
33943 }
33944
33945
33946 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33947 PyObject *resultobj = 0;
33948 wxWindow *arg1 = (wxWindow *) 0 ;
33949 wxSize *arg2 = 0 ;
33950 wxSize result;
33951 void *argp1 = 0 ;
33952 int res1 = 0 ;
33953 wxSize temp2 ;
33954 PyObject * obj0 = 0 ;
33955 PyObject * obj1 = 0 ;
33956 char * kwnames[] = {
33957 (char *) "self",(char *) "sz", NULL
33958 };
33959
33960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
33961 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33962 if (!SWIG_IsOK(res1)) {
33963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
33964 }
33965 arg1 = reinterpret_cast< wxWindow * >(argp1);
33966 {
33967 arg2 = &temp2;
33968 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33969 }
33970 {
33971 PyThreadState* __tstate = wxPyBeginAllowThreads();
33972 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
33973 wxPyEndAllowThreads(__tstate);
33974 if (PyErr_Occurred()) SWIG_fail;
33975 }
33976 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33977 return resultobj;
33978 fail:
33979 return NULL;
33980 }
33981
33982
33983 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33984 PyObject *resultobj = 0;
33985 wxWindow *arg1 = (wxWindow *) 0 ;
33986 wxPoint *arg2 = 0 ;
33987 wxPoint result;
33988 void *argp1 = 0 ;
33989 int res1 = 0 ;
33990 wxPoint temp2 ;
33991 PyObject * obj0 = 0 ;
33992 PyObject * obj1 = 0 ;
33993 char * kwnames[] = {
33994 (char *) "self",(char *) "pt", NULL
33995 };
33996
33997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
33998 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33999 if (!SWIG_IsOK(res1)) {
34000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34001 }
34002 arg1 = reinterpret_cast< wxWindow * >(argp1);
34003 {
34004 arg2 = &temp2;
34005 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34006 }
34007 {
34008 PyThreadState* __tstate = wxPyBeginAllowThreads();
34009 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
34010 wxPyEndAllowThreads(__tstate);
34011 if (PyErr_Occurred()) SWIG_fail;
34012 }
34013 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34014 return resultobj;
34015 fail:
34016 return NULL;
34017 }
34018
34019
34020 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34021 PyObject *resultobj = 0;
34022 wxWindow *arg1 = (wxWindow *) 0 ;
34023 wxSize *arg2 = 0 ;
34024 wxSize result;
34025 void *argp1 = 0 ;
34026 int res1 = 0 ;
34027 wxSize temp2 ;
34028 PyObject * obj0 = 0 ;
34029 PyObject * obj1 = 0 ;
34030 char * kwnames[] = {
34031 (char *) "self",(char *) "sz", NULL
34032 };
34033
34034 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
34035 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34036 if (!SWIG_IsOK(res1)) {
34037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34038 }
34039 arg1 = reinterpret_cast< wxWindow * >(argp1);
34040 {
34041 arg2 = &temp2;
34042 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34043 }
34044 {
34045 PyThreadState* __tstate = wxPyBeginAllowThreads();
34046 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
34047 wxPyEndAllowThreads(__tstate);
34048 if (PyErr_Occurred()) SWIG_fail;
34049 }
34050 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34051 return resultobj;
34052 fail:
34053 return NULL;
34054 }
34055
34056
34057 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34058 PyObject *resultobj = 0;
34059 wxWindow *arg1 = (wxWindow *) 0 ;
34060 int arg2 ;
34061 int arg3 ;
34062 void *argp1 = 0 ;
34063 int res1 = 0 ;
34064 int val2 ;
34065 int ecode2 = 0 ;
34066 int val3 ;
34067 int ecode3 = 0 ;
34068 PyObject * obj0 = 0 ;
34069 PyObject * obj1 = 0 ;
34070 PyObject * obj2 = 0 ;
34071 char * kwnames[] = {
34072 (char *) "self",(char *) "x",(char *) "y", NULL
34073 };
34074
34075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34077 if (!SWIG_IsOK(res1)) {
34078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
34079 }
34080 arg1 = reinterpret_cast< wxWindow * >(argp1);
34081 ecode2 = SWIG_AsVal_int(obj1, &val2);
34082 if (!SWIG_IsOK(ecode2)) {
34083 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
34084 }
34085 arg2 = static_cast< int >(val2);
34086 ecode3 = SWIG_AsVal_int(obj2, &val3);
34087 if (!SWIG_IsOK(ecode3)) {
34088 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
34089 }
34090 arg3 = static_cast< int >(val3);
34091 {
34092 PyThreadState* __tstate = wxPyBeginAllowThreads();
34093 (arg1)->WarpPointer(arg2,arg3);
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_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34105 PyObject *resultobj = 0;
34106 wxWindow *arg1 = (wxWindow *) 0 ;
34107 void *argp1 = 0 ;
34108 int res1 = 0 ;
34109 PyObject *swig_obj[1] ;
34110
34111 if (!args) SWIG_fail;
34112 swig_obj[0] = args;
34113 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34114 if (!SWIG_IsOK(res1)) {
34115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34116 }
34117 arg1 = reinterpret_cast< wxWindow * >(argp1);
34118 {
34119 PyThreadState* __tstate = wxPyBeginAllowThreads();
34120 (arg1)->CaptureMouse();
34121 wxPyEndAllowThreads(__tstate);
34122 if (PyErr_Occurred()) SWIG_fail;
34123 }
34124 resultobj = SWIG_Py_Void();
34125 return resultobj;
34126 fail:
34127 return NULL;
34128 }
34129
34130
34131 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34132 PyObject *resultobj = 0;
34133 wxWindow *arg1 = (wxWindow *) 0 ;
34134 void *argp1 = 0 ;
34135 int res1 = 0 ;
34136 PyObject *swig_obj[1] ;
34137
34138 if (!args) SWIG_fail;
34139 swig_obj[0] = args;
34140 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34141 if (!SWIG_IsOK(res1)) {
34142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34143 }
34144 arg1 = reinterpret_cast< wxWindow * >(argp1);
34145 {
34146 PyThreadState* __tstate = wxPyBeginAllowThreads();
34147 (arg1)->ReleaseMouse();
34148 wxPyEndAllowThreads(__tstate);
34149 if (PyErr_Occurred()) SWIG_fail;
34150 }
34151 resultobj = SWIG_Py_Void();
34152 return resultobj;
34153 fail:
34154 return NULL;
34155 }
34156
34157
34158 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34159 PyObject *resultobj = 0;
34160 wxWindow *result = 0 ;
34161
34162 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
34163 {
34164 if (!wxPyCheckForApp()) SWIG_fail;
34165 PyThreadState* __tstate = wxPyBeginAllowThreads();
34166 result = (wxWindow *)wxWindow::GetCapture();
34167 wxPyEndAllowThreads(__tstate);
34168 if (PyErr_Occurred()) SWIG_fail;
34169 }
34170 {
34171 resultobj = wxPyMake_wxObject(result, 0);
34172 }
34173 return resultobj;
34174 fail:
34175 return NULL;
34176 }
34177
34178
34179 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34180 PyObject *resultobj = 0;
34181 wxWindow *arg1 = (wxWindow *) 0 ;
34182 bool result;
34183 void *argp1 = 0 ;
34184 int res1 = 0 ;
34185 PyObject *swig_obj[1] ;
34186
34187 if (!args) SWIG_fail;
34188 swig_obj[0] = args;
34189 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34190 if (!SWIG_IsOK(res1)) {
34191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
34192 }
34193 arg1 = reinterpret_cast< wxWindow * >(argp1);
34194 {
34195 PyThreadState* __tstate = wxPyBeginAllowThreads();
34196 result = (bool)((wxWindow const *)arg1)->HasCapture();
34197 wxPyEndAllowThreads(__tstate);
34198 if (PyErr_Occurred()) SWIG_fail;
34199 }
34200 {
34201 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34202 }
34203 return resultobj;
34204 fail:
34205 return NULL;
34206 }
34207
34208
34209 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34210 PyObject *resultobj = 0;
34211 wxWindow *arg1 = (wxWindow *) 0 ;
34212 bool arg2 = (bool) true ;
34213 wxRect *arg3 = (wxRect *) NULL ;
34214 void *argp1 = 0 ;
34215 int res1 = 0 ;
34216 bool val2 ;
34217 int ecode2 = 0 ;
34218 void *argp3 = 0 ;
34219 int res3 = 0 ;
34220 PyObject * obj0 = 0 ;
34221 PyObject * obj1 = 0 ;
34222 PyObject * obj2 = 0 ;
34223 char * kwnames[] = {
34224 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
34225 };
34226
34227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34228 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34229 if (!SWIG_IsOK(res1)) {
34230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
34231 }
34232 arg1 = reinterpret_cast< wxWindow * >(argp1);
34233 if (obj1) {
34234 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34235 if (!SWIG_IsOK(ecode2)) {
34236 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
34237 }
34238 arg2 = static_cast< bool >(val2);
34239 }
34240 if (obj2) {
34241 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
34242 if (!SWIG_IsOK(res3)) {
34243 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
34244 }
34245 arg3 = reinterpret_cast< wxRect * >(argp3);
34246 }
34247 {
34248 PyThreadState* __tstate = wxPyBeginAllowThreads();
34249 (arg1)->Refresh(arg2,(wxRect const *)arg3);
34250 wxPyEndAllowThreads(__tstate);
34251 if (PyErr_Occurred()) SWIG_fail;
34252 }
34253 resultobj = SWIG_Py_Void();
34254 return resultobj;
34255 fail:
34256 return NULL;
34257 }
34258
34259
34260 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34261 PyObject *resultobj = 0;
34262 wxWindow *arg1 = (wxWindow *) 0 ;
34263 wxRect *arg2 = 0 ;
34264 bool arg3 = (bool) true ;
34265 void *argp1 = 0 ;
34266 int res1 = 0 ;
34267 wxRect temp2 ;
34268 bool val3 ;
34269 int ecode3 = 0 ;
34270 PyObject * obj0 = 0 ;
34271 PyObject * obj1 = 0 ;
34272 PyObject * obj2 = 0 ;
34273 char * kwnames[] = {
34274 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
34275 };
34276
34277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34278 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34279 if (!SWIG_IsOK(res1)) {
34280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34281 }
34282 arg1 = reinterpret_cast< wxWindow * >(argp1);
34283 {
34284 arg2 = &temp2;
34285 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34286 }
34287 if (obj2) {
34288 ecode3 = SWIG_AsVal_bool(obj2, &val3);
34289 if (!SWIG_IsOK(ecode3)) {
34290 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
34291 }
34292 arg3 = static_cast< bool >(val3);
34293 }
34294 {
34295 PyThreadState* __tstate = wxPyBeginAllowThreads();
34296 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
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_Update(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_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
34319 }
34320 arg1 = reinterpret_cast< wxWindow * >(argp1);
34321 {
34322 PyThreadState* __tstate = wxPyBeginAllowThreads();
34323 (arg1)->Update();
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_ClearBackground(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_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
34346 }
34347 arg1 = reinterpret_cast< wxWindow * >(argp1);
34348 {
34349 PyThreadState* __tstate = wxPyBeginAllowThreads();
34350 (arg1)->ClearBackground();
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_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34362 PyObject *resultobj = 0;
34363 wxWindow *arg1 = (wxWindow *) 0 ;
34364 void *argp1 = 0 ;
34365 int res1 = 0 ;
34366 PyObject *swig_obj[1] ;
34367
34368 if (!args) SWIG_fail;
34369 swig_obj[0] = args;
34370 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34371 if (!SWIG_IsOK(res1)) {
34372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
34373 }
34374 arg1 = reinterpret_cast< wxWindow * >(argp1);
34375 {
34376 PyThreadState* __tstate = wxPyBeginAllowThreads();
34377 (arg1)->Freeze();
34378 wxPyEndAllowThreads(__tstate);
34379 if (PyErr_Occurred()) SWIG_fail;
34380 }
34381 resultobj = SWIG_Py_Void();
34382 return resultobj;
34383 fail:
34384 return NULL;
34385 }
34386
34387
34388 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34389 PyObject *resultobj = 0;
34390 wxWindow *arg1 = (wxWindow *) 0 ;
34391 void *argp1 = 0 ;
34392 int res1 = 0 ;
34393 PyObject *swig_obj[1] ;
34394
34395 if (!args) SWIG_fail;
34396 swig_obj[0] = args;
34397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34398 if (!SWIG_IsOK(res1)) {
34399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
34400 }
34401 arg1 = reinterpret_cast< wxWindow * >(argp1);
34402 {
34403 PyThreadState* __tstate = wxPyBeginAllowThreads();
34404 (arg1)->Thaw();
34405 wxPyEndAllowThreads(__tstate);
34406 if (PyErr_Occurred()) SWIG_fail;
34407 }
34408 resultobj = SWIG_Py_Void();
34409 return resultobj;
34410 fail:
34411 return NULL;
34412 }
34413
34414
34415 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34416 PyObject *resultobj = 0;
34417 wxWindow *arg1 = (wxWindow *) 0 ;
34418 wxDC *arg2 = 0 ;
34419 void *argp1 = 0 ;
34420 int res1 = 0 ;
34421 void *argp2 = 0 ;
34422 int res2 = 0 ;
34423 PyObject * obj0 = 0 ;
34424 PyObject * obj1 = 0 ;
34425 char * kwnames[] = {
34426 (char *) "self",(char *) "dc", NULL
34427 };
34428
34429 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
34430 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34431 if (!SWIG_IsOK(res1)) {
34432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
34433 }
34434 arg1 = reinterpret_cast< wxWindow * >(argp1);
34435 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
34436 if (!SWIG_IsOK(res2)) {
34437 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34438 }
34439 if (!argp2) {
34440 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34441 }
34442 arg2 = reinterpret_cast< wxDC * >(argp2);
34443 {
34444 PyThreadState* __tstate = wxPyBeginAllowThreads();
34445 (arg1)->PrepareDC(*arg2);
34446 wxPyEndAllowThreads(__tstate);
34447 if (PyErr_Occurred()) SWIG_fail;
34448 }
34449 resultobj = SWIG_Py_Void();
34450 return resultobj;
34451 fail:
34452 return NULL;
34453 }
34454
34455
34456 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34457 PyObject *resultobj = 0;
34458 wxWindow *arg1 = (wxWindow *) 0 ;
34459 wxRegion *result = 0 ;
34460 void *argp1 = 0 ;
34461 int res1 = 0 ;
34462 PyObject *swig_obj[1] ;
34463
34464 if (!args) SWIG_fail;
34465 swig_obj[0] = args;
34466 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34467 if (!SWIG_IsOK(res1)) {
34468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
34469 }
34470 arg1 = reinterpret_cast< wxWindow * >(argp1);
34471 {
34472 PyThreadState* __tstate = wxPyBeginAllowThreads();
34473 {
34474 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
34475 result = (wxRegion *) &_result_ref;
34476 }
34477 wxPyEndAllowThreads(__tstate);
34478 if (PyErr_Occurred()) SWIG_fail;
34479 }
34480 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
34481 return resultobj;
34482 fail:
34483 return NULL;
34484 }
34485
34486
34487 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34488 PyObject *resultobj = 0;
34489 wxWindow *arg1 = (wxWindow *) 0 ;
34490 wxRect result;
34491 void *argp1 = 0 ;
34492 int res1 = 0 ;
34493 PyObject *swig_obj[1] ;
34494
34495 if (!args) SWIG_fail;
34496 swig_obj[0] = args;
34497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34498 if (!SWIG_IsOK(res1)) {
34499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34500 }
34501 arg1 = reinterpret_cast< wxWindow * >(argp1);
34502 {
34503 PyThreadState* __tstate = wxPyBeginAllowThreads();
34504 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
34505 wxPyEndAllowThreads(__tstate);
34506 if (PyErr_Occurred()) SWIG_fail;
34507 }
34508 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34509 return resultobj;
34510 fail:
34511 return NULL;
34512 }
34513
34514
34515 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34516 PyObject *resultobj = 0;
34517 wxWindow *arg1 = (wxWindow *) 0 ;
34518 int arg2 ;
34519 int arg3 ;
34520 int arg4 = (int) 1 ;
34521 int arg5 = (int) 1 ;
34522 bool result;
34523 void *argp1 = 0 ;
34524 int res1 = 0 ;
34525 int val2 ;
34526 int ecode2 = 0 ;
34527 int val3 ;
34528 int ecode3 = 0 ;
34529 int val4 ;
34530 int ecode4 = 0 ;
34531 int val5 ;
34532 int ecode5 = 0 ;
34533 PyObject * obj0 = 0 ;
34534 PyObject * obj1 = 0 ;
34535 PyObject * obj2 = 0 ;
34536 PyObject * obj3 = 0 ;
34537 PyObject * obj4 = 0 ;
34538 char * kwnames[] = {
34539 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
34540 };
34541
34542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
34543 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34544 if (!SWIG_IsOK(res1)) {
34545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
34546 }
34547 arg1 = reinterpret_cast< wxWindow * >(argp1);
34548 ecode2 = SWIG_AsVal_int(obj1, &val2);
34549 if (!SWIG_IsOK(ecode2)) {
34550 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
34551 }
34552 arg2 = static_cast< int >(val2);
34553 ecode3 = SWIG_AsVal_int(obj2, &val3);
34554 if (!SWIG_IsOK(ecode3)) {
34555 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
34556 }
34557 arg3 = static_cast< int >(val3);
34558 if (obj3) {
34559 ecode4 = SWIG_AsVal_int(obj3, &val4);
34560 if (!SWIG_IsOK(ecode4)) {
34561 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
34562 }
34563 arg4 = static_cast< int >(val4);
34564 }
34565 if (obj4) {
34566 ecode5 = SWIG_AsVal_int(obj4, &val5);
34567 if (!SWIG_IsOK(ecode5)) {
34568 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
34569 }
34570 arg5 = static_cast< int >(val5);
34571 }
34572 {
34573 PyThreadState* __tstate = wxPyBeginAllowThreads();
34574 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
34575 wxPyEndAllowThreads(__tstate);
34576 if (PyErr_Occurred()) SWIG_fail;
34577 }
34578 {
34579 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34580 }
34581 return resultobj;
34582 fail:
34583 return NULL;
34584 }
34585
34586
34587 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34588 PyObject *resultobj = 0;
34589 wxWindow *arg1 = (wxWindow *) 0 ;
34590 wxPoint *arg2 = 0 ;
34591 bool result;
34592 void *argp1 = 0 ;
34593 int res1 = 0 ;
34594 wxPoint temp2 ;
34595 PyObject * obj0 = 0 ;
34596 PyObject * obj1 = 0 ;
34597 char * kwnames[] = {
34598 (char *) "self",(char *) "pt", NULL
34599 };
34600
34601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
34602 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34603 if (!SWIG_IsOK(res1)) {
34604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
34605 }
34606 arg1 = reinterpret_cast< wxWindow * >(argp1);
34607 {
34608 arg2 = &temp2;
34609 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34610 }
34611 {
34612 PyThreadState* __tstate = wxPyBeginAllowThreads();
34613 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
34614 wxPyEndAllowThreads(__tstate);
34615 if (PyErr_Occurred()) SWIG_fail;
34616 }
34617 {
34618 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34619 }
34620 return resultobj;
34621 fail:
34622 return NULL;
34623 }
34624
34625
34626 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34627 PyObject *resultobj = 0;
34628 wxWindow *arg1 = (wxWindow *) 0 ;
34629 wxRect *arg2 = 0 ;
34630 bool result;
34631 void *argp1 = 0 ;
34632 int res1 = 0 ;
34633 wxRect temp2 ;
34634 PyObject * obj0 = 0 ;
34635 PyObject * obj1 = 0 ;
34636 char * kwnames[] = {
34637 (char *) "self",(char *) "rect", NULL
34638 };
34639
34640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
34641 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34642 if (!SWIG_IsOK(res1)) {
34643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34644 }
34645 arg1 = reinterpret_cast< wxWindow * >(argp1);
34646 {
34647 arg2 = &temp2;
34648 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34649 }
34650 {
34651 PyThreadState* __tstate = wxPyBeginAllowThreads();
34652 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
34653 wxPyEndAllowThreads(__tstate);
34654 if (PyErr_Occurred()) SWIG_fail;
34655 }
34656 {
34657 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34658 }
34659 return resultobj;
34660 fail:
34661 return NULL;
34662 }
34663
34664
34665 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34666 PyObject *resultobj = 0;
34667 wxWindow *arg1 = (wxWindow *) 0 ;
34668 SwigValueWrapper<wxVisualAttributes > result;
34669 void *argp1 = 0 ;
34670 int res1 = 0 ;
34671 PyObject *swig_obj[1] ;
34672
34673 if (!args) SWIG_fail;
34674 swig_obj[0] = args;
34675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34676 if (!SWIG_IsOK(res1)) {
34677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
34678 }
34679 arg1 = reinterpret_cast< wxWindow * >(argp1);
34680 {
34681 PyThreadState* __tstate = wxPyBeginAllowThreads();
34682 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
34683 wxPyEndAllowThreads(__tstate);
34684 if (PyErr_Occurred()) SWIG_fail;
34685 }
34686 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34687 return resultobj;
34688 fail:
34689 return NULL;
34690 }
34691
34692
34693 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34694 PyObject *resultobj = 0;
34695 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
34696 SwigValueWrapper<wxVisualAttributes > result;
34697 int val1 ;
34698 int ecode1 = 0 ;
34699 PyObject * obj0 = 0 ;
34700 char * kwnames[] = {
34701 (char *) "variant", NULL
34702 };
34703
34704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
34705 if (obj0) {
34706 ecode1 = SWIG_AsVal_int(obj0, &val1);
34707 if (!SWIG_IsOK(ecode1)) {
34708 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
34709 }
34710 arg1 = static_cast< wxWindowVariant >(val1);
34711 }
34712 {
34713 if (!wxPyCheckForApp()) SWIG_fail;
34714 PyThreadState* __tstate = wxPyBeginAllowThreads();
34715 result = wxWindow::GetClassDefaultAttributes(arg1);
34716 wxPyEndAllowThreads(__tstate);
34717 if (PyErr_Occurred()) SWIG_fail;
34718 }
34719 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34720 return resultobj;
34721 fail:
34722 return NULL;
34723 }
34724
34725
34726 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34727 PyObject *resultobj = 0;
34728 wxWindow *arg1 = (wxWindow *) 0 ;
34729 wxColour *arg2 = 0 ;
34730 bool result;
34731 void *argp1 = 0 ;
34732 int res1 = 0 ;
34733 wxColour temp2 ;
34734 PyObject * obj0 = 0 ;
34735 PyObject * obj1 = 0 ;
34736 char * kwnames[] = {
34737 (char *) "self",(char *) "colour", NULL
34738 };
34739
34740 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34741 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34742 if (!SWIG_IsOK(res1)) {
34743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34744 }
34745 arg1 = reinterpret_cast< wxWindow * >(argp1);
34746 {
34747 arg2 = &temp2;
34748 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34749 }
34750 {
34751 PyThreadState* __tstate = wxPyBeginAllowThreads();
34752 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
34753 wxPyEndAllowThreads(__tstate);
34754 if (PyErr_Occurred()) SWIG_fail;
34755 }
34756 {
34757 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34758 }
34759 return resultobj;
34760 fail:
34761 return NULL;
34762 }
34763
34764
34765 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34766 PyObject *resultobj = 0;
34767 wxWindow *arg1 = (wxWindow *) 0 ;
34768 wxColour *arg2 = 0 ;
34769 void *argp1 = 0 ;
34770 int res1 = 0 ;
34771 wxColour temp2 ;
34772 PyObject * obj0 = 0 ;
34773 PyObject * obj1 = 0 ;
34774 char * kwnames[] = {
34775 (char *) "self",(char *) "colour", NULL
34776 };
34777
34778 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34779 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34780 if (!SWIG_IsOK(res1)) {
34781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34782 }
34783 arg1 = reinterpret_cast< wxWindow * >(argp1);
34784 {
34785 arg2 = &temp2;
34786 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34787 }
34788 {
34789 PyThreadState* __tstate = wxPyBeginAllowThreads();
34790 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
34791 wxPyEndAllowThreads(__tstate);
34792 if (PyErr_Occurred()) SWIG_fail;
34793 }
34794 resultobj = SWIG_Py_Void();
34795 return resultobj;
34796 fail:
34797 return NULL;
34798 }
34799
34800
34801 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34802 PyObject *resultobj = 0;
34803 wxWindow *arg1 = (wxWindow *) 0 ;
34804 wxColour *arg2 = 0 ;
34805 bool result;
34806 void *argp1 = 0 ;
34807 int res1 = 0 ;
34808 wxColour temp2 ;
34809 PyObject * obj0 = 0 ;
34810 PyObject * obj1 = 0 ;
34811 char * kwnames[] = {
34812 (char *) "self",(char *) "colour", NULL
34813 };
34814
34815 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34816 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34817 if (!SWIG_IsOK(res1)) {
34818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34819 }
34820 arg1 = reinterpret_cast< wxWindow * >(argp1);
34821 {
34822 arg2 = &temp2;
34823 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34824 }
34825 {
34826 PyThreadState* __tstate = wxPyBeginAllowThreads();
34827 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
34828 wxPyEndAllowThreads(__tstate);
34829 if (PyErr_Occurred()) SWIG_fail;
34830 }
34831 {
34832 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34833 }
34834 return resultobj;
34835 fail:
34836 return NULL;
34837 }
34838
34839
34840 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34841 PyObject *resultobj = 0;
34842 wxWindow *arg1 = (wxWindow *) 0 ;
34843 wxColour *arg2 = 0 ;
34844 void *argp1 = 0 ;
34845 int res1 = 0 ;
34846 wxColour temp2 ;
34847 PyObject * obj0 = 0 ;
34848 PyObject * obj1 = 0 ;
34849 char * kwnames[] = {
34850 (char *) "self",(char *) "colour", NULL
34851 };
34852
34853 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34854 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34855 if (!SWIG_IsOK(res1)) {
34856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34857 }
34858 arg1 = reinterpret_cast< wxWindow * >(argp1);
34859 {
34860 arg2 = &temp2;
34861 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34862 }
34863 {
34864 PyThreadState* __tstate = wxPyBeginAllowThreads();
34865 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
34866 wxPyEndAllowThreads(__tstate);
34867 if (PyErr_Occurred()) SWIG_fail;
34868 }
34869 resultobj = SWIG_Py_Void();
34870 return resultobj;
34871 fail:
34872 return NULL;
34873 }
34874
34875
34876 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34877 PyObject *resultobj = 0;
34878 wxWindow *arg1 = (wxWindow *) 0 ;
34879 wxColour result;
34880 void *argp1 = 0 ;
34881 int res1 = 0 ;
34882 PyObject *swig_obj[1] ;
34883
34884 if (!args) SWIG_fail;
34885 swig_obj[0] = args;
34886 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34887 if (!SWIG_IsOK(res1)) {
34888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
34889 }
34890 arg1 = reinterpret_cast< wxWindow * >(argp1);
34891 {
34892 PyThreadState* __tstate = wxPyBeginAllowThreads();
34893 result = ((wxWindow const *)arg1)->GetBackgroundColour();
34894 wxPyEndAllowThreads(__tstate);
34895 if (PyErr_Occurred()) SWIG_fail;
34896 }
34897 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
34898 return resultobj;
34899 fail:
34900 return NULL;
34901 }
34902
34903
34904 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34905 PyObject *resultobj = 0;
34906 wxWindow *arg1 = (wxWindow *) 0 ;
34907 wxColour result;
34908 void *argp1 = 0 ;
34909 int res1 = 0 ;
34910 PyObject *swig_obj[1] ;
34911
34912 if (!args) SWIG_fail;
34913 swig_obj[0] = args;
34914 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34915 if (!SWIG_IsOK(res1)) {
34916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
34917 }
34918 arg1 = reinterpret_cast< wxWindow * >(argp1);
34919 {
34920 PyThreadState* __tstate = wxPyBeginAllowThreads();
34921 result = ((wxWindow const *)arg1)->GetForegroundColour();
34922 wxPyEndAllowThreads(__tstate);
34923 if (PyErr_Occurred()) SWIG_fail;
34924 }
34925 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
34926 return resultobj;
34927 fail:
34928 return NULL;
34929 }
34930
34931
34932 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34933 PyObject *resultobj = 0;
34934 wxWindow *arg1 = (wxWindow *) 0 ;
34935 bool result;
34936 void *argp1 = 0 ;
34937 int res1 = 0 ;
34938 PyObject *swig_obj[1] ;
34939
34940 if (!args) SWIG_fail;
34941 swig_obj[0] = args;
34942 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34943 if (!SWIG_IsOK(res1)) {
34944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
34945 }
34946 arg1 = reinterpret_cast< wxWindow * >(argp1);
34947 {
34948 PyThreadState* __tstate = wxPyBeginAllowThreads();
34949 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
34950 wxPyEndAllowThreads(__tstate);
34951 if (PyErr_Occurred()) SWIG_fail;
34952 }
34953 {
34954 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34955 }
34956 return resultobj;
34957 fail:
34958 return NULL;
34959 }
34960
34961
34962 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34963 PyObject *resultobj = 0;
34964 wxWindow *arg1 = (wxWindow *) 0 ;
34965 bool result;
34966 void *argp1 = 0 ;
34967 int res1 = 0 ;
34968 PyObject *swig_obj[1] ;
34969
34970 if (!args) SWIG_fail;
34971 swig_obj[0] = args;
34972 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34973 if (!SWIG_IsOK(res1)) {
34974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
34975 }
34976 arg1 = reinterpret_cast< wxWindow * >(argp1);
34977 {
34978 PyThreadState* __tstate = wxPyBeginAllowThreads();
34979 result = (bool)((wxWindow const *)arg1)->UseBgCol();
34980 wxPyEndAllowThreads(__tstate);
34981 if (PyErr_Occurred()) SWIG_fail;
34982 }
34983 {
34984 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34985 }
34986 return resultobj;
34987 fail:
34988 return NULL;
34989 }
34990
34991
34992 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34993 PyObject *resultobj = 0;
34994 wxWindow *arg1 = (wxWindow *) 0 ;
34995 wxBackgroundStyle arg2 ;
34996 bool result;
34997 void *argp1 = 0 ;
34998 int res1 = 0 ;
34999 int val2 ;
35000 int ecode2 = 0 ;
35001 PyObject * obj0 = 0 ;
35002 PyObject * obj1 = 0 ;
35003 char * kwnames[] = {
35004 (char *) "self",(char *) "style", NULL
35005 };
35006
35007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
35008 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35009 if (!SWIG_IsOK(res1)) {
35010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
35011 }
35012 arg1 = reinterpret_cast< wxWindow * >(argp1);
35013 ecode2 = SWIG_AsVal_int(obj1, &val2);
35014 if (!SWIG_IsOK(ecode2)) {
35015 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
35016 }
35017 arg2 = static_cast< wxBackgroundStyle >(val2);
35018 {
35019 PyThreadState* __tstate = wxPyBeginAllowThreads();
35020 result = (bool)(arg1)->SetBackgroundStyle(arg2);
35021 wxPyEndAllowThreads(__tstate);
35022 if (PyErr_Occurred()) SWIG_fail;
35023 }
35024 {
35025 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35026 }
35027 return resultobj;
35028 fail:
35029 return NULL;
35030 }
35031
35032
35033 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35034 PyObject *resultobj = 0;
35035 wxWindow *arg1 = (wxWindow *) 0 ;
35036 wxBackgroundStyle result;
35037 void *argp1 = 0 ;
35038 int res1 = 0 ;
35039 PyObject *swig_obj[1] ;
35040
35041 if (!args) SWIG_fail;
35042 swig_obj[0] = args;
35043 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35044 if (!SWIG_IsOK(res1)) {
35045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
35046 }
35047 arg1 = reinterpret_cast< wxWindow * >(argp1);
35048 {
35049 PyThreadState* __tstate = wxPyBeginAllowThreads();
35050 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
35051 wxPyEndAllowThreads(__tstate);
35052 if (PyErr_Occurred()) SWIG_fail;
35053 }
35054 resultobj = SWIG_From_int(static_cast< int >(result));
35055 return resultobj;
35056 fail:
35057 return NULL;
35058 }
35059
35060
35061 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35062 PyObject *resultobj = 0;
35063 wxWindow *arg1 = (wxWindow *) 0 ;
35064 bool result;
35065 void *argp1 = 0 ;
35066 int res1 = 0 ;
35067 PyObject *swig_obj[1] ;
35068
35069 if (!args) SWIG_fail;
35070 swig_obj[0] = args;
35071 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35072 if (!SWIG_IsOK(res1)) {
35073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
35074 }
35075 arg1 = reinterpret_cast< wxWindow * >(argp1);
35076 {
35077 PyThreadState* __tstate = wxPyBeginAllowThreads();
35078 result = (bool)(arg1)->HasTransparentBackground();
35079 wxPyEndAllowThreads(__tstate);
35080 if (PyErr_Occurred()) SWIG_fail;
35081 }
35082 {
35083 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35084 }
35085 return resultobj;
35086 fail:
35087 return NULL;
35088 }
35089
35090
35091 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35092 PyObject *resultobj = 0;
35093 wxWindow *arg1 = (wxWindow *) 0 ;
35094 wxCursor *arg2 = 0 ;
35095 bool result;
35096 void *argp1 = 0 ;
35097 int res1 = 0 ;
35098 void *argp2 = 0 ;
35099 int res2 = 0 ;
35100 PyObject * obj0 = 0 ;
35101 PyObject * obj1 = 0 ;
35102 char * kwnames[] = {
35103 (char *) "self",(char *) "cursor", NULL
35104 };
35105
35106 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
35107 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35108 if (!SWIG_IsOK(res1)) {
35109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35110 }
35111 arg1 = reinterpret_cast< wxWindow * >(argp1);
35112 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
35113 if (!SWIG_IsOK(res2)) {
35114 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35115 }
35116 if (!argp2) {
35117 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35118 }
35119 arg2 = reinterpret_cast< wxCursor * >(argp2);
35120 {
35121 PyThreadState* __tstate = wxPyBeginAllowThreads();
35122 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
35123 wxPyEndAllowThreads(__tstate);
35124 if (PyErr_Occurred()) SWIG_fail;
35125 }
35126 {
35127 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35128 }
35129 return resultobj;
35130 fail:
35131 return NULL;
35132 }
35133
35134
35135 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35136 PyObject *resultobj = 0;
35137 wxWindow *arg1 = (wxWindow *) 0 ;
35138 wxCursor result;
35139 void *argp1 = 0 ;
35140 int res1 = 0 ;
35141 PyObject *swig_obj[1] ;
35142
35143 if (!args) SWIG_fail;
35144 swig_obj[0] = args;
35145 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35146 if (!SWIG_IsOK(res1)) {
35147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35148 }
35149 arg1 = reinterpret_cast< wxWindow * >(argp1);
35150 {
35151 PyThreadState* __tstate = wxPyBeginAllowThreads();
35152 result = (arg1)->GetCursor();
35153 wxPyEndAllowThreads(__tstate);
35154 if (PyErr_Occurred()) SWIG_fail;
35155 }
35156 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
35157 return resultobj;
35158 fail:
35159 return NULL;
35160 }
35161
35162
35163 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35164 PyObject *resultobj = 0;
35165 wxWindow *arg1 = (wxWindow *) 0 ;
35166 wxFont *arg2 = 0 ;
35167 bool result;
35168 void *argp1 = 0 ;
35169 int res1 = 0 ;
35170 void *argp2 = 0 ;
35171 int res2 = 0 ;
35172 PyObject * obj0 = 0 ;
35173 PyObject * obj1 = 0 ;
35174 char * kwnames[] = {
35175 (char *) "self",(char *) "font", NULL
35176 };
35177
35178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
35179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35180 if (!SWIG_IsOK(res1)) {
35181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35182 }
35183 arg1 = reinterpret_cast< wxWindow * >(argp1);
35184 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35185 if (!SWIG_IsOK(res2)) {
35186 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35187 }
35188 if (!argp2) {
35189 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35190 }
35191 arg2 = reinterpret_cast< wxFont * >(argp2);
35192 {
35193 PyThreadState* __tstate = wxPyBeginAllowThreads();
35194 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
35195 wxPyEndAllowThreads(__tstate);
35196 if (PyErr_Occurred()) SWIG_fail;
35197 }
35198 {
35199 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35200 }
35201 return resultobj;
35202 fail:
35203 return NULL;
35204 }
35205
35206
35207 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35208 PyObject *resultobj = 0;
35209 wxWindow *arg1 = (wxWindow *) 0 ;
35210 wxFont *arg2 = 0 ;
35211 void *argp1 = 0 ;
35212 int res1 = 0 ;
35213 void *argp2 = 0 ;
35214 int res2 = 0 ;
35215 PyObject * obj0 = 0 ;
35216 PyObject * obj1 = 0 ;
35217 char * kwnames[] = {
35218 (char *) "self",(char *) "font", NULL
35219 };
35220
35221 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
35222 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35223 if (!SWIG_IsOK(res1)) {
35224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35225 }
35226 arg1 = reinterpret_cast< wxWindow * >(argp1);
35227 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35228 if (!SWIG_IsOK(res2)) {
35229 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35230 }
35231 if (!argp2) {
35232 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35233 }
35234 arg2 = reinterpret_cast< wxFont * >(argp2);
35235 {
35236 PyThreadState* __tstate = wxPyBeginAllowThreads();
35237 (arg1)->SetOwnFont((wxFont const &)*arg2);
35238 wxPyEndAllowThreads(__tstate);
35239 if (PyErr_Occurred()) SWIG_fail;
35240 }
35241 resultobj = SWIG_Py_Void();
35242 return resultobj;
35243 fail:
35244 return NULL;
35245 }
35246
35247
35248 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35249 PyObject *resultobj = 0;
35250 wxWindow *arg1 = (wxWindow *) 0 ;
35251 wxFont result;
35252 void *argp1 = 0 ;
35253 int res1 = 0 ;
35254 PyObject *swig_obj[1] ;
35255
35256 if (!args) SWIG_fail;
35257 swig_obj[0] = args;
35258 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35259 if (!SWIG_IsOK(res1)) {
35260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35261 }
35262 arg1 = reinterpret_cast< wxWindow * >(argp1);
35263 {
35264 PyThreadState* __tstate = wxPyBeginAllowThreads();
35265 result = (arg1)->GetFont();
35266 wxPyEndAllowThreads(__tstate);
35267 if (PyErr_Occurred()) SWIG_fail;
35268 }
35269 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
35270 return resultobj;
35271 fail:
35272 return NULL;
35273 }
35274
35275
35276 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35277 PyObject *resultobj = 0;
35278 wxWindow *arg1 = (wxWindow *) 0 ;
35279 wxCaret *arg2 = (wxCaret *) 0 ;
35280 void *argp1 = 0 ;
35281 int res1 = 0 ;
35282 int res2 = 0 ;
35283 PyObject * obj0 = 0 ;
35284 PyObject * obj1 = 0 ;
35285 char * kwnames[] = {
35286 (char *) "self",(char *) "caret", NULL
35287 };
35288
35289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
35290 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35291 if (!SWIG_IsOK(res1)) {
35292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
35293 }
35294 arg1 = reinterpret_cast< wxWindow * >(argp1);
35295 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
35296 if (!SWIG_IsOK(res2)) {
35297 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
35298 }
35299 {
35300 PyThreadState* __tstate = wxPyBeginAllowThreads();
35301 (arg1)->SetCaret(arg2);
35302 wxPyEndAllowThreads(__tstate);
35303 if (PyErr_Occurred()) SWIG_fail;
35304 }
35305 resultobj = SWIG_Py_Void();
35306 return resultobj;
35307 fail:
35308 return NULL;
35309 }
35310
35311
35312 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35313 PyObject *resultobj = 0;
35314 wxWindow *arg1 = (wxWindow *) 0 ;
35315 wxCaret *result = 0 ;
35316 void *argp1 = 0 ;
35317 int res1 = 0 ;
35318 PyObject *swig_obj[1] ;
35319
35320 if (!args) SWIG_fail;
35321 swig_obj[0] = args;
35322 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35323 if (!SWIG_IsOK(res1)) {
35324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
35325 }
35326 arg1 = reinterpret_cast< wxWindow * >(argp1);
35327 {
35328 PyThreadState* __tstate = wxPyBeginAllowThreads();
35329 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
35330 wxPyEndAllowThreads(__tstate);
35331 if (PyErr_Occurred()) SWIG_fail;
35332 }
35333 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
35334 return resultobj;
35335 fail:
35336 return NULL;
35337 }
35338
35339
35340 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35341 PyObject *resultobj = 0;
35342 wxWindow *arg1 = (wxWindow *) 0 ;
35343 int result;
35344 void *argp1 = 0 ;
35345 int res1 = 0 ;
35346 PyObject *swig_obj[1] ;
35347
35348 if (!args) SWIG_fail;
35349 swig_obj[0] = args;
35350 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35351 if (!SWIG_IsOK(res1)) {
35352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35353 }
35354 arg1 = reinterpret_cast< wxWindow * >(argp1);
35355 {
35356 PyThreadState* __tstate = wxPyBeginAllowThreads();
35357 result = (int)((wxWindow const *)arg1)->GetCharHeight();
35358 wxPyEndAllowThreads(__tstate);
35359 if (PyErr_Occurred()) SWIG_fail;
35360 }
35361 resultobj = SWIG_From_int(static_cast< int >(result));
35362 return resultobj;
35363 fail:
35364 return NULL;
35365 }
35366
35367
35368 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35369 PyObject *resultobj = 0;
35370 wxWindow *arg1 = (wxWindow *) 0 ;
35371 int result;
35372 void *argp1 = 0 ;
35373 int res1 = 0 ;
35374 PyObject *swig_obj[1] ;
35375
35376 if (!args) SWIG_fail;
35377 swig_obj[0] = args;
35378 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35379 if (!SWIG_IsOK(res1)) {
35380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35381 }
35382 arg1 = reinterpret_cast< wxWindow * >(argp1);
35383 {
35384 PyThreadState* __tstate = wxPyBeginAllowThreads();
35385 result = (int)((wxWindow const *)arg1)->GetCharWidth();
35386 wxPyEndAllowThreads(__tstate);
35387 if (PyErr_Occurred()) SWIG_fail;
35388 }
35389 resultobj = SWIG_From_int(static_cast< int >(result));
35390 return resultobj;
35391 fail:
35392 return NULL;
35393 }
35394
35395
35396 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35397 PyObject *resultobj = 0;
35398 wxWindow *arg1 = (wxWindow *) 0 ;
35399 wxString *arg2 = 0 ;
35400 int *arg3 = (int *) 0 ;
35401 int *arg4 = (int *) 0 ;
35402 void *argp1 = 0 ;
35403 int res1 = 0 ;
35404 bool temp2 = false ;
35405 int temp3 ;
35406 int res3 = SWIG_TMPOBJ ;
35407 int temp4 ;
35408 int res4 = SWIG_TMPOBJ ;
35409 PyObject * obj0 = 0 ;
35410 PyObject * obj1 = 0 ;
35411 char * kwnames[] = {
35412 (char *) "self",(char *) "string", NULL
35413 };
35414
35415 arg3 = &temp3;
35416 arg4 = &temp4;
35417 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
35418 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35419 if (!SWIG_IsOK(res1)) {
35420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35421 }
35422 arg1 = reinterpret_cast< wxWindow * >(argp1);
35423 {
35424 arg2 = wxString_in_helper(obj1);
35425 if (arg2 == NULL) SWIG_fail;
35426 temp2 = true;
35427 }
35428 {
35429 PyThreadState* __tstate = wxPyBeginAllowThreads();
35430 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
35431 wxPyEndAllowThreads(__tstate);
35432 if (PyErr_Occurred()) SWIG_fail;
35433 }
35434 resultobj = SWIG_Py_Void();
35435 if (SWIG_IsTmpObj(res3)) {
35436 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35437 } else {
35438 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35439 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35440 }
35441 if (SWIG_IsTmpObj(res4)) {
35442 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35443 } else {
35444 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35445 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35446 }
35447 {
35448 if (temp2)
35449 delete arg2;
35450 }
35451 return resultobj;
35452 fail:
35453 {
35454 if (temp2)
35455 delete arg2;
35456 }
35457 return NULL;
35458 }
35459
35460
35461 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35462 PyObject *resultobj = 0;
35463 wxWindow *arg1 = (wxWindow *) 0 ;
35464 wxString *arg2 = 0 ;
35465 int *arg3 = (int *) 0 ;
35466 int *arg4 = (int *) 0 ;
35467 int *arg5 = (int *) 0 ;
35468 int *arg6 = (int *) 0 ;
35469 wxFont *arg7 = (wxFont *) NULL ;
35470 void *argp1 = 0 ;
35471 int res1 = 0 ;
35472 bool temp2 = false ;
35473 int temp3 ;
35474 int res3 = SWIG_TMPOBJ ;
35475 int temp4 ;
35476 int res4 = SWIG_TMPOBJ ;
35477 int temp5 ;
35478 int res5 = SWIG_TMPOBJ ;
35479 int temp6 ;
35480 int res6 = SWIG_TMPOBJ ;
35481 void *argp7 = 0 ;
35482 int res7 = 0 ;
35483 PyObject * obj0 = 0 ;
35484 PyObject * obj1 = 0 ;
35485 PyObject * obj2 = 0 ;
35486 char * kwnames[] = {
35487 (char *) "self",(char *) "string",(char *) "font", NULL
35488 };
35489
35490 arg3 = &temp3;
35491 arg4 = &temp4;
35492 arg5 = &temp5;
35493 arg6 = &temp6;
35494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35496 if (!SWIG_IsOK(res1)) {
35497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35498 }
35499 arg1 = reinterpret_cast< wxWindow * >(argp1);
35500 {
35501 arg2 = wxString_in_helper(obj1);
35502 if (arg2 == NULL) SWIG_fail;
35503 temp2 = true;
35504 }
35505 if (obj2) {
35506 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
35507 if (!SWIG_IsOK(res7)) {
35508 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
35509 }
35510 arg7 = reinterpret_cast< wxFont * >(argp7);
35511 }
35512 {
35513 PyThreadState* __tstate = wxPyBeginAllowThreads();
35514 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
35515 wxPyEndAllowThreads(__tstate);
35516 if (PyErr_Occurred()) SWIG_fail;
35517 }
35518 resultobj = SWIG_Py_Void();
35519 if (SWIG_IsTmpObj(res3)) {
35520 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35521 } else {
35522 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35523 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35524 }
35525 if (SWIG_IsTmpObj(res4)) {
35526 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35527 } else {
35528 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35529 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35530 }
35531 if (SWIG_IsTmpObj(res5)) {
35532 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
35533 } else {
35534 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35535 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
35536 }
35537 if (SWIG_IsTmpObj(res6)) {
35538 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
35539 } else {
35540 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35541 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
35542 }
35543 {
35544 if (temp2)
35545 delete arg2;
35546 }
35547 return resultobj;
35548 fail:
35549 {
35550 if (temp2)
35551 delete arg2;
35552 }
35553 return NULL;
35554 }
35555
35556
35557 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35558 PyObject *resultobj = 0;
35559 wxWindow *arg1 = (wxWindow *) 0 ;
35560 int *arg2 = (int *) 0 ;
35561 int *arg3 = (int *) 0 ;
35562 void *argp1 = 0 ;
35563 int res1 = 0 ;
35564 int temp2 ;
35565 int res2 = 0 ;
35566 int temp3 ;
35567 int res3 = 0 ;
35568 PyObject * obj0 = 0 ;
35569 PyObject * obj1 = 0 ;
35570 PyObject * obj2 = 0 ;
35571 char * kwnames[] = {
35572 (char *) "self",(char *) "x",(char *) "y", NULL
35573 };
35574
35575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35576 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35577 if (!SWIG_IsOK(res1)) {
35578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35579 }
35580 arg1 = reinterpret_cast< wxWindow * >(argp1);
35581 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35582 int val;
35583 int ecode = SWIG_AsVal_int(obj1, &val);
35584 if (!SWIG_IsOK(ecode)) {
35585 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
35586 }
35587 temp2 = static_cast< int >(val);
35588 arg2 = &temp2;
35589 res2 = SWIG_AddTmpMask(ecode);
35590 }
35591 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35592 int val;
35593 int ecode = SWIG_AsVal_int(obj2, &val);
35594 if (!SWIG_IsOK(ecode)) {
35595 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
35596 }
35597 temp3 = static_cast< int >(val);
35598 arg3 = &temp3;
35599 res3 = SWIG_AddTmpMask(ecode);
35600 }
35601 {
35602 PyThreadState* __tstate = wxPyBeginAllowThreads();
35603 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
35604 wxPyEndAllowThreads(__tstate);
35605 if (PyErr_Occurred()) SWIG_fail;
35606 }
35607 resultobj = SWIG_Py_Void();
35608 if (SWIG_IsTmpObj(res2)) {
35609 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35610 } else {
35611 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35612 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35613 }
35614 if (SWIG_IsTmpObj(res3)) {
35615 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35616 } else {
35617 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35618 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35619 }
35620 return resultobj;
35621 fail:
35622 return NULL;
35623 }
35624
35625
35626 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35627 PyObject *resultobj = 0;
35628 wxWindow *arg1 = (wxWindow *) 0 ;
35629 int *arg2 = (int *) 0 ;
35630 int *arg3 = (int *) 0 ;
35631 void *argp1 = 0 ;
35632 int res1 = 0 ;
35633 int temp2 ;
35634 int res2 = 0 ;
35635 int temp3 ;
35636 int res3 = 0 ;
35637 PyObject * obj0 = 0 ;
35638 PyObject * obj1 = 0 ;
35639 PyObject * obj2 = 0 ;
35640 char * kwnames[] = {
35641 (char *) "self",(char *) "x",(char *) "y", NULL
35642 };
35643
35644 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35645 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35646 if (!SWIG_IsOK(res1)) {
35647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35648 }
35649 arg1 = reinterpret_cast< wxWindow * >(argp1);
35650 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35651 int val;
35652 int ecode = SWIG_AsVal_int(obj1, &val);
35653 if (!SWIG_IsOK(ecode)) {
35654 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
35655 }
35656 temp2 = static_cast< int >(val);
35657 arg2 = &temp2;
35658 res2 = SWIG_AddTmpMask(ecode);
35659 }
35660 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35661 int val;
35662 int ecode = SWIG_AsVal_int(obj2, &val);
35663 if (!SWIG_IsOK(ecode)) {
35664 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
35665 }
35666 temp3 = static_cast< int >(val);
35667 arg3 = &temp3;
35668 res3 = SWIG_AddTmpMask(ecode);
35669 }
35670 {
35671 PyThreadState* __tstate = wxPyBeginAllowThreads();
35672 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
35673 wxPyEndAllowThreads(__tstate);
35674 if (PyErr_Occurred()) SWIG_fail;
35675 }
35676 resultobj = SWIG_Py_Void();
35677 if (SWIG_IsTmpObj(res2)) {
35678 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35679 } else {
35680 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35681 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35682 }
35683 if (SWIG_IsTmpObj(res3)) {
35684 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35685 } else {
35686 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35687 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35688 }
35689 return resultobj;
35690 fail:
35691 return NULL;
35692 }
35693
35694
35695 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35696 PyObject *resultobj = 0;
35697 wxWindow *arg1 = (wxWindow *) 0 ;
35698 wxPoint *arg2 = 0 ;
35699 wxPoint result;
35700 void *argp1 = 0 ;
35701 int res1 = 0 ;
35702 wxPoint temp2 ;
35703 PyObject * obj0 = 0 ;
35704 PyObject * obj1 = 0 ;
35705 char * kwnames[] = {
35706 (char *) "self",(char *) "pt", NULL
35707 };
35708
35709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
35710 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35711 if (!SWIG_IsOK(res1)) {
35712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35713 }
35714 arg1 = reinterpret_cast< wxWindow * >(argp1);
35715 {
35716 arg2 = &temp2;
35717 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35718 }
35719 {
35720 PyThreadState* __tstate = wxPyBeginAllowThreads();
35721 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
35722 wxPyEndAllowThreads(__tstate);
35723 if (PyErr_Occurred()) SWIG_fail;
35724 }
35725 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35726 return resultobj;
35727 fail:
35728 return NULL;
35729 }
35730
35731
35732 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35733 PyObject *resultobj = 0;
35734 wxWindow *arg1 = (wxWindow *) 0 ;
35735 wxPoint *arg2 = 0 ;
35736 wxPoint result;
35737 void *argp1 = 0 ;
35738 int res1 = 0 ;
35739 wxPoint temp2 ;
35740 PyObject * obj0 = 0 ;
35741 PyObject * obj1 = 0 ;
35742 char * kwnames[] = {
35743 (char *) "self",(char *) "pt", NULL
35744 };
35745
35746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
35747 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35748 if (!SWIG_IsOK(res1)) {
35749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
35750 }
35751 arg1 = reinterpret_cast< wxWindow * >(argp1);
35752 {
35753 arg2 = &temp2;
35754 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35755 }
35756 {
35757 PyThreadState* __tstate = wxPyBeginAllowThreads();
35758 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
35759 wxPyEndAllowThreads(__tstate);
35760 if (PyErr_Occurred()) SWIG_fail;
35761 }
35762 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35763 return resultobj;
35764 fail:
35765 return NULL;
35766 }
35767
35768
35769 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35770 PyObject *resultobj = 0;
35771 wxWindow *arg1 = (wxWindow *) 0 ;
35772 int arg2 ;
35773 int arg3 ;
35774 wxHitTest result;
35775 void *argp1 = 0 ;
35776 int res1 = 0 ;
35777 int val2 ;
35778 int ecode2 = 0 ;
35779 int val3 ;
35780 int ecode3 = 0 ;
35781 PyObject * obj0 = 0 ;
35782 PyObject * obj1 = 0 ;
35783 PyObject * obj2 = 0 ;
35784 char * kwnames[] = {
35785 (char *) "self",(char *) "x",(char *) "y", NULL
35786 };
35787
35788 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35789 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35790 if (!SWIG_IsOK(res1)) {
35791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35792 }
35793 arg1 = reinterpret_cast< wxWindow * >(argp1);
35794 ecode2 = SWIG_AsVal_int(obj1, &val2);
35795 if (!SWIG_IsOK(ecode2)) {
35796 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
35797 }
35798 arg2 = static_cast< int >(val2);
35799 ecode3 = SWIG_AsVal_int(obj2, &val3);
35800 if (!SWIG_IsOK(ecode3)) {
35801 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
35802 }
35803 arg3 = static_cast< int >(val3);
35804 {
35805 PyThreadState* __tstate = wxPyBeginAllowThreads();
35806 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
35807 wxPyEndAllowThreads(__tstate);
35808 if (PyErr_Occurred()) SWIG_fail;
35809 }
35810 resultobj = SWIG_From_int(static_cast< int >(result));
35811 return resultobj;
35812 fail:
35813 return NULL;
35814 }
35815
35816
35817 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35818 PyObject *resultobj = 0;
35819 wxWindow *arg1 = (wxWindow *) 0 ;
35820 wxPoint *arg2 = 0 ;
35821 wxHitTest result;
35822 void *argp1 = 0 ;
35823 int res1 = 0 ;
35824 wxPoint temp2 ;
35825 PyObject * obj0 = 0 ;
35826 PyObject * obj1 = 0 ;
35827 char * kwnames[] = {
35828 (char *) "self",(char *) "pt", NULL
35829 };
35830
35831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
35832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35833 if (!SWIG_IsOK(res1)) {
35834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
35835 }
35836 arg1 = reinterpret_cast< wxWindow * >(argp1);
35837 {
35838 arg2 = &temp2;
35839 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35840 }
35841 {
35842 PyThreadState* __tstate = wxPyBeginAllowThreads();
35843 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
35844 wxPyEndAllowThreads(__tstate);
35845 if (PyErr_Occurred()) SWIG_fail;
35846 }
35847 resultobj = SWIG_From_int(static_cast< int >(result));
35848 return resultobj;
35849 fail:
35850 return NULL;
35851 }
35852
35853
35854 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
35855 PyObject *resultobj = 0;
35856 wxWindow *arg1 = (wxWindow *) 0 ;
35857 long arg2 ;
35858 wxBorder result;
35859 void *argp1 = 0 ;
35860 int res1 = 0 ;
35861 long val2 ;
35862 int ecode2 = 0 ;
35863
35864 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
35865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35866 if (!SWIG_IsOK(res1)) {
35867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
35868 }
35869 arg1 = reinterpret_cast< wxWindow * >(argp1);
35870 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
35871 if (!SWIG_IsOK(ecode2)) {
35872 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
35873 }
35874 arg2 = static_cast< long >(val2);
35875 {
35876 PyThreadState* __tstate = wxPyBeginAllowThreads();
35877 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
35878 wxPyEndAllowThreads(__tstate);
35879 if (PyErr_Occurred()) SWIG_fail;
35880 }
35881 resultobj = SWIG_From_int(static_cast< int >(result));
35882 return resultobj;
35883 fail:
35884 return NULL;
35885 }
35886
35887
35888 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
35889 PyObject *resultobj = 0;
35890 wxWindow *arg1 = (wxWindow *) 0 ;
35891 wxBorder result;
35892 void *argp1 = 0 ;
35893 int res1 = 0 ;
35894
35895 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
35896 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35897 if (!SWIG_IsOK(res1)) {
35898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
35899 }
35900 arg1 = reinterpret_cast< wxWindow * >(argp1);
35901 {
35902 PyThreadState* __tstate = wxPyBeginAllowThreads();
35903 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
35904 wxPyEndAllowThreads(__tstate);
35905 if (PyErr_Occurred()) SWIG_fail;
35906 }
35907 resultobj = SWIG_From_int(static_cast< int >(result));
35908 return resultobj;
35909 fail:
35910 return NULL;
35911 }
35912
35913
35914 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
35915 int argc;
35916 PyObject *argv[3];
35917
35918 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
35919 --argc;
35920 if (argc == 1) {
35921 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
35922 }
35923 if (argc == 2) {
35924 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
35925 }
35926
35927 fail:
35928 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
35929 return NULL;
35930 }
35931
35932
35933 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35934 PyObject *resultobj = 0;
35935 wxWindow *arg1 = (wxWindow *) 0 ;
35936 long arg2 = (long) wxUPDATE_UI_NONE ;
35937 void *argp1 = 0 ;
35938 int res1 = 0 ;
35939 long val2 ;
35940 int ecode2 = 0 ;
35941 PyObject * obj0 = 0 ;
35942 PyObject * obj1 = 0 ;
35943 char * kwnames[] = {
35944 (char *) "self",(char *) "flags", NULL
35945 };
35946
35947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
35948 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35949 if (!SWIG_IsOK(res1)) {
35950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
35951 }
35952 arg1 = reinterpret_cast< wxWindow * >(argp1);
35953 if (obj1) {
35954 ecode2 = SWIG_AsVal_long(obj1, &val2);
35955 if (!SWIG_IsOK(ecode2)) {
35956 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
35957 }
35958 arg2 = static_cast< long >(val2);
35959 }
35960 {
35961 PyThreadState* __tstate = wxPyBeginAllowThreads();
35962 (arg1)->UpdateWindowUI(arg2);
35963 wxPyEndAllowThreads(__tstate);
35964 if (PyErr_Occurred()) SWIG_fail;
35965 }
35966 resultobj = SWIG_Py_Void();
35967 return resultobj;
35968 fail:
35969 return NULL;
35970 }
35971
35972
35973 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35974 PyObject *resultobj = 0;
35975 wxWindow *arg1 = (wxWindow *) 0 ;
35976 wxMenu *arg2 = (wxMenu *) 0 ;
35977 int arg3 = (int) -1 ;
35978 int arg4 = (int) -1 ;
35979 bool result;
35980 void *argp1 = 0 ;
35981 int res1 = 0 ;
35982 void *argp2 = 0 ;
35983 int res2 = 0 ;
35984 int val3 ;
35985 int ecode3 = 0 ;
35986 int val4 ;
35987 int ecode4 = 0 ;
35988 PyObject * obj0 = 0 ;
35989 PyObject * obj1 = 0 ;
35990 PyObject * obj2 = 0 ;
35991 PyObject * obj3 = 0 ;
35992 char * kwnames[] = {
35993 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
35994 };
35995
35996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35997 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35998 if (!SWIG_IsOK(res1)) {
35999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
36000 }
36001 arg1 = reinterpret_cast< wxWindow * >(argp1);
36002 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36003 if (!SWIG_IsOK(res2)) {
36004 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
36005 }
36006 arg2 = reinterpret_cast< wxMenu * >(argp2);
36007 if (obj2) {
36008 ecode3 = SWIG_AsVal_int(obj2, &val3);
36009 if (!SWIG_IsOK(ecode3)) {
36010 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
36011 }
36012 arg3 = static_cast< int >(val3);
36013 }
36014 if (obj3) {
36015 ecode4 = SWIG_AsVal_int(obj3, &val4);
36016 if (!SWIG_IsOK(ecode4)) {
36017 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
36018 }
36019 arg4 = static_cast< int >(val4);
36020 }
36021 {
36022 PyThreadState* __tstate = wxPyBeginAllowThreads();
36023 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
36024 wxPyEndAllowThreads(__tstate);
36025 if (PyErr_Occurred()) SWIG_fail;
36026 }
36027 {
36028 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36029 }
36030 return resultobj;
36031 fail:
36032 return NULL;
36033 }
36034
36035
36036 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36037 PyObject *resultobj = 0;
36038 wxWindow *arg1 = (wxWindow *) 0 ;
36039 wxMenu *arg2 = (wxMenu *) 0 ;
36040 wxPoint const &arg3_defvalue = wxDefaultPosition ;
36041 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
36042 bool result;
36043 void *argp1 = 0 ;
36044 int res1 = 0 ;
36045 void *argp2 = 0 ;
36046 int res2 = 0 ;
36047 wxPoint temp3 ;
36048 PyObject * obj0 = 0 ;
36049 PyObject * obj1 = 0 ;
36050 PyObject * obj2 = 0 ;
36051 char * kwnames[] = {
36052 (char *) "self",(char *) "menu",(char *) "pos", NULL
36053 };
36054
36055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36056 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36057 if (!SWIG_IsOK(res1)) {
36058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
36059 }
36060 arg1 = reinterpret_cast< wxWindow * >(argp1);
36061 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36062 if (!SWIG_IsOK(res2)) {
36063 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
36064 }
36065 arg2 = reinterpret_cast< wxMenu * >(argp2);
36066 if (obj2) {
36067 {
36068 arg3 = &temp3;
36069 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
36070 }
36071 }
36072 {
36073 PyThreadState* __tstate = wxPyBeginAllowThreads();
36074 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
36075 wxPyEndAllowThreads(__tstate);
36076 if (PyErr_Occurred()) SWIG_fail;
36077 }
36078 {
36079 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36080 }
36081 return resultobj;
36082 fail:
36083 return NULL;
36084 }
36085
36086
36087 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36088 PyObject *resultobj = 0;
36089 wxWindow *arg1 = (wxWindow *) 0 ;
36090 long result;
36091 void *argp1 = 0 ;
36092 int res1 = 0 ;
36093 PyObject *swig_obj[1] ;
36094
36095 if (!args) SWIG_fail;
36096 swig_obj[0] = args;
36097 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36098 if (!SWIG_IsOK(res1)) {
36099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36100 }
36101 arg1 = reinterpret_cast< wxWindow * >(argp1);
36102 {
36103 PyThreadState* __tstate = wxPyBeginAllowThreads();
36104 result = (long)wxWindow_GetHandle(arg1);
36105 wxPyEndAllowThreads(__tstate);
36106 if (PyErr_Occurred()) SWIG_fail;
36107 }
36108 resultobj = SWIG_From_long(static_cast< long >(result));
36109 return resultobj;
36110 fail:
36111 return NULL;
36112 }
36113
36114
36115 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36116 PyObject *resultobj = 0;
36117 wxWindow *arg1 = (wxWindow *) 0 ;
36118 long arg2 ;
36119 void *argp1 = 0 ;
36120 int res1 = 0 ;
36121 long val2 ;
36122 int ecode2 = 0 ;
36123 PyObject * obj0 = 0 ;
36124 PyObject * obj1 = 0 ;
36125 char * kwnames[] = {
36126 (char *) "self",(char *) "handle", NULL
36127 };
36128
36129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
36130 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36131 if (!SWIG_IsOK(res1)) {
36132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36133 }
36134 arg1 = reinterpret_cast< wxWindow * >(argp1);
36135 ecode2 = SWIG_AsVal_long(obj1, &val2);
36136 if (!SWIG_IsOK(ecode2)) {
36137 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
36138 }
36139 arg2 = static_cast< long >(val2);
36140 {
36141 PyThreadState* __tstate = wxPyBeginAllowThreads();
36142 wxWindow_AssociateHandle(arg1,arg2);
36143 wxPyEndAllowThreads(__tstate);
36144 if (PyErr_Occurred()) SWIG_fail;
36145 }
36146 resultobj = SWIG_Py_Void();
36147 return resultobj;
36148 fail:
36149 return NULL;
36150 }
36151
36152
36153 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36154 PyObject *resultobj = 0;
36155 wxWindow *arg1 = (wxWindow *) 0 ;
36156 void *argp1 = 0 ;
36157 int res1 = 0 ;
36158 PyObject *swig_obj[1] ;
36159
36160 if (!args) SWIG_fail;
36161 swig_obj[0] = args;
36162 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36163 if (!SWIG_IsOK(res1)) {
36164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36165 }
36166 arg1 = reinterpret_cast< wxWindow * >(argp1);
36167 {
36168 PyThreadState* __tstate = wxPyBeginAllowThreads();
36169 (arg1)->DissociateHandle();
36170 wxPyEndAllowThreads(__tstate);
36171 if (PyErr_Occurred()) SWIG_fail;
36172 }
36173 resultobj = SWIG_Py_Void();
36174 return resultobj;
36175 fail:
36176 return NULL;
36177 }
36178
36179
36180 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36181 PyObject *resultobj = 0;
36182 wxWindow *arg1 = (wxWindow *) 0 ;
36183 int arg2 ;
36184 bool result;
36185 void *argp1 = 0 ;
36186 int res1 = 0 ;
36187 int val2 ;
36188 int ecode2 = 0 ;
36189 PyObject * obj0 = 0 ;
36190 PyObject * obj1 = 0 ;
36191 char * kwnames[] = {
36192 (char *) "self",(char *) "orient", NULL
36193 };
36194
36195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
36196 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36197 if (!SWIG_IsOK(res1)) {
36198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
36199 }
36200 arg1 = reinterpret_cast< wxWindow * >(argp1);
36201 ecode2 = SWIG_AsVal_int(obj1, &val2);
36202 if (!SWIG_IsOK(ecode2)) {
36203 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
36204 }
36205 arg2 = static_cast< int >(val2);
36206 {
36207 PyThreadState* __tstate = wxPyBeginAllowThreads();
36208 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
36209 wxPyEndAllowThreads(__tstate);
36210 if (PyErr_Occurred()) SWIG_fail;
36211 }
36212 {
36213 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36214 }
36215 return resultobj;
36216 fail:
36217 return NULL;
36218 }
36219
36220
36221 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36222 PyObject *resultobj = 0;
36223 wxWindow *arg1 = (wxWindow *) 0 ;
36224 int arg2 ;
36225 int arg3 ;
36226 int arg4 ;
36227 int arg5 ;
36228 bool arg6 = (bool) true ;
36229 void *argp1 = 0 ;
36230 int res1 = 0 ;
36231 int val2 ;
36232 int ecode2 = 0 ;
36233 int val3 ;
36234 int ecode3 = 0 ;
36235 int val4 ;
36236 int ecode4 = 0 ;
36237 int val5 ;
36238 int ecode5 = 0 ;
36239 bool val6 ;
36240 int ecode6 = 0 ;
36241 PyObject * obj0 = 0 ;
36242 PyObject * obj1 = 0 ;
36243 PyObject * obj2 = 0 ;
36244 PyObject * obj3 = 0 ;
36245 PyObject * obj4 = 0 ;
36246 PyObject * obj5 = 0 ;
36247 char * kwnames[] = {
36248 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
36249 };
36250
36251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
36252 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36253 if (!SWIG_IsOK(res1)) {
36254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
36255 }
36256 arg1 = reinterpret_cast< wxWindow * >(argp1);
36257 ecode2 = SWIG_AsVal_int(obj1, &val2);
36258 if (!SWIG_IsOK(ecode2)) {
36259 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
36260 }
36261 arg2 = static_cast< int >(val2);
36262 ecode3 = SWIG_AsVal_int(obj2, &val3);
36263 if (!SWIG_IsOK(ecode3)) {
36264 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
36265 }
36266 arg3 = static_cast< int >(val3);
36267 ecode4 = SWIG_AsVal_int(obj3, &val4);
36268 if (!SWIG_IsOK(ecode4)) {
36269 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
36270 }
36271 arg4 = static_cast< int >(val4);
36272 ecode5 = SWIG_AsVal_int(obj4, &val5);
36273 if (!SWIG_IsOK(ecode5)) {
36274 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
36275 }
36276 arg5 = static_cast< int >(val5);
36277 if (obj5) {
36278 ecode6 = SWIG_AsVal_bool(obj5, &val6);
36279 if (!SWIG_IsOK(ecode6)) {
36280 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
36281 }
36282 arg6 = static_cast< bool >(val6);
36283 }
36284 {
36285 PyThreadState* __tstate = wxPyBeginAllowThreads();
36286 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
36287 wxPyEndAllowThreads(__tstate);
36288 if (PyErr_Occurred()) SWIG_fail;
36289 }
36290 resultobj = SWIG_Py_Void();
36291 return resultobj;
36292 fail:
36293 return NULL;
36294 }
36295
36296
36297 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36298 PyObject *resultobj = 0;
36299 wxWindow *arg1 = (wxWindow *) 0 ;
36300 int arg2 ;
36301 int arg3 ;
36302 bool arg4 = (bool) true ;
36303 void *argp1 = 0 ;
36304 int res1 = 0 ;
36305 int val2 ;
36306 int ecode2 = 0 ;
36307 int val3 ;
36308 int ecode3 = 0 ;
36309 bool val4 ;
36310 int ecode4 = 0 ;
36311 PyObject * obj0 = 0 ;
36312 PyObject * obj1 = 0 ;
36313 PyObject * obj2 = 0 ;
36314 PyObject * obj3 = 0 ;
36315 char * kwnames[] = {
36316 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
36317 };
36318
36319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36320 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36321 if (!SWIG_IsOK(res1)) {
36322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
36323 }
36324 arg1 = reinterpret_cast< wxWindow * >(argp1);
36325 ecode2 = SWIG_AsVal_int(obj1, &val2);
36326 if (!SWIG_IsOK(ecode2)) {
36327 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
36328 }
36329 arg2 = static_cast< int >(val2);
36330 ecode3 = SWIG_AsVal_int(obj2, &val3);
36331 if (!SWIG_IsOK(ecode3)) {
36332 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
36333 }
36334 arg3 = static_cast< int >(val3);
36335 if (obj3) {
36336 ecode4 = SWIG_AsVal_bool(obj3, &val4);
36337 if (!SWIG_IsOK(ecode4)) {
36338 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
36339 }
36340 arg4 = static_cast< bool >(val4);
36341 }
36342 {
36343 PyThreadState* __tstate = wxPyBeginAllowThreads();
36344 (arg1)->SetScrollPos(arg2,arg3,arg4);
36345 wxPyEndAllowThreads(__tstate);
36346 if (PyErr_Occurred()) SWIG_fail;
36347 }
36348 resultobj = SWIG_Py_Void();
36349 return resultobj;
36350 fail:
36351 return NULL;
36352 }
36353
36354
36355 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36356 PyObject *resultobj = 0;
36357 wxWindow *arg1 = (wxWindow *) 0 ;
36358 int arg2 ;
36359 int result;
36360 void *argp1 = 0 ;
36361 int res1 = 0 ;
36362 int val2 ;
36363 int ecode2 = 0 ;
36364 PyObject * obj0 = 0 ;
36365 PyObject * obj1 = 0 ;
36366 char * kwnames[] = {
36367 (char *) "self",(char *) "orientation", NULL
36368 };
36369
36370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
36371 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36372 if (!SWIG_IsOK(res1)) {
36373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
36374 }
36375 arg1 = reinterpret_cast< wxWindow * >(argp1);
36376 ecode2 = SWIG_AsVal_int(obj1, &val2);
36377 if (!SWIG_IsOK(ecode2)) {
36378 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
36379 }
36380 arg2 = static_cast< int >(val2);
36381 {
36382 PyThreadState* __tstate = wxPyBeginAllowThreads();
36383 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
36384 wxPyEndAllowThreads(__tstate);
36385 if (PyErr_Occurred()) SWIG_fail;
36386 }
36387 resultobj = SWIG_From_int(static_cast< int >(result));
36388 return resultobj;
36389 fail:
36390 return NULL;
36391 }
36392
36393
36394 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36395 PyObject *resultobj = 0;
36396 wxWindow *arg1 = (wxWindow *) 0 ;
36397 int arg2 ;
36398 int result;
36399 void *argp1 = 0 ;
36400 int res1 = 0 ;
36401 int val2 ;
36402 int ecode2 = 0 ;
36403 PyObject * obj0 = 0 ;
36404 PyObject * obj1 = 0 ;
36405 char * kwnames[] = {
36406 (char *) "self",(char *) "orientation", NULL
36407 };
36408
36409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
36410 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36411 if (!SWIG_IsOK(res1)) {
36412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
36413 }
36414 arg1 = reinterpret_cast< wxWindow * >(argp1);
36415 ecode2 = SWIG_AsVal_int(obj1, &val2);
36416 if (!SWIG_IsOK(ecode2)) {
36417 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
36418 }
36419 arg2 = static_cast< int >(val2);
36420 {
36421 PyThreadState* __tstate = wxPyBeginAllowThreads();
36422 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
36423 wxPyEndAllowThreads(__tstate);
36424 if (PyErr_Occurred()) SWIG_fail;
36425 }
36426 resultobj = SWIG_From_int(static_cast< int >(result));
36427 return resultobj;
36428 fail:
36429 return NULL;
36430 }
36431
36432
36433 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36434 PyObject *resultobj = 0;
36435 wxWindow *arg1 = (wxWindow *) 0 ;
36436 int arg2 ;
36437 int result;
36438 void *argp1 = 0 ;
36439 int res1 = 0 ;
36440 int val2 ;
36441 int ecode2 = 0 ;
36442 PyObject * obj0 = 0 ;
36443 PyObject * obj1 = 0 ;
36444 char * kwnames[] = {
36445 (char *) "self",(char *) "orientation", NULL
36446 };
36447
36448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
36449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36450 if (!SWIG_IsOK(res1)) {
36451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
36452 }
36453 arg1 = reinterpret_cast< wxWindow * >(argp1);
36454 ecode2 = SWIG_AsVal_int(obj1, &val2);
36455 if (!SWIG_IsOK(ecode2)) {
36456 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
36457 }
36458 arg2 = static_cast< int >(val2);
36459 {
36460 PyThreadState* __tstate = wxPyBeginAllowThreads();
36461 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
36462 wxPyEndAllowThreads(__tstate);
36463 if (PyErr_Occurred()) SWIG_fail;
36464 }
36465 resultobj = SWIG_From_int(static_cast< int >(result));
36466 return resultobj;
36467 fail:
36468 return NULL;
36469 }
36470
36471
36472 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36473 PyObject *resultobj = 0;
36474 wxWindow *arg1 = (wxWindow *) 0 ;
36475 int arg2 ;
36476 int arg3 ;
36477 wxRect *arg4 = (wxRect *) NULL ;
36478 void *argp1 = 0 ;
36479 int res1 = 0 ;
36480 int val2 ;
36481 int ecode2 = 0 ;
36482 int val3 ;
36483 int ecode3 = 0 ;
36484 void *argp4 = 0 ;
36485 int res4 = 0 ;
36486 PyObject * obj0 = 0 ;
36487 PyObject * obj1 = 0 ;
36488 PyObject * obj2 = 0 ;
36489 PyObject * obj3 = 0 ;
36490 char * kwnames[] = {
36491 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
36492 };
36493
36494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36496 if (!SWIG_IsOK(res1)) {
36497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36498 }
36499 arg1 = reinterpret_cast< wxWindow * >(argp1);
36500 ecode2 = SWIG_AsVal_int(obj1, &val2);
36501 if (!SWIG_IsOK(ecode2)) {
36502 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
36503 }
36504 arg2 = static_cast< int >(val2);
36505 ecode3 = SWIG_AsVal_int(obj2, &val3);
36506 if (!SWIG_IsOK(ecode3)) {
36507 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
36508 }
36509 arg3 = static_cast< int >(val3);
36510 if (obj3) {
36511 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
36512 if (!SWIG_IsOK(res4)) {
36513 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
36514 }
36515 arg4 = reinterpret_cast< wxRect * >(argp4);
36516 }
36517 {
36518 PyThreadState* __tstate = wxPyBeginAllowThreads();
36519 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
36520 wxPyEndAllowThreads(__tstate);
36521 if (PyErr_Occurred()) SWIG_fail;
36522 }
36523 resultobj = SWIG_Py_Void();
36524 return resultobj;
36525 fail:
36526 return NULL;
36527 }
36528
36529
36530 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36531 PyObject *resultobj = 0;
36532 wxWindow *arg1 = (wxWindow *) 0 ;
36533 int arg2 ;
36534 bool result;
36535 void *argp1 = 0 ;
36536 int res1 = 0 ;
36537 int val2 ;
36538 int ecode2 = 0 ;
36539 PyObject * obj0 = 0 ;
36540 PyObject * obj1 = 0 ;
36541 char * kwnames[] = {
36542 (char *) "self",(char *) "lines", NULL
36543 };
36544
36545 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
36546 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36547 if (!SWIG_IsOK(res1)) {
36548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
36549 }
36550 arg1 = reinterpret_cast< wxWindow * >(argp1);
36551 ecode2 = SWIG_AsVal_int(obj1, &val2);
36552 if (!SWIG_IsOK(ecode2)) {
36553 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
36554 }
36555 arg2 = static_cast< int >(val2);
36556 {
36557 PyThreadState* __tstate = wxPyBeginAllowThreads();
36558 result = (bool)(arg1)->ScrollLines(arg2);
36559 wxPyEndAllowThreads(__tstate);
36560 if (PyErr_Occurred()) SWIG_fail;
36561 }
36562 {
36563 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36564 }
36565 return resultobj;
36566 fail:
36567 return NULL;
36568 }
36569
36570
36571 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36572 PyObject *resultobj = 0;
36573 wxWindow *arg1 = (wxWindow *) 0 ;
36574 int arg2 ;
36575 bool result;
36576 void *argp1 = 0 ;
36577 int res1 = 0 ;
36578 int val2 ;
36579 int ecode2 = 0 ;
36580 PyObject * obj0 = 0 ;
36581 PyObject * obj1 = 0 ;
36582 char * kwnames[] = {
36583 (char *) "self",(char *) "pages", NULL
36584 };
36585
36586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
36587 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36588 if (!SWIG_IsOK(res1)) {
36589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
36590 }
36591 arg1 = reinterpret_cast< wxWindow * >(argp1);
36592 ecode2 = SWIG_AsVal_int(obj1, &val2);
36593 if (!SWIG_IsOK(ecode2)) {
36594 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
36595 }
36596 arg2 = static_cast< int >(val2);
36597 {
36598 PyThreadState* __tstate = wxPyBeginAllowThreads();
36599 result = (bool)(arg1)->ScrollPages(arg2);
36600 wxPyEndAllowThreads(__tstate);
36601 if (PyErr_Occurred()) SWIG_fail;
36602 }
36603 {
36604 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36605 }
36606 return resultobj;
36607 fail:
36608 return NULL;
36609 }
36610
36611
36612 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36613 PyObject *resultobj = 0;
36614 wxWindow *arg1 = (wxWindow *) 0 ;
36615 bool result;
36616 void *argp1 = 0 ;
36617 int res1 = 0 ;
36618 PyObject *swig_obj[1] ;
36619
36620 if (!args) SWIG_fail;
36621 swig_obj[0] = args;
36622 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36623 if (!SWIG_IsOK(res1)) {
36624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36625 }
36626 arg1 = reinterpret_cast< wxWindow * >(argp1);
36627 {
36628 PyThreadState* __tstate = wxPyBeginAllowThreads();
36629 result = (bool)(arg1)->LineUp();
36630 wxPyEndAllowThreads(__tstate);
36631 if (PyErr_Occurred()) SWIG_fail;
36632 }
36633 {
36634 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36635 }
36636 return resultobj;
36637 fail:
36638 return NULL;
36639 }
36640
36641
36642 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36643 PyObject *resultobj = 0;
36644 wxWindow *arg1 = (wxWindow *) 0 ;
36645 bool result;
36646 void *argp1 = 0 ;
36647 int res1 = 0 ;
36648 PyObject *swig_obj[1] ;
36649
36650 if (!args) SWIG_fail;
36651 swig_obj[0] = args;
36652 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36653 if (!SWIG_IsOK(res1)) {
36654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36655 }
36656 arg1 = reinterpret_cast< wxWindow * >(argp1);
36657 {
36658 PyThreadState* __tstate = wxPyBeginAllowThreads();
36659 result = (bool)(arg1)->LineDown();
36660 wxPyEndAllowThreads(__tstate);
36661 if (PyErr_Occurred()) SWIG_fail;
36662 }
36663 {
36664 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36665 }
36666 return resultobj;
36667 fail:
36668 return NULL;
36669 }
36670
36671
36672 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36673 PyObject *resultobj = 0;
36674 wxWindow *arg1 = (wxWindow *) 0 ;
36675 bool result;
36676 void *argp1 = 0 ;
36677 int res1 = 0 ;
36678 PyObject *swig_obj[1] ;
36679
36680 if (!args) SWIG_fail;
36681 swig_obj[0] = args;
36682 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36683 if (!SWIG_IsOK(res1)) {
36684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36685 }
36686 arg1 = reinterpret_cast< wxWindow * >(argp1);
36687 {
36688 PyThreadState* __tstate = wxPyBeginAllowThreads();
36689 result = (bool)(arg1)->PageUp();
36690 wxPyEndAllowThreads(__tstate);
36691 if (PyErr_Occurred()) SWIG_fail;
36692 }
36693 {
36694 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36695 }
36696 return resultobj;
36697 fail:
36698 return NULL;
36699 }
36700
36701
36702 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36703 PyObject *resultobj = 0;
36704 wxWindow *arg1 = (wxWindow *) 0 ;
36705 bool result;
36706 void *argp1 = 0 ;
36707 int res1 = 0 ;
36708 PyObject *swig_obj[1] ;
36709
36710 if (!args) SWIG_fail;
36711 swig_obj[0] = args;
36712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36713 if (!SWIG_IsOK(res1)) {
36714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36715 }
36716 arg1 = reinterpret_cast< wxWindow * >(argp1);
36717 {
36718 PyThreadState* __tstate = wxPyBeginAllowThreads();
36719 result = (bool)(arg1)->PageDown();
36720 wxPyEndAllowThreads(__tstate);
36721 if (PyErr_Occurred()) SWIG_fail;
36722 }
36723 {
36724 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36725 }
36726 return resultobj;
36727 fail:
36728 return NULL;
36729 }
36730
36731
36732 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36733 PyObject *resultobj = 0;
36734 wxWindow *arg1 = (wxWindow *) 0 ;
36735 wxString *arg2 = 0 ;
36736 void *argp1 = 0 ;
36737 int res1 = 0 ;
36738 bool temp2 = false ;
36739 PyObject * obj0 = 0 ;
36740 PyObject * obj1 = 0 ;
36741 char * kwnames[] = {
36742 (char *) "self",(char *) "text", NULL
36743 };
36744
36745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
36746 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36747 if (!SWIG_IsOK(res1)) {
36748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
36749 }
36750 arg1 = reinterpret_cast< wxWindow * >(argp1);
36751 {
36752 arg2 = wxString_in_helper(obj1);
36753 if (arg2 == NULL) SWIG_fail;
36754 temp2 = true;
36755 }
36756 {
36757 PyThreadState* __tstate = wxPyBeginAllowThreads();
36758 (arg1)->SetHelpText((wxString const &)*arg2);
36759 wxPyEndAllowThreads(__tstate);
36760 if (PyErr_Occurred()) SWIG_fail;
36761 }
36762 resultobj = SWIG_Py_Void();
36763 {
36764 if (temp2)
36765 delete arg2;
36766 }
36767 return resultobj;
36768 fail:
36769 {
36770 if (temp2)
36771 delete arg2;
36772 }
36773 return NULL;
36774 }
36775
36776
36777 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36778 PyObject *resultobj = 0;
36779 wxWindow *arg1 = (wxWindow *) 0 ;
36780 wxString *arg2 = 0 ;
36781 void *argp1 = 0 ;
36782 int res1 = 0 ;
36783 bool temp2 = false ;
36784 PyObject * obj0 = 0 ;
36785 PyObject * obj1 = 0 ;
36786 char * kwnames[] = {
36787 (char *) "self",(char *) "text", NULL
36788 };
36789
36790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
36791 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36792 if (!SWIG_IsOK(res1)) {
36793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
36794 }
36795 arg1 = reinterpret_cast< wxWindow * >(argp1);
36796 {
36797 arg2 = wxString_in_helper(obj1);
36798 if (arg2 == NULL) SWIG_fail;
36799 temp2 = true;
36800 }
36801 {
36802 PyThreadState* __tstate = wxPyBeginAllowThreads();
36803 (arg1)->SetHelpTextForId((wxString const &)*arg2);
36804 wxPyEndAllowThreads(__tstate);
36805 if (PyErr_Occurred()) SWIG_fail;
36806 }
36807 resultobj = SWIG_Py_Void();
36808 {
36809 if (temp2)
36810 delete arg2;
36811 }
36812 return resultobj;
36813 fail:
36814 {
36815 if (temp2)
36816 delete arg2;
36817 }
36818 return NULL;
36819 }
36820
36821
36822 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36823 PyObject *resultobj = 0;
36824 wxWindow *arg1 = (wxWindow *) 0 ;
36825 wxString result;
36826 void *argp1 = 0 ;
36827 int res1 = 0 ;
36828 PyObject *swig_obj[1] ;
36829
36830 if (!args) SWIG_fail;
36831 swig_obj[0] = args;
36832 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36833 if (!SWIG_IsOK(res1)) {
36834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
36835 }
36836 arg1 = reinterpret_cast< wxWindow * >(argp1);
36837 {
36838 PyThreadState* __tstate = wxPyBeginAllowThreads();
36839 result = ((wxWindow const *)arg1)->GetHelpText();
36840 wxPyEndAllowThreads(__tstate);
36841 if (PyErr_Occurred()) SWIG_fail;
36842 }
36843 {
36844 #if wxUSE_UNICODE
36845 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36846 #else
36847 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36848 #endif
36849 }
36850 return resultobj;
36851 fail:
36852 return NULL;
36853 }
36854
36855
36856 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36857 PyObject *resultobj = 0;
36858 wxWindow *arg1 = (wxWindow *) 0 ;
36859 wxString *arg2 = 0 ;
36860 void *argp1 = 0 ;
36861 int res1 = 0 ;
36862 bool temp2 = false ;
36863 PyObject * obj0 = 0 ;
36864 PyObject * obj1 = 0 ;
36865 char * kwnames[] = {
36866 (char *) "self",(char *) "tip", NULL
36867 };
36868
36869 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
36870 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36871 if (!SWIG_IsOK(res1)) {
36872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
36873 }
36874 arg1 = reinterpret_cast< wxWindow * >(argp1);
36875 {
36876 arg2 = wxString_in_helper(obj1);
36877 if (arg2 == NULL) SWIG_fail;
36878 temp2 = true;
36879 }
36880 {
36881 PyThreadState* __tstate = wxPyBeginAllowThreads();
36882 (arg1)->SetToolTip((wxString const &)*arg2);
36883 wxPyEndAllowThreads(__tstate);
36884 if (PyErr_Occurred()) SWIG_fail;
36885 }
36886 resultobj = SWIG_Py_Void();
36887 {
36888 if (temp2)
36889 delete arg2;
36890 }
36891 return resultobj;
36892 fail:
36893 {
36894 if (temp2)
36895 delete arg2;
36896 }
36897 return NULL;
36898 }
36899
36900
36901 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36902 PyObject *resultobj = 0;
36903 wxWindow *arg1 = (wxWindow *) 0 ;
36904 wxToolTip *arg2 = (wxToolTip *) 0 ;
36905 void *argp1 = 0 ;
36906 int res1 = 0 ;
36907 int res2 = 0 ;
36908 PyObject * obj0 = 0 ;
36909 PyObject * obj1 = 0 ;
36910 char * kwnames[] = {
36911 (char *) "self",(char *) "tip", NULL
36912 };
36913
36914 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
36915 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36916 if (!SWIG_IsOK(res1)) {
36917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
36918 }
36919 arg1 = reinterpret_cast< wxWindow * >(argp1);
36920 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
36921 if (!SWIG_IsOK(res2)) {
36922 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
36923 }
36924 {
36925 PyThreadState* __tstate = wxPyBeginAllowThreads();
36926 (arg1)->SetToolTip(arg2);
36927 wxPyEndAllowThreads(__tstate);
36928 if (PyErr_Occurred()) SWIG_fail;
36929 }
36930 resultobj = SWIG_Py_Void();
36931 return resultobj;
36932 fail:
36933 return NULL;
36934 }
36935
36936
36937 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36938 PyObject *resultobj = 0;
36939 wxWindow *arg1 = (wxWindow *) 0 ;
36940 wxToolTip *result = 0 ;
36941 void *argp1 = 0 ;
36942 int res1 = 0 ;
36943 PyObject *swig_obj[1] ;
36944
36945 if (!args) SWIG_fail;
36946 swig_obj[0] = args;
36947 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36948 if (!SWIG_IsOK(res1)) {
36949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
36950 }
36951 arg1 = reinterpret_cast< wxWindow * >(argp1);
36952 {
36953 PyThreadState* __tstate = wxPyBeginAllowThreads();
36954 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
36955 wxPyEndAllowThreads(__tstate);
36956 if (PyErr_Occurred()) SWIG_fail;
36957 }
36958 {
36959 resultobj = wxPyMake_wxObject(result, (bool)0);
36960 }
36961 return resultobj;
36962 fail:
36963 return NULL;
36964 }
36965
36966
36967 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36968 PyObject *resultobj = 0;
36969 wxWindow *arg1 = (wxWindow *) 0 ;
36970 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
36971 void *argp1 = 0 ;
36972 int res1 = 0 ;
36973 int res2 = 0 ;
36974 PyObject * obj0 = 0 ;
36975 PyObject * obj1 = 0 ;
36976 char * kwnames[] = {
36977 (char *) "self",(char *) "dropTarget", NULL
36978 };
36979
36980 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
36981 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36982 if (!SWIG_IsOK(res1)) {
36983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
36984 }
36985 arg1 = reinterpret_cast< wxWindow * >(argp1);
36986 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
36987 if (!SWIG_IsOK(res2)) {
36988 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
36989 }
36990 {
36991 PyThreadState* __tstate = wxPyBeginAllowThreads();
36992 (arg1)->SetDropTarget(arg2);
36993 wxPyEndAllowThreads(__tstate);
36994 if (PyErr_Occurred()) SWIG_fail;
36995 }
36996 resultobj = SWIG_Py_Void();
36997 return resultobj;
36998 fail:
36999 return NULL;
37000 }
37001
37002
37003 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37004 PyObject *resultobj = 0;
37005 wxWindow *arg1 = (wxWindow *) 0 ;
37006 wxPyDropTarget *result = 0 ;
37007 void *argp1 = 0 ;
37008 int res1 = 0 ;
37009 PyObject *swig_obj[1] ;
37010
37011 if (!args) SWIG_fail;
37012 swig_obj[0] = args;
37013 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37014 if (!SWIG_IsOK(res1)) {
37015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
37016 }
37017 arg1 = reinterpret_cast< wxWindow * >(argp1);
37018 {
37019 PyThreadState* __tstate = wxPyBeginAllowThreads();
37020 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
37021 wxPyEndAllowThreads(__tstate);
37022 if (PyErr_Occurred()) SWIG_fail;
37023 }
37024 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
37025 return resultobj;
37026 fail:
37027 return NULL;
37028 }
37029
37030
37031 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37032 PyObject *resultobj = 0;
37033 wxWindow *arg1 = (wxWindow *) 0 ;
37034 bool arg2 ;
37035 void *argp1 = 0 ;
37036 int res1 = 0 ;
37037 bool val2 ;
37038 int ecode2 = 0 ;
37039 PyObject * obj0 = 0 ;
37040 PyObject * obj1 = 0 ;
37041 char * kwnames[] = {
37042 (char *) "self",(char *) "accept", NULL
37043 };
37044
37045 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
37046 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37047 if (!SWIG_IsOK(res1)) {
37048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
37049 }
37050 arg1 = reinterpret_cast< wxWindow * >(argp1);
37051 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37052 if (!SWIG_IsOK(ecode2)) {
37053 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
37054 }
37055 arg2 = static_cast< bool >(val2);
37056 {
37057 PyThreadState* __tstate = wxPyBeginAllowThreads();
37058 wxWindow_DragAcceptFiles(arg1,arg2);
37059 wxPyEndAllowThreads(__tstate);
37060 if (PyErr_Occurred()) SWIG_fail;
37061 }
37062 resultobj = SWIG_Py_Void();
37063 return resultobj;
37064 fail:
37065 return NULL;
37066 }
37067
37068
37069 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37070 PyObject *resultobj = 0;
37071 wxWindow *arg1 = (wxWindow *) 0 ;
37072 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
37073 void *argp1 = 0 ;
37074 int res1 = 0 ;
37075 int res2 = 0 ;
37076 PyObject * obj0 = 0 ;
37077 PyObject * obj1 = 0 ;
37078 char * kwnames[] = {
37079 (char *) "self",(char *) "constraints", NULL
37080 };
37081
37082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
37083 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37084 if (!SWIG_IsOK(res1)) {
37085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
37086 }
37087 arg1 = reinterpret_cast< wxWindow * >(argp1);
37088 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
37089 if (!SWIG_IsOK(res2)) {
37090 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
37091 }
37092 {
37093 PyThreadState* __tstate = wxPyBeginAllowThreads();
37094 (arg1)->SetConstraints(arg2);
37095 wxPyEndAllowThreads(__tstate);
37096 if (PyErr_Occurred()) SWIG_fail;
37097 }
37098 resultobj = SWIG_Py_Void();
37099 return resultobj;
37100 fail:
37101 return NULL;
37102 }
37103
37104
37105 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37106 PyObject *resultobj = 0;
37107 wxWindow *arg1 = (wxWindow *) 0 ;
37108 wxLayoutConstraints *result = 0 ;
37109 void *argp1 = 0 ;
37110 int res1 = 0 ;
37111 PyObject *swig_obj[1] ;
37112
37113 if (!args) SWIG_fail;
37114 swig_obj[0] = args;
37115 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37116 if (!SWIG_IsOK(res1)) {
37117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
37118 }
37119 arg1 = reinterpret_cast< wxWindow * >(argp1);
37120 {
37121 PyThreadState* __tstate = wxPyBeginAllowThreads();
37122 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
37123 wxPyEndAllowThreads(__tstate);
37124 if (PyErr_Occurred()) SWIG_fail;
37125 }
37126 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
37127 return resultobj;
37128 fail:
37129 return NULL;
37130 }
37131
37132
37133 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37134 PyObject *resultobj = 0;
37135 wxWindow *arg1 = (wxWindow *) 0 ;
37136 bool arg2 ;
37137 void *argp1 = 0 ;
37138 int res1 = 0 ;
37139 bool val2 ;
37140 int ecode2 = 0 ;
37141 PyObject * obj0 = 0 ;
37142 PyObject * obj1 = 0 ;
37143 char * kwnames[] = {
37144 (char *) "self",(char *) "autoLayout", NULL
37145 };
37146
37147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
37148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37149 if (!SWIG_IsOK(res1)) {
37150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
37151 }
37152 arg1 = reinterpret_cast< wxWindow * >(argp1);
37153 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37154 if (!SWIG_IsOK(ecode2)) {
37155 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
37156 }
37157 arg2 = static_cast< bool >(val2);
37158 {
37159 PyThreadState* __tstate = wxPyBeginAllowThreads();
37160 (arg1)->SetAutoLayout(arg2);
37161 wxPyEndAllowThreads(__tstate);
37162 if (PyErr_Occurred()) SWIG_fail;
37163 }
37164 resultobj = SWIG_Py_Void();
37165 return resultobj;
37166 fail:
37167 return NULL;
37168 }
37169
37170
37171 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37172 PyObject *resultobj = 0;
37173 wxWindow *arg1 = (wxWindow *) 0 ;
37174 bool result;
37175 void *argp1 = 0 ;
37176 int res1 = 0 ;
37177 PyObject *swig_obj[1] ;
37178
37179 if (!args) SWIG_fail;
37180 swig_obj[0] = args;
37181 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37182 if (!SWIG_IsOK(res1)) {
37183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
37184 }
37185 arg1 = reinterpret_cast< wxWindow * >(argp1);
37186 {
37187 PyThreadState* __tstate = wxPyBeginAllowThreads();
37188 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
37189 wxPyEndAllowThreads(__tstate);
37190 if (PyErr_Occurred()) SWIG_fail;
37191 }
37192 {
37193 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37194 }
37195 return resultobj;
37196 fail:
37197 return NULL;
37198 }
37199
37200
37201 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37202 PyObject *resultobj = 0;
37203 wxWindow *arg1 = (wxWindow *) 0 ;
37204 bool result;
37205 void *argp1 = 0 ;
37206 int res1 = 0 ;
37207 PyObject *swig_obj[1] ;
37208
37209 if (!args) SWIG_fail;
37210 swig_obj[0] = args;
37211 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37212 if (!SWIG_IsOK(res1)) {
37213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
37214 }
37215 arg1 = reinterpret_cast< wxWindow * >(argp1);
37216 {
37217 PyThreadState* __tstate = wxPyBeginAllowThreads();
37218 result = (bool)(arg1)->Layout();
37219 wxPyEndAllowThreads(__tstate);
37220 if (PyErr_Occurred()) SWIG_fail;
37221 }
37222 {
37223 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37224 }
37225 return resultobj;
37226 fail:
37227 return NULL;
37228 }
37229
37230
37231 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37232 PyObject *resultobj = 0;
37233 wxWindow *arg1 = (wxWindow *) 0 ;
37234 wxSizer *arg2 = (wxSizer *) 0 ;
37235 bool arg3 = (bool) true ;
37236 void *argp1 = 0 ;
37237 int res1 = 0 ;
37238 int res2 = 0 ;
37239 bool val3 ;
37240 int ecode3 = 0 ;
37241 PyObject * obj0 = 0 ;
37242 PyObject * obj1 = 0 ;
37243 PyObject * obj2 = 0 ;
37244 char * kwnames[] = {
37245 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37246 };
37247
37248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37250 if (!SWIG_IsOK(res1)) {
37251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37252 }
37253 arg1 = reinterpret_cast< wxWindow * >(argp1);
37254 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37255 if (!SWIG_IsOK(res2)) {
37256 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37257 }
37258 if (obj2) {
37259 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37260 if (!SWIG_IsOK(ecode3)) {
37261 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
37262 }
37263 arg3 = static_cast< bool >(val3);
37264 }
37265 {
37266 PyThreadState* __tstate = wxPyBeginAllowThreads();
37267 (arg1)->SetSizer(arg2,arg3);
37268 wxPyEndAllowThreads(__tstate);
37269 if (PyErr_Occurred()) SWIG_fail;
37270 }
37271 resultobj = SWIG_Py_Void();
37272 return resultobj;
37273 fail:
37274 return NULL;
37275 }
37276
37277
37278 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37279 PyObject *resultobj = 0;
37280 wxWindow *arg1 = (wxWindow *) 0 ;
37281 wxSizer *arg2 = (wxSizer *) 0 ;
37282 bool arg3 = (bool) true ;
37283 void *argp1 = 0 ;
37284 int res1 = 0 ;
37285 int res2 = 0 ;
37286 bool val3 ;
37287 int ecode3 = 0 ;
37288 PyObject * obj0 = 0 ;
37289 PyObject * obj1 = 0 ;
37290 PyObject * obj2 = 0 ;
37291 char * kwnames[] = {
37292 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37293 };
37294
37295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37296 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37297 if (!SWIG_IsOK(res1)) {
37298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
37299 }
37300 arg1 = reinterpret_cast< wxWindow * >(argp1);
37301 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37302 if (!SWIG_IsOK(res2)) {
37303 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
37304 }
37305 if (obj2) {
37306 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37307 if (!SWIG_IsOK(ecode3)) {
37308 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
37309 }
37310 arg3 = static_cast< bool >(val3);
37311 }
37312 {
37313 PyThreadState* __tstate = wxPyBeginAllowThreads();
37314 (arg1)->SetSizerAndFit(arg2,arg3);
37315 wxPyEndAllowThreads(__tstate);
37316 if (PyErr_Occurred()) SWIG_fail;
37317 }
37318 resultobj = SWIG_Py_Void();
37319 return resultobj;
37320 fail:
37321 return NULL;
37322 }
37323
37324
37325 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37326 PyObject *resultobj = 0;
37327 wxWindow *arg1 = (wxWindow *) 0 ;
37328 wxSizer *result = 0 ;
37329 void *argp1 = 0 ;
37330 int res1 = 0 ;
37331 PyObject *swig_obj[1] ;
37332
37333 if (!args) SWIG_fail;
37334 swig_obj[0] = args;
37335 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37336 if (!SWIG_IsOK(res1)) {
37337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37338 }
37339 arg1 = reinterpret_cast< wxWindow * >(argp1);
37340 {
37341 PyThreadState* __tstate = wxPyBeginAllowThreads();
37342 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
37343 wxPyEndAllowThreads(__tstate);
37344 if (PyErr_Occurred()) SWIG_fail;
37345 }
37346 {
37347 resultobj = wxPyMake_wxObject(result, (bool)0);
37348 }
37349 return resultobj;
37350 fail:
37351 return NULL;
37352 }
37353
37354
37355 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37356 PyObject *resultobj = 0;
37357 wxWindow *arg1 = (wxWindow *) 0 ;
37358 wxSizer *arg2 = (wxSizer *) 0 ;
37359 void *argp1 = 0 ;
37360 int res1 = 0 ;
37361 void *argp2 = 0 ;
37362 int res2 = 0 ;
37363 PyObject * obj0 = 0 ;
37364 PyObject * obj1 = 0 ;
37365 char * kwnames[] = {
37366 (char *) "self",(char *) "sizer", NULL
37367 };
37368
37369 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
37370 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37371 if (!SWIG_IsOK(res1)) {
37372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37373 }
37374 arg1 = reinterpret_cast< wxWindow * >(argp1);
37375 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
37376 if (!SWIG_IsOK(res2)) {
37377 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37378 }
37379 arg2 = reinterpret_cast< wxSizer * >(argp2);
37380 {
37381 PyThreadState* __tstate = wxPyBeginAllowThreads();
37382 (arg1)->SetContainingSizer(arg2);
37383 wxPyEndAllowThreads(__tstate);
37384 if (PyErr_Occurred()) SWIG_fail;
37385 }
37386 resultobj = SWIG_Py_Void();
37387 return resultobj;
37388 fail:
37389 return NULL;
37390 }
37391
37392
37393 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37394 PyObject *resultobj = 0;
37395 wxWindow *arg1 = (wxWindow *) 0 ;
37396 wxSizer *result = 0 ;
37397 void *argp1 = 0 ;
37398 int res1 = 0 ;
37399 PyObject *swig_obj[1] ;
37400
37401 if (!args) SWIG_fail;
37402 swig_obj[0] = args;
37403 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37404 if (!SWIG_IsOK(res1)) {
37405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37406 }
37407 arg1 = reinterpret_cast< wxWindow * >(argp1);
37408 {
37409 PyThreadState* __tstate = wxPyBeginAllowThreads();
37410 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
37411 wxPyEndAllowThreads(__tstate);
37412 if (PyErr_Occurred()) SWIG_fail;
37413 }
37414 {
37415 resultobj = wxPyMake_wxObject(result, (bool)0);
37416 }
37417 return resultobj;
37418 fail:
37419 return NULL;
37420 }
37421
37422
37423 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37424 PyObject *resultobj = 0;
37425 wxWindow *arg1 = (wxWindow *) 0 ;
37426 void *argp1 = 0 ;
37427 int res1 = 0 ;
37428 PyObject *swig_obj[1] ;
37429
37430 if (!args) SWIG_fail;
37431 swig_obj[0] = args;
37432 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37433 if (!SWIG_IsOK(res1)) {
37434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
37435 }
37436 arg1 = reinterpret_cast< wxWindow * >(argp1);
37437 {
37438 PyThreadState* __tstate = wxPyBeginAllowThreads();
37439 (arg1)->InheritAttributes();
37440 wxPyEndAllowThreads(__tstate);
37441 if (PyErr_Occurred()) SWIG_fail;
37442 }
37443 resultobj = SWIG_Py_Void();
37444 return resultobj;
37445 fail:
37446 return NULL;
37447 }
37448
37449
37450 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37451 PyObject *resultobj = 0;
37452 wxWindow *arg1 = (wxWindow *) 0 ;
37453 bool result;
37454 void *argp1 = 0 ;
37455 int res1 = 0 ;
37456 PyObject *swig_obj[1] ;
37457
37458 if (!args) SWIG_fail;
37459 swig_obj[0] = args;
37460 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37461 if (!SWIG_IsOK(res1)) {
37462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
37463 }
37464 arg1 = reinterpret_cast< wxWindow * >(argp1);
37465 {
37466 PyThreadState* __tstate = wxPyBeginAllowThreads();
37467 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
37468 wxPyEndAllowThreads(__tstate);
37469 if (PyErr_Occurred()) SWIG_fail;
37470 }
37471 {
37472 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37473 }
37474 return resultobj;
37475 fail:
37476 return NULL;
37477 }
37478
37479
37480 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37481 PyObject *obj;
37482 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37483 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
37484 return SWIG_Py_Void();
37485 }
37486
37487 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37488 return SWIG_Python_InitShadowInstance(args);
37489 }
37490
37491 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37492 PyObject *resultobj = 0;
37493 long arg1 ;
37494 wxWindow *arg2 = (wxWindow *) NULL ;
37495 wxWindow *result = 0 ;
37496 long val1 ;
37497 int ecode1 = 0 ;
37498 void *argp2 = 0 ;
37499 int res2 = 0 ;
37500 PyObject * obj0 = 0 ;
37501 PyObject * obj1 = 0 ;
37502 char * kwnames[] = {
37503 (char *) "id",(char *) "parent", NULL
37504 };
37505
37506 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
37507 ecode1 = SWIG_AsVal_long(obj0, &val1);
37508 if (!SWIG_IsOK(ecode1)) {
37509 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
37510 }
37511 arg1 = static_cast< long >(val1);
37512 if (obj1) {
37513 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37514 if (!SWIG_IsOK(res2)) {
37515 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
37516 }
37517 arg2 = reinterpret_cast< wxWindow * >(argp2);
37518 }
37519 {
37520 if (!wxPyCheckForApp()) SWIG_fail;
37521 PyThreadState* __tstate = wxPyBeginAllowThreads();
37522 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
37523 wxPyEndAllowThreads(__tstate);
37524 if (PyErr_Occurred()) SWIG_fail;
37525 }
37526 {
37527 resultobj = wxPyMake_wxObject(result, 0);
37528 }
37529 return resultobj;
37530 fail:
37531 return NULL;
37532 }
37533
37534
37535 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37536 PyObject *resultobj = 0;
37537 wxString *arg1 = 0 ;
37538 wxWindow *arg2 = (wxWindow *) NULL ;
37539 wxWindow *result = 0 ;
37540 bool temp1 = false ;
37541 void *argp2 = 0 ;
37542 int res2 = 0 ;
37543 PyObject * obj0 = 0 ;
37544 PyObject * obj1 = 0 ;
37545 char * kwnames[] = {
37546 (char *) "name",(char *) "parent", NULL
37547 };
37548
37549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
37550 {
37551 arg1 = wxString_in_helper(obj0);
37552 if (arg1 == NULL) SWIG_fail;
37553 temp1 = true;
37554 }
37555 if (obj1) {
37556 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37557 if (!SWIG_IsOK(res2)) {
37558 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
37559 }
37560 arg2 = reinterpret_cast< wxWindow * >(argp2);
37561 }
37562 {
37563 if (!wxPyCheckForApp()) SWIG_fail;
37564 PyThreadState* __tstate = wxPyBeginAllowThreads();
37565 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
37566 wxPyEndAllowThreads(__tstate);
37567 if (PyErr_Occurred()) SWIG_fail;
37568 }
37569 {
37570 resultobj = wxPyMake_wxObject(result, 0);
37571 }
37572 {
37573 if (temp1)
37574 delete arg1;
37575 }
37576 return resultobj;
37577 fail:
37578 {
37579 if (temp1)
37580 delete arg1;
37581 }
37582 return NULL;
37583 }
37584
37585
37586 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37587 PyObject *resultobj = 0;
37588 wxString *arg1 = 0 ;
37589 wxWindow *arg2 = (wxWindow *) NULL ;
37590 wxWindow *result = 0 ;
37591 bool temp1 = false ;
37592 void *argp2 = 0 ;
37593 int res2 = 0 ;
37594 PyObject * obj0 = 0 ;
37595 PyObject * obj1 = 0 ;
37596 char * kwnames[] = {
37597 (char *) "label",(char *) "parent", NULL
37598 };
37599
37600 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
37601 {
37602 arg1 = wxString_in_helper(obj0);
37603 if (arg1 == NULL) SWIG_fail;
37604 temp1 = true;
37605 }
37606 if (obj1) {
37607 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37608 if (!SWIG_IsOK(res2)) {
37609 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
37610 }
37611 arg2 = reinterpret_cast< wxWindow * >(argp2);
37612 }
37613 {
37614 if (!wxPyCheckForApp()) SWIG_fail;
37615 PyThreadState* __tstate = wxPyBeginAllowThreads();
37616 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
37617 wxPyEndAllowThreads(__tstate);
37618 if (PyErr_Occurred()) SWIG_fail;
37619 }
37620 {
37621 resultobj = wxPyMake_wxObject(result, 0);
37622 }
37623 {
37624 if (temp1)
37625 delete arg1;
37626 }
37627 return resultobj;
37628 fail:
37629 {
37630 if (temp1)
37631 delete arg1;
37632 }
37633 return NULL;
37634 }
37635
37636
37637 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37638 PyObject *resultobj = 0;
37639 wxWindow *arg1 = (wxWindow *) 0 ;
37640 unsigned long arg2 ;
37641 wxWindow *result = 0 ;
37642 void *argp1 = 0 ;
37643 int res1 = 0 ;
37644 unsigned long val2 ;
37645 int ecode2 = 0 ;
37646 PyObject * obj0 = 0 ;
37647 PyObject * obj1 = 0 ;
37648 char * kwnames[] = {
37649 (char *) "parent",(char *) "_hWnd", NULL
37650 };
37651
37652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
37653 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37654 if (!SWIG_IsOK(res1)) {
37655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
37656 }
37657 arg1 = reinterpret_cast< wxWindow * >(argp1);
37658 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
37659 if (!SWIG_IsOK(ecode2)) {
37660 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
37661 }
37662 arg2 = static_cast< unsigned long >(val2);
37663 {
37664 PyThreadState* __tstate = wxPyBeginAllowThreads();
37665 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
37666 wxPyEndAllowThreads(__tstate);
37667 if (PyErr_Occurred()) SWIG_fail;
37668 }
37669 {
37670 resultobj = wxPyMake_wxObject(result, 0);
37671 }
37672 return resultobj;
37673 fail:
37674 return NULL;
37675 }
37676
37677
37678 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37679 PyObject *resultobj = 0;
37680 PyObject *result = 0 ;
37681
37682 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
37683 {
37684 PyThreadState* __tstate = wxPyBeginAllowThreads();
37685 result = (PyObject *)GetTopLevelWindows();
37686 wxPyEndAllowThreads(__tstate);
37687 if (PyErr_Occurred()) SWIG_fail;
37688 }
37689 resultobj = result;
37690 return resultobj;
37691 fail:
37692 return NULL;
37693 }
37694
37695
37696 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37697 PyObject *resultobj = 0;
37698 wxValidator *result = 0 ;
37699
37700 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
37701 {
37702 PyThreadState* __tstate = wxPyBeginAllowThreads();
37703 result = (wxValidator *)new wxValidator();
37704 wxPyEndAllowThreads(__tstate);
37705 if (PyErr_Occurred()) SWIG_fail;
37706 }
37707 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
37708 return resultobj;
37709 fail:
37710 return NULL;
37711 }
37712
37713
37714 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37715 PyObject *resultobj = 0;
37716 wxValidator *arg1 = (wxValidator *) 0 ;
37717 wxValidator *result = 0 ;
37718 void *argp1 = 0 ;
37719 int res1 = 0 ;
37720 PyObject *swig_obj[1] ;
37721
37722 if (!args) SWIG_fail;
37723 swig_obj[0] = args;
37724 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37725 if (!SWIG_IsOK(res1)) {
37726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
37727 }
37728 arg1 = reinterpret_cast< wxValidator * >(argp1);
37729 {
37730 PyThreadState* __tstate = wxPyBeginAllowThreads();
37731 result = (wxValidator *)(arg1)->Clone();
37732 wxPyEndAllowThreads(__tstate);
37733 if (PyErr_Occurred()) SWIG_fail;
37734 }
37735 {
37736 resultobj = wxPyMake_wxObject(result, 0);
37737 }
37738 return resultobj;
37739 fail:
37740 return NULL;
37741 }
37742
37743
37744 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37745 PyObject *resultobj = 0;
37746 wxValidator *arg1 = (wxValidator *) 0 ;
37747 wxWindow *arg2 = (wxWindow *) 0 ;
37748 bool result;
37749 void *argp1 = 0 ;
37750 int res1 = 0 ;
37751 void *argp2 = 0 ;
37752 int res2 = 0 ;
37753 PyObject * obj0 = 0 ;
37754 PyObject * obj1 = 0 ;
37755 char * kwnames[] = {
37756 (char *) "self",(char *) "parent", NULL
37757 };
37758
37759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
37760 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37761 if (!SWIG_IsOK(res1)) {
37762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
37763 }
37764 arg1 = reinterpret_cast< wxValidator * >(argp1);
37765 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37766 if (!SWIG_IsOK(res2)) {
37767 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
37768 }
37769 arg2 = reinterpret_cast< wxWindow * >(argp2);
37770 {
37771 PyThreadState* __tstate = wxPyBeginAllowThreads();
37772 result = (bool)(arg1)->Validate(arg2);
37773 wxPyEndAllowThreads(__tstate);
37774 if (PyErr_Occurred()) SWIG_fail;
37775 }
37776 {
37777 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37778 }
37779 return resultobj;
37780 fail:
37781 return NULL;
37782 }
37783
37784
37785 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37786 PyObject *resultobj = 0;
37787 wxValidator *arg1 = (wxValidator *) 0 ;
37788 bool result;
37789 void *argp1 = 0 ;
37790 int res1 = 0 ;
37791 PyObject *swig_obj[1] ;
37792
37793 if (!args) SWIG_fail;
37794 swig_obj[0] = args;
37795 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37796 if (!SWIG_IsOK(res1)) {
37797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37798 }
37799 arg1 = reinterpret_cast< wxValidator * >(argp1);
37800 {
37801 PyThreadState* __tstate = wxPyBeginAllowThreads();
37802 result = (bool)(arg1)->TransferToWindow();
37803 wxPyEndAllowThreads(__tstate);
37804 if (PyErr_Occurred()) SWIG_fail;
37805 }
37806 {
37807 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37808 }
37809 return resultobj;
37810 fail:
37811 return NULL;
37812 }
37813
37814
37815 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37816 PyObject *resultobj = 0;
37817 wxValidator *arg1 = (wxValidator *) 0 ;
37818 bool result;
37819 void *argp1 = 0 ;
37820 int res1 = 0 ;
37821 PyObject *swig_obj[1] ;
37822
37823 if (!args) SWIG_fail;
37824 swig_obj[0] = args;
37825 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37826 if (!SWIG_IsOK(res1)) {
37827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37828 }
37829 arg1 = reinterpret_cast< wxValidator * >(argp1);
37830 {
37831 PyThreadState* __tstate = wxPyBeginAllowThreads();
37832 result = (bool)(arg1)->TransferFromWindow();
37833 wxPyEndAllowThreads(__tstate);
37834 if (PyErr_Occurred()) SWIG_fail;
37835 }
37836 {
37837 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37838 }
37839 return resultobj;
37840 fail:
37841 return NULL;
37842 }
37843
37844
37845 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37846 PyObject *resultobj = 0;
37847 wxValidator *arg1 = (wxValidator *) 0 ;
37848 wxWindow *result = 0 ;
37849 void *argp1 = 0 ;
37850 int res1 = 0 ;
37851 PyObject *swig_obj[1] ;
37852
37853 if (!args) SWIG_fail;
37854 swig_obj[0] = args;
37855 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37856 if (!SWIG_IsOK(res1)) {
37857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37858 }
37859 arg1 = reinterpret_cast< wxValidator * >(argp1);
37860 {
37861 PyThreadState* __tstate = wxPyBeginAllowThreads();
37862 result = (wxWindow *)(arg1)->GetWindow();
37863 wxPyEndAllowThreads(__tstate);
37864 if (PyErr_Occurred()) SWIG_fail;
37865 }
37866 {
37867 resultobj = wxPyMake_wxObject(result, 0);
37868 }
37869 return resultobj;
37870 fail:
37871 return NULL;
37872 }
37873
37874
37875 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37876 PyObject *resultobj = 0;
37877 wxValidator *arg1 = (wxValidator *) 0 ;
37878 wxWindow *arg2 = (wxWindow *) 0 ;
37879 void *argp1 = 0 ;
37880 int res1 = 0 ;
37881 void *argp2 = 0 ;
37882 int res2 = 0 ;
37883 PyObject * obj0 = 0 ;
37884 PyObject * obj1 = 0 ;
37885 char * kwnames[] = {
37886 (char *) "self",(char *) "window", NULL
37887 };
37888
37889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
37890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37891 if (!SWIG_IsOK(res1)) {
37892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37893 }
37894 arg1 = reinterpret_cast< wxValidator * >(argp1);
37895 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37896 if (!SWIG_IsOK(res2)) {
37897 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
37898 }
37899 arg2 = reinterpret_cast< wxWindow * >(argp2);
37900 {
37901 PyThreadState* __tstate = wxPyBeginAllowThreads();
37902 (arg1)->SetWindow(arg2);
37903 wxPyEndAllowThreads(__tstate);
37904 if (PyErr_Occurred()) SWIG_fail;
37905 }
37906 resultobj = SWIG_Py_Void();
37907 return resultobj;
37908 fail:
37909 return NULL;
37910 }
37911
37912
37913 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37914 PyObject *resultobj = 0;
37915 bool result;
37916
37917 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
37918 {
37919 PyThreadState* __tstate = wxPyBeginAllowThreads();
37920 result = (bool)wxValidator::IsSilent();
37921 wxPyEndAllowThreads(__tstate);
37922 if (PyErr_Occurred()) SWIG_fail;
37923 }
37924 {
37925 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37926 }
37927 return resultobj;
37928 fail:
37929 return NULL;
37930 }
37931
37932
37933 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37934 PyObject *resultobj = 0;
37935 int arg1 = (int) true ;
37936 int val1 ;
37937 int ecode1 = 0 ;
37938 PyObject * obj0 = 0 ;
37939 char * kwnames[] = {
37940 (char *) "doIt", NULL
37941 };
37942
37943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
37944 if (obj0) {
37945 ecode1 = SWIG_AsVal_int(obj0, &val1);
37946 if (!SWIG_IsOK(ecode1)) {
37947 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
37948 }
37949 arg1 = static_cast< int >(val1);
37950 }
37951 {
37952 PyThreadState* __tstate = wxPyBeginAllowThreads();
37953 wxValidator::SetBellOnError(arg1);
37954 wxPyEndAllowThreads(__tstate);
37955 if (PyErr_Occurred()) SWIG_fail;
37956 }
37957 resultobj = SWIG_Py_Void();
37958 return resultobj;
37959 fail:
37960 return NULL;
37961 }
37962
37963
37964 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37965 PyObject *obj;
37966 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37967 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
37968 return SWIG_Py_Void();
37969 }
37970
37971 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37972 return SWIG_Python_InitShadowInstance(args);
37973 }
37974
37975 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37976 PyObject *resultobj = 0;
37977 wxPyValidator *result = 0 ;
37978
37979 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
37980 {
37981 PyThreadState* __tstate = wxPyBeginAllowThreads();
37982 result = (wxPyValidator *)new wxPyValidator();
37983 wxPyEndAllowThreads(__tstate);
37984 if (PyErr_Occurred()) SWIG_fail;
37985 }
37986 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
37987 return resultobj;
37988 fail:
37989 return NULL;
37990 }
37991
37992
37993 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37994 PyObject *resultobj = 0;
37995 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
37996 PyObject *arg2 = (PyObject *) 0 ;
37997 PyObject *arg3 = (PyObject *) 0 ;
37998 int arg4 = (int) true ;
37999 void *argp1 = 0 ;
38000 int res1 = 0 ;
38001 int val4 ;
38002 int ecode4 = 0 ;
38003 PyObject * obj0 = 0 ;
38004 PyObject * obj1 = 0 ;
38005 PyObject * obj2 = 0 ;
38006 PyObject * obj3 = 0 ;
38007 char * kwnames[] = {
38008 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
38009 };
38010
38011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
38013 if (!SWIG_IsOK(res1)) {
38014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
38015 }
38016 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
38017 arg2 = obj1;
38018 arg3 = obj2;
38019 if (obj3) {
38020 ecode4 = SWIG_AsVal_int(obj3, &val4);
38021 if (!SWIG_IsOK(ecode4)) {
38022 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
38023 }
38024 arg4 = static_cast< int >(val4);
38025 }
38026 {
38027 PyThreadState* __tstate = wxPyBeginAllowThreads();
38028 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
38029 wxPyEndAllowThreads(__tstate);
38030 if (PyErr_Occurred()) SWIG_fail;
38031 }
38032 resultobj = SWIG_Py_Void();
38033 return resultobj;
38034 fail:
38035 return NULL;
38036 }
38037
38038
38039 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38040 PyObject *obj;
38041 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38042 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
38043 return SWIG_Py_Void();
38044 }
38045
38046 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38047 return SWIG_Python_InitShadowInstance(args);
38048 }
38049
38050 SWIGINTERN int DefaultValidator_set(PyObject *) {
38051 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
38052 return 1;
38053 }
38054
38055
38056 SWIGINTERN PyObject *DefaultValidator_get(void) {
38057 PyObject *pyobj = 0;
38058
38059 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
38060 return pyobj;
38061 }
38062
38063
38064 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38065 PyObject *resultobj = 0;
38066 wxString const &arg1_defvalue = wxPyEmptyString ;
38067 wxString *arg1 = (wxString *) &arg1_defvalue ;
38068 long arg2 = (long) 0 ;
38069 wxMenu *result = 0 ;
38070 bool temp1 = false ;
38071 long val2 ;
38072 int ecode2 = 0 ;
38073 PyObject * obj0 = 0 ;
38074 PyObject * obj1 = 0 ;
38075 char * kwnames[] = {
38076 (char *) "title",(char *) "style", NULL
38077 };
38078
38079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
38080 if (obj0) {
38081 {
38082 arg1 = wxString_in_helper(obj0);
38083 if (arg1 == NULL) SWIG_fail;
38084 temp1 = true;
38085 }
38086 }
38087 if (obj1) {
38088 ecode2 = SWIG_AsVal_long(obj1, &val2);
38089 if (!SWIG_IsOK(ecode2)) {
38090 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
38091 }
38092 arg2 = static_cast< long >(val2);
38093 }
38094 {
38095 if (!wxPyCheckForApp()) SWIG_fail;
38096 PyThreadState* __tstate = wxPyBeginAllowThreads();
38097 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
38098 wxPyEndAllowThreads(__tstate);
38099 if (PyErr_Occurred()) SWIG_fail;
38100 }
38101 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
38102 {
38103 if (temp1)
38104 delete arg1;
38105 }
38106 return resultobj;
38107 fail:
38108 {
38109 if (temp1)
38110 delete arg1;
38111 }
38112 return NULL;
38113 }
38114
38115
38116 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38117 PyObject *resultobj = 0;
38118 wxMenu *arg1 = (wxMenu *) 0 ;
38119 int arg2 ;
38120 wxString *arg3 = 0 ;
38121 wxString const &arg4_defvalue = wxPyEmptyString ;
38122 wxString *arg4 = (wxString *) &arg4_defvalue ;
38123 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
38124 wxMenuItem *result = 0 ;
38125 void *argp1 = 0 ;
38126 int res1 = 0 ;
38127 int val2 ;
38128 int ecode2 = 0 ;
38129 bool temp3 = false ;
38130 bool temp4 = false ;
38131 int val5 ;
38132 int ecode5 = 0 ;
38133 PyObject * obj0 = 0 ;
38134 PyObject * obj1 = 0 ;
38135 PyObject * obj2 = 0 ;
38136 PyObject * obj3 = 0 ;
38137 PyObject * obj4 = 0 ;
38138 char * kwnames[] = {
38139 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38140 };
38141
38142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38144 if (!SWIG_IsOK(res1)) {
38145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
38146 }
38147 arg1 = reinterpret_cast< wxMenu * >(argp1);
38148 ecode2 = SWIG_AsVal_int(obj1, &val2);
38149 if (!SWIG_IsOK(ecode2)) {
38150 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
38151 }
38152 arg2 = static_cast< int >(val2);
38153 {
38154 arg3 = wxString_in_helper(obj2);
38155 if (arg3 == NULL) SWIG_fail;
38156 temp3 = true;
38157 }
38158 if (obj3) {
38159 {
38160 arg4 = wxString_in_helper(obj3);
38161 if (arg4 == NULL) SWIG_fail;
38162 temp4 = true;
38163 }
38164 }
38165 if (obj4) {
38166 ecode5 = SWIG_AsVal_int(obj4, &val5);
38167 if (!SWIG_IsOK(ecode5)) {
38168 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
38169 }
38170 arg5 = static_cast< wxItemKind >(val5);
38171 }
38172 {
38173 PyThreadState* __tstate = wxPyBeginAllowThreads();
38174 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
38175 wxPyEndAllowThreads(__tstate);
38176 if (PyErr_Occurred()) SWIG_fail;
38177 }
38178 {
38179 resultobj = wxPyMake_wxObject(result, (bool)0);
38180 }
38181 {
38182 if (temp3)
38183 delete arg3;
38184 }
38185 {
38186 if (temp4)
38187 delete arg4;
38188 }
38189 return resultobj;
38190 fail:
38191 {
38192 if (temp3)
38193 delete arg3;
38194 }
38195 {
38196 if (temp4)
38197 delete arg4;
38198 }
38199 return NULL;
38200 }
38201
38202
38203 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38204 PyObject *resultobj = 0;
38205 wxMenu *arg1 = (wxMenu *) 0 ;
38206 wxMenuItem *result = 0 ;
38207 void *argp1 = 0 ;
38208 int res1 = 0 ;
38209 PyObject *swig_obj[1] ;
38210
38211 if (!args) SWIG_fail;
38212 swig_obj[0] = args;
38213 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38214 if (!SWIG_IsOK(res1)) {
38215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
38216 }
38217 arg1 = reinterpret_cast< wxMenu * >(argp1);
38218 {
38219 PyThreadState* __tstate = wxPyBeginAllowThreads();
38220 result = (wxMenuItem *)(arg1)->AppendSeparator();
38221 wxPyEndAllowThreads(__tstate);
38222 if (PyErr_Occurred()) SWIG_fail;
38223 }
38224 {
38225 resultobj = wxPyMake_wxObject(result, (bool)0);
38226 }
38227 return resultobj;
38228 fail:
38229 return NULL;
38230 }
38231
38232
38233 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38234 PyObject *resultobj = 0;
38235 wxMenu *arg1 = (wxMenu *) 0 ;
38236 int arg2 ;
38237 wxString *arg3 = 0 ;
38238 wxString const &arg4_defvalue = wxPyEmptyString ;
38239 wxString *arg4 = (wxString *) &arg4_defvalue ;
38240 wxMenuItem *result = 0 ;
38241 void *argp1 = 0 ;
38242 int res1 = 0 ;
38243 int val2 ;
38244 int ecode2 = 0 ;
38245 bool temp3 = false ;
38246 bool temp4 = false ;
38247 PyObject * obj0 = 0 ;
38248 PyObject * obj1 = 0 ;
38249 PyObject * obj2 = 0 ;
38250 PyObject * obj3 = 0 ;
38251 char * kwnames[] = {
38252 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38253 };
38254
38255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38256 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38257 if (!SWIG_IsOK(res1)) {
38258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38259 }
38260 arg1 = reinterpret_cast< wxMenu * >(argp1);
38261 ecode2 = SWIG_AsVal_int(obj1, &val2);
38262 if (!SWIG_IsOK(ecode2)) {
38263 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
38264 }
38265 arg2 = static_cast< int >(val2);
38266 {
38267 arg3 = wxString_in_helper(obj2);
38268 if (arg3 == NULL) SWIG_fail;
38269 temp3 = true;
38270 }
38271 if (obj3) {
38272 {
38273 arg4 = wxString_in_helper(obj3);
38274 if (arg4 == NULL) SWIG_fail;
38275 temp4 = true;
38276 }
38277 }
38278 {
38279 PyThreadState* __tstate = wxPyBeginAllowThreads();
38280 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38281 wxPyEndAllowThreads(__tstate);
38282 if (PyErr_Occurred()) SWIG_fail;
38283 }
38284 {
38285 resultobj = wxPyMake_wxObject(result, (bool)0);
38286 }
38287 {
38288 if (temp3)
38289 delete arg3;
38290 }
38291 {
38292 if (temp4)
38293 delete arg4;
38294 }
38295 return resultobj;
38296 fail:
38297 {
38298 if (temp3)
38299 delete arg3;
38300 }
38301 {
38302 if (temp4)
38303 delete arg4;
38304 }
38305 return NULL;
38306 }
38307
38308
38309 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38310 PyObject *resultobj = 0;
38311 wxMenu *arg1 = (wxMenu *) 0 ;
38312 int arg2 ;
38313 wxString *arg3 = 0 ;
38314 wxString const &arg4_defvalue = wxPyEmptyString ;
38315 wxString *arg4 = (wxString *) &arg4_defvalue ;
38316 wxMenuItem *result = 0 ;
38317 void *argp1 = 0 ;
38318 int res1 = 0 ;
38319 int val2 ;
38320 int ecode2 = 0 ;
38321 bool temp3 = false ;
38322 bool temp4 = false ;
38323 PyObject * obj0 = 0 ;
38324 PyObject * obj1 = 0 ;
38325 PyObject * obj2 = 0 ;
38326 PyObject * obj3 = 0 ;
38327 char * kwnames[] = {
38328 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38329 };
38330
38331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38332 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38333 if (!SWIG_IsOK(res1)) {
38334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38335 }
38336 arg1 = reinterpret_cast< wxMenu * >(argp1);
38337 ecode2 = SWIG_AsVal_int(obj1, &val2);
38338 if (!SWIG_IsOK(ecode2)) {
38339 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
38340 }
38341 arg2 = static_cast< int >(val2);
38342 {
38343 arg3 = wxString_in_helper(obj2);
38344 if (arg3 == NULL) SWIG_fail;
38345 temp3 = true;
38346 }
38347 if (obj3) {
38348 {
38349 arg4 = wxString_in_helper(obj3);
38350 if (arg4 == NULL) SWIG_fail;
38351 temp4 = true;
38352 }
38353 }
38354 {
38355 PyThreadState* __tstate = wxPyBeginAllowThreads();
38356 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38357 wxPyEndAllowThreads(__tstate);
38358 if (PyErr_Occurred()) SWIG_fail;
38359 }
38360 {
38361 resultobj = wxPyMake_wxObject(result, (bool)0);
38362 }
38363 {
38364 if (temp3)
38365 delete arg3;
38366 }
38367 {
38368 if (temp4)
38369 delete arg4;
38370 }
38371 return resultobj;
38372 fail:
38373 {
38374 if (temp3)
38375 delete arg3;
38376 }
38377 {
38378 if (temp4)
38379 delete arg4;
38380 }
38381 return NULL;
38382 }
38383
38384
38385 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38386 PyObject *resultobj = 0;
38387 wxMenu *arg1 = (wxMenu *) 0 ;
38388 int arg2 ;
38389 wxString *arg3 = 0 ;
38390 wxMenu *arg4 = (wxMenu *) 0 ;
38391 wxString const &arg5_defvalue = wxPyEmptyString ;
38392 wxString *arg5 = (wxString *) &arg5_defvalue ;
38393 wxMenuItem *result = 0 ;
38394 void *argp1 = 0 ;
38395 int res1 = 0 ;
38396 int val2 ;
38397 int ecode2 = 0 ;
38398 bool temp3 = false ;
38399 void *argp4 = 0 ;
38400 int res4 = 0 ;
38401 bool temp5 = false ;
38402 PyObject * obj0 = 0 ;
38403 PyObject * obj1 = 0 ;
38404 PyObject * obj2 = 0 ;
38405 PyObject * obj3 = 0 ;
38406 PyObject * obj4 = 0 ;
38407 char * kwnames[] = {
38408 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
38409 };
38410
38411 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38412 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38413 if (!SWIG_IsOK(res1)) {
38414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38415 }
38416 arg1 = reinterpret_cast< wxMenu * >(argp1);
38417 ecode2 = SWIG_AsVal_int(obj1, &val2);
38418 if (!SWIG_IsOK(ecode2)) {
38419 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
38420 }
38421 arg2 = static_cast< int >(val2);
38422 {
38423 arg3 = wxString_in_helper(obj2);
38424 if (arg3 == NULL) SWIG_fail;
38425 temp3 = true;
38426 }
38427 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
38428 if (!SWIG_IsOK(res4)) {
38429 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
38430 }
38431 arg4 = reinterpret_cast< wxMenu * >(argp4);
38432 if (obj4) {
38433 {
38434 arg5 = wxString_in_helper(obj4);
38435 if (arg5 == NULL) SWIG_fail;
38436 temp5 = true;
38437 }
38438 }
38439 {
38440 PyThreadState* __tstate = wxPyBeginAllowThreads();
38441 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
38442 wxPyEndAllowThreads(__tstate);
38443 if (PyErr_Occurred()) SWIG_fail;
38444 }
38445 {
38446 resultobj = wxPyMake_wxObject(result, (bool)0);
38447 }
38448 {
38449 if (temp3)
38450 delete arg3;
38451 }
38452 {
38453 if (temp5)
38454 delete arg5;
38455 }
38456 return resultobj;
38457 fail:
38458 {
38459 if (temp3)
38460 delete arg3;
38461 }
38462 {
38463 if (temp5)
38464 delete arg5;
38465 }
38466 return NULL;
38467 }
38468
38469
38470 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38471 PyObject *resultobj = 0;
38472 wxMenu *arg1 = (wxMenu *) 0 ;
38473 wxMenu *arg2 = (wxMenu *) 0 ;
38474 wxString *arg3 = 0 ;
38475 wxString const &arg4_defvalue = wxPyEmptyString ;
38476 wxString *arg4 = (wxString *) &arg4_defvalue ;
38477 wxMenuItem *result = 0 ;
38478 void *argp1 = 0 ;
38479 int res1 = 0 ;
38480 void *argp2 = 0 ;
38481 int res2 = 0 ;
38482 bool temp3 = false ;
38483 bool temp4 = false ;
38484 PyObject * obj0 = 0 ;
38485 PyObject * obj1 = 0 ;
38486 PyObject * obj2 = 0 ;
38487 PyObject * obj3 = 0 ;
38488 char * kwnames[] = {
38489 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
38490 };
38491
38492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38493 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38494 if (!SWIG_IsOK(res1)) {
38495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38496 }
38497 arg1 = reinterpret_cast< wxMenu * >(argp1);
38498 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
38499 if (!SWIG_IsOK(res2)) {
38500 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
38501 }
38502 arg2 = reinterpret_cast< wxMenu * >(argp2);
38503 {
38504 arg3 = wxString_in_helper(obj2);
38505 if (arg3 == NULL) SWIG_fail;
38506 temp3 = true;
38507 }
38508 if (obj3) {
38509 {
38510 arg4 = wxString_in_helper(obj3);
38511 if (arg4 == NULL) SWIG_fail;
38512 temp4 = true;
38513 }
38514 }
38515 {
38516 PyThreadState* __tstate = wxPyBeginAllowThreads();
38517 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38518 wxPyEndAllowThreads(__tstate);
38519 if (PyErr_Occurred()) SWIG_fail;
38520 }
38521 {
38522 resultobj = wxPyMake_wxObject(result, (bool)0);
38523 }
38524 {
38525 if (temp3)
38526 delete arg3;
38527 }
38528 {
38529 if (temp4)
38530 delete arg4;
38531 }
38532 return resultobj;
38533 fail:
38534 {
38535 if (temp3)
38536 delete arg3;
38537 }
38538 {
38539 if (temp4)
38540 delete arg4;
38541 }
38542 return NULL;
38543 }
38544
38545
38546 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38547 PyObject *resultobj = 0;
38548 wxMenu *arg1 = (wxMenu *) 0 ;
38549 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38550 wxMenuItem *result = 0 ;
38551 void *argp1 = 0 ;
38552 int res1 = 0 ;
38553 int res2 = 0 ;
38554 PyObject * obj0 = 0 ;
38555 PyObject * obj1 = 0 ;
38556 char * kwnames[] = {
38557 (char *) "self",(char *) "item", NULL
38558 };
38559
38560 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
38561 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38562 if (!SWIG_IsOK(res1)) {
38563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38564 }
38565 arg1 = reinterpret_cast< wxMenu * >(argp1);
38566 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38567 if (!SWIG_IsOK(res2)) {
38568 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
38569 }
38570 {
38571 PyThreadState* __tstate = wxPyBeginAllowThreads();
38572 result = (wxMenuItem *)(arg1)->Append(arg2);
38573 wxPyEndAllowThreads(__tstate);
38574 if (PyErr_Occurred()) SWIG_fail;
38575 }
38576 {
38577 resultobj = wxPyMake_wxObject(result, (bool)0);
38578 }
38579 return resultobj;
38580 fail:
38581 return NULL;
38582 }
38583
38584
38585 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38586 PyObject *resultobj = 0;
38587 wxMenu *arg1 = (wxMenu *) 0 ;
38588 size_t arg2 ;
38589 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
38590 wxMenuItem *result = 0 ;
38591 void *argp1 = 0 ;
38592 int res1 = 0 ;
38593 size_t val2 ;
38594 int ecode2 = 0 ;
38595 int res3 = 0 ;
38596 PyObject * obj0 = 0 ;
38597 PyObject * obj1 = 0 ;
38598 PyObject * obj2 = 0 ;
38599 char * kwnames[] = {
38600 (char *) "self",(char *) "pos",(char *) "item", NULL
38601 };
38602
38603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38604 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38605 if (!SWIG_IsOK(res1)) {
38606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38607 }
38608 arg1 = reinterpret_cast< wxMenu * >(argp1);
38609 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38610 if (!SWIG_IsOK(ecode2)) {
38611 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
38612 }
38613 arg2 = static_cast< size_t >(val2);
38614 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38615 if (!SWIG_IsOK(res3)) {
38616 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
38617 }
38618 {
38619 PyThreadState* __tstate = wxPyBeginAllowThreads();
38620 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
38621 wxPyEndAllowThreads(__tstate);
38622 if (PyErr_Occurred()) SWIG_fail;
38623 }
38624 {
38625 resultobj = wxPyMake_wxObject(result, (bool)0);
38626 }
38627 return resultobj;
38628 fail:
38629 return NULL;
38630 }
38631
38632
38633 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38634 PyObject *resultobj = 0;
38635 wxMenu *arg1 = (wxMenu *) 0 ;
38636 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38637 wxMenuItem *result = 0 ;
38638 void *argp1 = 0 ;
38639 int res1 = 0 ;
38640 int res2 = 0 ;
38641 PyObject * obj0 = 0 ;
38642 PyObject * obj1 = 0 ;
38643 char * kwnames[] = {
38644 (char *) "self",(char *) "item", NULL
38645 };
38646
38647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
38648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38649 if (!SWIG_IsOK(res1)) {
38650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38651 }
38652 arg1 = reinterpret_cast< wxMenu * >(argp1);
38653 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38654 if (!SWIG_IsOK(res2)) {
38655 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
38656 }
38657 {
38658 PyThreadState* __tstate = wxPyBeginAllowThreads();
38659 result = (wxMenuItem *)(arg1)->Prepend(arg2);
38660 wxPyEndAllowThreads(__tstate);
38661 if (PyErr_Occurred()) SWIG_fail;
38662 }
38663 {
38664 resultobj = wxPyMake_wxObject(result, (bool)0);
38665 }
38666 return resultobj;
38667 fail:
38668 return NULL;
38669 }
38670
38671
38672 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38673 PyObject *resultobj = 0;
38674 wxMenu *arg1 = (wxMenu *) 0 ;
38675 void *argp1 = 0 ;
38676 int res1 = 0 ;
38677 PyObject *swig_obj[1] ;
38678
38679 if (!args) SWIG_fail;
38680 swig_obj[0] = args;
38681 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38682 if (!SWIG_IsOK(res1)) {
38683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
38684 }
38685 arg1 = reinterpret_cast< wxMenu * >(argp1);
38686 {
38687 PyThreadState* __tstate = wxPyBeginAllowThreads();
38688 (arg1)->Break();
38689 wxPyEndAllowThreads(__tstate);
38690 if (PyErr_Occurred()) SWIG_fail;
38691 }
38692 resultobj = SWIG_Py_Void();
38693 return resultobj;
38694 fail:
38695 return NULL;
38696 }
38697
38698
38699 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38700 PyObject *resultobj = 0;
38701 wxMenu *arg1 = (wxMenu *) 0 ;
38702 size_t arg2 ;
38703 int arg3 ;
38704 wxString *arg4 = 0 ;
38705 wxString const &arg5_defvalue = wxPyEmptyString ;
38706 wxString *arg5 = (wxString *) &arg5_defvalue ;
38707 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
38708 wxMenuItem *result = 0 ;
38709 void *argp1 = 0 ;
38710 int res1 = 0 ;
38711 size_t val2 ;
38712 int ecode2 = 0 ;
38713 int val3 ;
38714 int ecode3 = 0 ;
38715 bool temp4 = false ;
38716 bool temp5 = false ;
38717 int val6 ;
38718 int ecode6 = 0 ;
38719 PyObject * obj0 = 0 ;
38720 PyObject * obj1 = 0 ;
38721 PyObject * obj2 = 0 ;
38722 PyObject * obj3 = 0 ;
38723 PyObject * obj4 = 0 ;
38724 PyObject * obj5 = 0 ;
38725 char * kwnames[] = {
38726 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38727 };
38728
38729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
38730 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38731 if (!SWIG_IsOK(res1)) {
38732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
38733 }
38734 arg1 = reinterpret_cast< wxMenu * >(argp1);
38735 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38736 if (!SWIG_IsOK(ecode2)) {
38737 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
38738 }
38739 arg2 = static_cast< size_t >(val2);
38740 ecode3 = SWIG_AsVal_int(obj2, &val3);
38741 if (!SWIG_IsOK(ecode3)) {
38742 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
38743 }
38744 arg3 = static_cast< int >(val3);
38745 {
38746 arg4 = wxString_in_helper(obj3);
38747 if (arg4 == NULL) SWIG_fail;
38748 temp4 = true;
38749 }
38750 if (obj4) {
38751 {
38752 arg5 = wxString_in_helper(obj4);
38753 if (arg5 == NULL) SWIG_fail;
38754 temp5 = true;
38755 }
38756 }
38757 if (obj5) {
38758 ecode6 = SWIG_AsVal_int(obj5, &val6);
38759 if (!SWIG_IsOK(ecode6)) {
38760 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
38761 }
38762 arg6 = static_cast< wxItemKind >(val6);
38763 }
38764 {
38765 PyThreadState* __tstate = wxPyBeginAllowThreads();
38766 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
38767 wxPyEndAllowThreads(__tstate);
38768 if (PyErr_Occurred()) SWIG_fail;
38769 }
38770 {
38771 resultobj = wxPyMake_wxObject(result, (bool)0);
38772 }
38773 {
38774 if (temp4)
38775 delete arg4;
38776 }
38777 {
38778 if (temp5)
38779 delete arg5;
38780 }
38781 return resultobj;
38782 fail:
38783 {
38784 if (temp4)
38785 delete arg4;
38786 }
38787 {
38788 if (temp5)
38789 delete arg5;
38790 }
38791 return NULL;
38792 }
38793
38794
38795 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38796 PyObject *resultobj = 0;
38797 wxMenu *arg1 = (wxMenu *) 0 ;
38798 size_t arg2 ;
38799 wxMenuItem *result = 0 ;
38800 void *argp1 = 0 ;
38801 int res1 = 0 ;
38802 size_t val2 ;
38803 int ecode2 = 0 ;
38804 PyObject * obj0 = 0 ;
38805 PyObject * obj1 = 0 ;
38806 char * kwnames[] = {
38807 (char *) "self",(char *) "pos", NULL
38808 };
38809
38810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
38811 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38812 if (!SWIG_IsOK(res1)) {
38813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
38814 }
38815 arg1 = reinterpret_cast< wxMenu * >(argp1);
38816 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38817 if (!SWIG_IsOK(ecode2)) {
38818 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
38819 }
38820 arg2 = static_cast< size_t >(val2);
38821 {
38822 PyThreadState* __tstate = wxPyBeginAllowThreads();
38823 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
38824 wxPyEndAllowThreads(__tstate);
38825 if (PyErr_Occurred()) SWIG_fail;
38826 }
38827 {
38828 resultobj = wxPyMake_wxObject(result, (bool)0);
38829 }
38830 return resultobj;
38831 fail:
38832 return NULL;
38833 }
38834
38835
38836 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38837 PyObject *resultobj = 0;
38838 wxMenu *arg1 = (wxMenu *) 0 ;
38839 size_t arg2 ;
38840 int arg3 ;
38841 wxString *arg4 = 0 ;
38842 wxString const &arg5_defvalue = wxPyEmptyString ;
38843 wxString *arg5 = (wxString *) &arg5_defvalue ;
38844 wxMenuItem *result = 0 ;
38845 void *argp1 = 0 ;
38846 int res1 = 0 ;
38847 size_t val2 ;
38848 int ecode2 = 0 ;
38849 int val3 ;
38850 int ecode3 = 0 ;
38851 bool temp4 = false ;
38852 bool temp5 = false ;
38853 PyObject * obj0 = 0 ;
38854 PyObject * obj1 = 0 ;
38855 PyObject * obj2 = 0 ;
38856 PyObject * obj3 = 0 ;
38857 PyObject * obj4 = 0 ;
38858 char * kwnames[] = {
38859 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
38860 };
38861
38862 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38863 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38864 if (!SWIG_IsOK(res1)) {
38865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38866 }
38867 arg1 = reinterpret_cast< wxMenu * >(argp1);
38868 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38869 if (!SWIG_IsOK(ecode2)) {
38870 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
38871 }
38872 arg2 = static_cast< size_t >(val2);
38873 ecode3 = SWIG_AsVal_int(obj2, &val3);
38874 if (!SWIG_IsOK(ecode3)) {
38875 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
38876 }
38877 arg3 = static_cast< int >(val3);
38878 {
38879 arg4 = wxString_in_helper(obj3);
38880 if (arg4 == NULL) SWIG_fail;
38881 temp4 = true;
38882 }
38883 if (obj4) {
38884 {
38885 arg5 = wxString_in_helper(obj4);
38886 if (arg5 == NULL) SWIG_fail;
38887 temp5 = true;
38888 }
38889 }
38890 {
38891 PyThreadState* __tstate = wxPyBeginAllowThreads();
38892 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
38893 wxPyEndAllowThreads(__tstate);
38894 if (PyErr_Occurred()) SWIG_fail;
38895 }
38896 {
38897 resultobj = wxPyMake_wxObject(result, (bool)0);
38898 }
38899 {
38900 if (temp4)
38901 delete arg4;
38902 }
38903 {
38904 if (temp5)
38905 delete arg5;
38906 }
38907 return resultobj;
38908 fail:
38909 {
38910 if (temp4)
38911 delete arg4;
38912 }
38913 {
38914 if (temp5)
38915 delete arg5;
38916 }
38917 return NULL;
38918 }
38919
38920
38921 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38922 PyObject *resultobj = 0;
38923 wxMenu *arg1 = (wxMenu *) 0 ;
38924 size_t arg2 ;
38925 int arg3 ;
38926 wxString *arg4 = 0 ;
38927 wxString const &arg5_defvalue = wxPyEmptyString ;
38928 wxString *arg5 = (wxString *) &arg5_defvalue ;
38929 wxMenuItem *result = 0 ;
38930 void *argp1 = 0 ;
38931 int res1 = 0 ;
38932 size_t val2 ;
38933 int ecode2 = 0 ;
38934 int val3 ;
38935 int ecode3 = 0 ;
38936 bool temp4 = false ;
38937 bool temp5 = false ;
38938 PyObject * obj0 = 0 ;
38939 PyObject * obj1 = 0 ;
38940 PyObject * obj2 = 0 ;
38941 PyObject * obj3 = 0 ;
38942 PyObject * obj4 = 0 ;
38943 char * kwnames[] = {
38944 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
38945 };
38946
38947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38948 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38949 if (!SWIG_IsOK(res1)) {
38950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38951 }
38952 arg1 = reinterpret_cast< wxMenu * >(argp1);
38953 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38954 if (!SWIG_IsOK(ecode2)) {
38955 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
38956 }
38957 arg2 = static_cast< size_t >(val2);
38958 ecode3 = SWIG_AsVal_int(obj2, &val3);
38959 if (!SWIG_IsOK(ecode3)) {
38960 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
38961 }
38962 arg3 = static_cast< int >(val3);
38963 {
38964 arg4 = wxString_in_helper(obj3);
38965 if (arg4 == NULL) SWIG_fail;
38966 temp4 = true;
38967 }
38968 if (obj4) {
38969 {
38970 arg5 = wxString_in_helper(obj4);
38971 if (arg5 == NULL) SWIG_fail;
38972 temp5 = true;
38973 }
38974 }
38975 {
38976 PyThreadState* __tstate = wxPyBeginAllowThreads();
38977 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
38978 wxPyEndAllowThreads(__tstate);
38979 if (PyErr_Occurred()) SWIG_fail;
38980 }
38981 {
38982 resultobj = wxPyMake_wxObject(result, (bool)0);
38983 }
38984 {
38985 if (temp4)
38986 delete arg4;
38987 }
38988 {
38989 if (temp5)
38990 delete arg5;
38991 }
38992 return resultobj;
38993 fail:
38994 {
38995 if (temp4)
38996 delete arg4;
38997 }
38998 {
38999 if (temp5)
39000 delete arg5;
39001 }
39002 return NULL;
39003 }
39004
39005
39006 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39007 PyObject *resultobj = 0;
39008 wxMenu *arg1 = (wxMenu *) 0 ;
39009 size_t arg2 ;
39010 int arg3 ;
39011 wxString *arg4 = 0 ;
39012 wxMenu *arg5 = (wxMenu *) 0 ;
39013 wxString const &arg6_defvalue = wxPyEmptyString ;
39014 wxString *arg6 = (wxString *) &arg6_defvalue ;
39015 wxMenuItem *result = 0 ;
39016 void *argp1 = 0 ;
39017 int res1 = 0 ;
39018 size_t val2 ;
39019 int ecode2 = 0 ;
39020 int val3 ;
39021 int ecode3 = 0 ;
39022 bool temp4 = false ;
39023 void *argp5 = 0 ;
39024 int res5 = 0 ;
39025 bool temp6 = false ;
39026 PyObject * obj0 = 0 ;
39027 PyObject * obj1 = 0 ;
39028 PyObject * obj2 = 0 ;
39029 PyObject * obj3 = 0 ;
39030 PyObject * obj4 = 0 ;
39031 PyObject * obj5 = 0 ;
39032 char * kwnames[] = {
39033 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39034 };
39035
39036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
39037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39038 if (!SWIG_IsOK(res1)) {
39039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39040 }
39041 arg1 = reinterpret_cast< wxMenu * >(argp1);
39042 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39043 if (!SWIG_IsOK(ecode2)) {
39044 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
39045 }
39046 arg2 = static_cast< size_t >(val2);
39047 ecode3 = SWIG_AsVal_int(obj2, &val3);
39048 if (!SWIG_IsOK(ecode3)) {
39049 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
39050 }
39051 arg3 = static_cast< int >(val3);
39052 {
39053 arg4 = wxString_in_helper(obj3);
39054 if (arg4 == NULL) SWIG_fail;
39055 temp4 = true;
39056 }
39057 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
39058 if (!SWIG_IsOK(res5)) {
39059 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
39060 }
39061 arg5 = reinterpret_cast< wxMenu * >(argp5);
39062 if (obj5) {
39063 {
39064 arg6 = wxString_in_helper(obj5);
39065 if (arg6 == NULL) SWIG_fail;
39066 temp6 = true;
39067 }
39068 }
39069 {
39070 PyThreadState* __tstate = wxPyBeginAllowThreads();
39071 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
39072 wxPyEndAllowThreads(__tstate);
39073 if (PyErr_Occurred()) SWIG_fail;
39074 }
39075 {
39076 resultobj = wxPyMake_wxObject(result, (bool)0);
39077 }
39078 {
39079 if (temp4)
39080 delete arg4;
39081 }
39082 {
39083 if (temp6)
39084 delete arg6;
39085 }
39086 return resultobj;
39087 fail:
39088 {
39089 if (temp4)
39090 delete arg4;
39091 }
39092 {
39093 if (temp6)
39094 delete arg6;
39095 }
39096 return NULL;
39097 }
39098
39099
39100 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39101 PyObject *resultobj = 0;
39102 wxMenu *arg1 = (wxMenu *) 0 ;
39103 int arg2 ;
39104 wxString *arg3 = 0 ;
39105 wxString const &arg4_defvalue = wxPyEmptyString ;
39106 wxString *arg4 = (wxString *) &arg4_defvalue ;
39107 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
39108 wxMenuItem *result = 0 ;
39109 void *argp1 = 0 ;
39110 int res1 = 0 ;
39111 int val2 ;
39112 int ecode2 = 0 ;
39113 bool temp3 = false ;
39114 bool temp4 = false ;
39115 int val5 ;
39116 int ecode5 = 0 ;
39117 PyObject * obj0 = 0 ;
39118 PyObject * obj1 = 0 ;
39119 PyObject * obj2 = 0 ;
39120 PyObject * obj3 = 0 ;
39121 PyObject * obj4 = 0 ;
39122 char * kwnames[] = {
39123 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
39124 };
39125
39126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39127 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39128 if (!SWIG_IsOK(res1)) {
39129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
39130 }
39131 arg1 = reinterpret_cast< wxMenu * >(argp1);
39132 ecode2 = SWIG_AsVal_int(obj1, &val2);
39133 if (!SWIG_IsOK(ecode2)) {
39134 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
39135 }
39136 arg2 = static_cast< int >(val2);
39137 {
39138 arg3 = wxString_in_helper(obj2);
39139 if (arg3 == NULL) SWIG_fail;
39140 temp3 = true;
39141 }
39142 if (obj3) {
39143 {
39144 arg4 = wxString_in_helper(obj3);
39145 if (arg4 == NULL) SWIG_fail;
39146 temp4 = true;
39147 }
39148 }
39149 if (obj4) {
39150 ecode5 = SWIG_AsVal_int(obj4, &val5);
39151 if (!SWIG_IsOK(ecode5)) {
39152 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
39153 }
39154 arg5 = static_cast< wxItemKind >(val5);
39155 }
39156 {
39157 PyThreadState* __tstate = wxPyBeginAllowThreads();
39158 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
39159 wxPyEndAllowThreads(__tstate);
39160 if (PyErr_Occurred()) SWIG_fail;
39161 }
39162 {
39163 resultobj = wxPyMake_wxObject(result, (bool)0);
39164 }
39165 {
39166 if (temp3)
39167 delete arg3;
39168 }
39169 {
39170 if (temp4)
39171 delete arg4;
39172 }
39173 return resultobj;
39174 fail:
39175 {
39176 if (temp3)
39177 delete arg3;
39178 }
39179 {
39180 if (temp4)
39181 delete arg4;
39182 }
39183 return NULL;
39184 }
39185
39186
39187 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39188 PyObject *resultobj = 0;
39189 wxMenu *arg1 = (wxMenu *) 0 ;
39190 wxMenuItem *result = 0 ;
39191 void *argp1 = 0 ;
39192 int res1 = 0 ;
39193 PyObject *swig_obj[1] ;
39194
39195 if (!args) SWIG_fail;
39196 swig_obj[0] = args;
39197 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39198 if (!SWIG_IsOK(res1)) {
39199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39200 }
39201 arg1 = reinterpret_cast< wxMenu * >(argp1);
39202 {
39203 PyThreadState* __tstate = wxPyBeginAllowThreads();
39204 result = (wxMenuItem *)(arg1)->PrependSeparator();
39205 wxPyEndAllowThreads(__tstate);
39206 if (PyErr_Occurred()) SWIG_fail;
39207 }
39208 {
39209 resultobj = wxPyMake_wxObject(result, (bool)0);
39210 }
39211 return resultobj;
39212 fail:
39213 return NULL;
39214 }
39215
39216
39217 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39218 PyObject *resultobj = 0;
39219 wxMenu *arg1 = (wxMenu *) 0 ;
39220 int arg2 ;
39221 wxString *arg3 = 0 ;
39222 wxString const &arg4_defvalue = wxPyEmptyString ;
39223 wxString *arg4 = (wxString *) &arg4_defvalue ;
39224 wxMenuItem *result = 0 ;
39225 void *argp1 = 0 ;
39226 int res1 = 0 ;
39227 int val2 ;
39228 int ecode2 = 0 ;
39229 bool temp3 = false ;
39230 bool temp4 = false ;
39231 PyObject * obj0 = 0 ;
39232 PyObject * obj1 = 0 ;
39233 PyObject * obj2 = 0 ;
39234 PyObject * obj3 = 0 ;
39235 char * kwnames[] = {
39236 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39237 };
39238
39239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39240 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39241 if (!SWIG_IsOK(res1)) {
39242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39243 }
39244 arg1 = reinterpret_cast< wxMenu * >(argp1);
39245 ecode2 = SWIG_AsVal_int(obj1, &val2);
39246 if (!SWIG_IsOK(ecode2)) {
39247 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
39248 }
39249 arg2 = static_cast< int >(val2);
39250 {
39251 arg3 = wxString_in_helper(obj2);
39252 if (arg3 == NULL) SWIG_fail;
39253 temp3 = true;
39254 }
39255 if (obj3) {
39256 {
39257 arg4 = wxString_in_helper(obj3);
39258 if (arg4 == NULL) SWIG_fail;
39259 temp4 = true;
39260 }
39261 }
39262 {
39263 PyThreadState* __tstate = wxPyBeginAllowThreads();
39264 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39265 wxPyEndAllowThreads(__tstate);
39266 if (PyErr_Occurred()) SWIG_fail;
39267 }
39268 {
39269 resultobj = wxPyMake_wxObject(result, (bool)0);
39270 }
39271 {
39272 if (temp3)
39273 delete arg3;
39274 }
39275 {
39276 if (temp4)
39277 delete arg4;
39278 }
39279 return resultobj;
39280 fail:
39281 {
39282 if (temp3)
39283 delete arg3;
39284 }
39285 {
39286 if (temp4)
39287 delete arg4;
39288 }
39289 return NULL;
39290 }
39291
39292
39293 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39294 PyObject *resultobj = 0;
39295 wxMenu *arg1 = (wxMenu *) 0 ;
39296 int arg2 ;
39297 wxString *arg3 = 0 ;
39298 wxString const &arg4_defvalue = wxPyEmptyString ;
39299 wxString *arg4 = (wxString *) &arg4_defvalue ;
39300 wxMenuItem *result = 0 ;
39301 void *argp1 = 0 ;
39302 int res1 = 0 ;
39303 int val2 ;
39304 int ecode2 = 0 ;
39305 bool temp3 = false ;
39306 bool temp4 = false ;
39307 PyObject * obj0 = 0 ;
39308 PyObject * obj1 = 0 ;
39309 PyObject * obj2 = 0 ;
39310 PyObject * obj3 = 0 ;
39311 char * kwnames[] = {
39312 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39313 };
39314
39315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39316 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39317 if (!SWIG_IsOK(res1)) {
39318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39319 }
39320 arg1 = reinterpret_cast< wxMenu * >(argp1);
39321 ecode2 = SWIG_AsVal_int(obj1, &val2);
39322 if (!SWIG_IsOK(ecode2)) {
39323 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
39324 }
39325 arg2 = static_cast< int >(val2);
39326 {
39327 arg3 = wxString_in_helper(obj2);
39328 if (arg3 == NULL) SWIG_fail;
39329 temp3 = true;
39330 }
39331 if (obj3) {
39332 {
39333 arg4 = wxString_in_helper(obj3);
39334 if (arg4 == NULL) SWIG_fail;
39335 temp4 = true;
39336 }
39337 }
39338 {
39339 PyThreadState* __tstate = wxPyBeginAllowThreads();
39340 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39341 wxPyEndAllowThreads(__tstate);
39342 if (PyErr_Occurred()) SWIG_fail;
39343 }
39344 {
39345 resultobj = wxPyMake_wxObject(result, (bool)0);
39346 }
39347 {
39348 if (temp3)
39349 delete arg3;
39350 }
39351 {
39352 if (temp4)
39353 delete arg4;
39354 }
39355 return resultobj;
39356 fail:
39357 {
39358 if (temp3)
39359 delete arg3;
39360 }
39361 {
39362 if (temp4)
39363 delete arg4;
39364 }
39365 return NULL;
39366 }
39367
39368
39369 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39370 PyObject *resultobj = 0;
39371 wxMenu *arg1 = (wxMenu *) 0 ;
39372 int arg2 ;
39373 wxString *arg3 = 0 ;
39374 wxMenu *arg4 = (wxMenu *) 0 ;
39375 wxString const &arg5_defvalue = wxPyEmptyString ;
39376 wxString *arg5 = (wxString *) &arg5_defvalue ;
39377 wxMenuItem *result = 0 ;
39378 void *argp1 = 0 ;
39379 int res1 = 0 ;
39380 int val2 ;
39381 int ecode2 = 0 ;
39382 bool temp3 = false ;
39383 void *argp4 = 0 ;
39384 int res4 = 0 ;
39385 bool temp5 = false ;
39386 PyObject * obj0 = 0 ;
39387 PyObject * obj1 = 0 ;
39388 PyObject * obj2 = 0 ;
39389 PyObject * obj3 = 0 ;
39390 PyObject * obj4 = 0 ;
39391 char * kwnames[] = {
39392 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39393 };
39394
39395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39396 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39397 if (!SWIG_IsOK(res1)) {
39398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39399 }
39400 arg1 = reinterpret_cast< wxMenu * >(argp1);
39401 ecode2 = SWIG_AsVal_int(obj1, &val2);
39402 if (!SWIG_IsOK(ecode2)) {
39403 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
39404 }
39405 arg2 = static_cast< int >(val2);
39406 {
39407 arg3 = wxString_in_helper(obj2);
39408 if (arg3 == NULL) SWIG_fail;
39409 temp3 = true;
39410 }
39411 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
39412 if (!SWIG_IsOK(res4)) {
39413 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
39414 }
39415 arg4 = reinterpret_cast< wxMenu * >(argp4);
39416 if (obj4) {
39417 {
39418 arg5 = wxString_in_helper(obj4);
39419 if (arg5 == NULL) SWIG_fail;
39420 temp5 = true;
39421 }
39422 }
39423 {
39424 PyThreadState* __tstate = wxPyBeginAllowThreads();
39425 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
39426 wxPyEndAllowThreads(__tstate);
39427 if (PyErr_Occurred()) SWIG_fail;
39428 }
39429 {
39430 resultobj = wxPyMake_wxObject(result, (bool)0);
39431 }
39432 {
39433 if (temp3)
39434 delete arg3;
39435 }
39436 {
39437 if (temp5)
39438 delete arg5;
39439 }
39440 return resultobj;
39441 fail:
39442 {
39443 if (temp3)
39444 delete arg3;
39445 }
39446 {
39447 if (temp5)
39448 delete arg5;
39449 }
39450 return NULL;
39451 }
39452
39453
39454 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39455 PyObject *resultobj = 0;
39456 wxMenu *arg1 = (wxMenu *) 0 ;
39457 int arg2 ;
39458 wxMenuItem *result = 0 ;
39459 void *argp1 = 0 ;
39460 int res1 = 0 ;
39461 int val2 ;
39462 int ecode2 = 0 ;
39463 PyObject * obj0 = 0 ;
39464 PyObject * obj1 = 0 ;
39465 char * kwnames[] = {
39466 (char *) "self",(char *) "id", NULL
39467 };
39468
39469 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
39470 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39471 if (!SWIG_IsOK(res1)) {
39472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
39473 }
39474 arg1 = reinterpret_cast< wxMenu * >(argp1);
39475 ecode2 = SWIG_AsVal_int(obj1, &val2);
39476 if (!SWIG_IsOK(ecode2)) {
39477 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
39478 }
39479 arg2 = static_cast< int >(val2);
39480 {
39481 PyThreadState* __tstate = wxPyBeginAllowThreads();
39482 result = (wxMenuItem *)(arg1)->Remove(arg2);
39483 wxPyEndAllowThreads(__tstate);
39484 if (PyErr_Occurred()) SWIG_fail;
39485 }
39486 {
39487 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39488 }
39489 return resultobj;
39490 fail:
39491 return NULL;
39492 }
39493
39494
39495 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39496 PyObject *resultobj = 0;
39497 wxMenu *arg1 = (wxMenu *) 0 ;
39498 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39499 wxMenuItem *result = 0 ;
39500 void *argp1 = 0 ;
39501 int res1 = 0 ;
39502 void *argp2 = 0 ;
39503 int res2 = 0 ;
39504 PyObject * obj0 = 0 ;
39505 PyObject * obj1 = 0 ;
39506 char * kwnames[] = {
39507 (char *) "self",(char *) "item", NULL
39508 };
39509
39510 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
39511 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39512 if (!SWIG_IsOK(res1)) {
39513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39514 }
39515 arg1 = reinterpret_cast< wxMenu * >(argp1);
39516 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39517 if (!SWIG_IsOK(res2)) {
39518 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39519 }
39520 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39521 {
39522 PyThreadState* __tstate = wxPyBeginAllowThreads();
39523 result = (wxMenuItem *)(arg1)->Remove(arg2);
39524 wxPyEndAllowThreads(__tstate);
39525 if (PyErr_Occurred()) SWIG_fail;
39526 }
39527 {
39528 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39529 }
39530 return resultobj;
39531 fail:
39532 return NULL;
39533 }
39534
39535
39536 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39537 PyObject *resultobj = 0;
39538 wxMenu *arg1 = (wxMenu *) 0 ;
39539 int arg2 ;
39540 bool result;
39541 void *argp1 = 0 ;
39542 int res1 = 0 ;
39543 int val2 ;
39544 int ecode2 = 0 ;
39545 PyObject * obj0 = 0 ;
39546 PyObject * obj1 = 0 ;
39547 char * kwnames[] = {
39548 (char *) "self",(char *) "id", NULL
39549 };
39550
39551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
39552 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39553 if (!SWIG_IsOK(res1)) {
39554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
39555 }
39556 arg1 = reinterpret_cast< wxMenu * >(argp1);
39557 ecode2 = SWIG_AsVal_int(obj1, &val2);
39558 if (!SWIG_IsOK(ecode2)) {
39559 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
39560 }
39561 arg2 = static_cast< int >(val2);
39562 {
39563 PyThreadState* __tstate = wxPyBeginAllowThreads();
39564 result = (bool)(arg1)->Delete(arg2);
39565 wxPyEndAllowThreads(__tstate);
39566 if (PyErr_Occurred()) SWIG_fail;
39567 }
39568 {
39569 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39570 }
39571 return resultobj;
39572 fail:
39573 return NULL;
39574 }
39575
39576
39577 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39578 PyObject *resultobj = 0;
39579 wxMenu *arg1 = (wxMenu *) 0 ;
39580 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39581 bool result;
39582 void *argp1 = 0 ;
39583 int res1 = 0 ;
39584 void *argp2 = 0 ;
39585 int res2 = 0 ;
39586 PyObject * obj0 = 0 ;
39587 PyObject * obj1 = 0 ;
39588 char * kwnames[] = {
39589 (char *) "self",(char *) "item", NULL
39590 };
39591
39592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
39593 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39594 if (!SWIG_IsOK(res1)) {
39595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39596 }
39597 arg1 = reinterpret_cast< wxMenu * >(argp1);
39598 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39599 if (!SWIG_IsOK(res2)) {
39600 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39601 }
39602 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39603 {
39604 PyThreadState* __tstate = wxPyBeginAllowThreads();
39605 result = (bool)(arg1)->Delete(arg2);
39606 wxPyEndAllowThreads(__tstate);
39607 if (PyErr_Occurred()) SWIG_fail;
39608 }
39609 {
39610 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39611 }
39612 return resultobj;
39613 fail:
39614 return NULL;
39615 }
39616
39617
39618 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39619 PyObject *resultobj = 0;
39620 wxMenu *arg1 = (wxMenu *) 0 ;
39621 void *argp1 = 0 ;
39622 int res1 = 0 ;
39623 PyObject *swig_obj[1] ;
39624
39625 if (!args) SWIG_fail;
39626 swig_obj[0] = args;
39627 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39628 if (!SWIG_IsOK(res1)) {
39629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
39630 }
39631 arg1 = reinterpret_cast< wxMenu * >(argp1);
39632 {
39633 PyThreadState* __tstate = wxPyBeginAllowThreads();
39634 wxMenu_Destroy(arg1);
39635 wxPyEndAllowThreads(__tstate);
39636 if (PyErr_Occurred()) SWIG_fail;
39637 }
39638 resultobj = SWIG_Py_Void();
39639 return resultobj;
39640 fail:
39641 return NULL;
39642 }
39643
39644
39645 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39646 PyObject *resultobj = 0;
39647 wxMenu *arg1 = (wxMenu *) 0 ;
39648 int arg2 ;
39649 bool result;
39650 void *argp1 = 0 ;
39651 int res1 = 0 ;
39652 int val2 ;
39653 int ecode2 = 0 ;
39654 PyObject * obj0 = 0 ;
39655 PyObject * obj1 = 0 ;
39656 char * kwnames[] = {
39657 (char *) "self",(char *) "id", NULL
39658 };
39659
39660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
39661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39662 if (!SWIG_IsOK(res1)) {
39663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
39664 }
39665 arg1 = reinterpret_cast< wxMenu * >(argp1);
39666 ecode2 = SWIG_AsVal_int(obj1, &val2);
39667 if (!SWIG_IsOK(ecode2)) {
39668 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
39669 }
39670 arg2 = static_cast< int >(val2);
39671 {
39672 PyThreadState* __tstate = wxPyBeginAllowThreads();
39673 result = (bool)(arg1)->Destroy(arg2);
39674 wxPyEndAllowThreads(__tstate);
39675 if (PyErr_Occurred()) SWIG_fail;
39676 }
39677 {
39678 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39679 }
39680 return resultobj;
39681 fail:
39682 return NULL;
39683 }
39684
39685
39686 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39687 PyObject *resultobj = 0;
39688 wxMenu *arg1 = (wxMenu *) 0 ;
39689 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39690 bool result;
39691 void *argp1 = 0 ;
39692 int res1 = 0 ;
39693 void *argp2 = 0 ;
39694 int res2 = 0 ;
39695 PyObject * obj0 = 0 ;
39696 PyObject * obj1 = 0 ;
39697 char * kwnames[] = {
39698 (char *) "self",(char *) "item", NULL
39699 };
39700
39701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
39702 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39703 if (!SWIG_IsOK(res1)) {
39704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39705 }
39706 arg1 = reinterpret_cast< wxMenu * >(argp1);
39707 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39708 if (!SWIG_IsOK(res2)) {
39709 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39710 }
39711 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39712 {
39713 PyThreadState* __tstate = wxPyBeginAllowThreads();
39714 result = (bool)(arg1)->Destroy(arg2);
39715 wxPyEndAllowThreads(__tstate);
39716 if (PyErr_Occurred()) SWIG_fail;
39717 }
39718 {
39719 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39720 }
39721 return resultobj;
39722 fail:
39723 return NULL;
39724 }
39725
39726
39727 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39728 PyObject *resultobj = 0;
39729 wxMenu *arg1 = (wxMenu *) 0 ;
39730 size_t result;
39731 void *argp1 = 0 ;
39732 int res1 = 0 ;
39733 PyObject *swig_obj[1] ;
39734
39735 if (!args) SWIG_fail;
39736 swig_obj[0] = args;
39737 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39738 if (!SWIG_IsOK(res1)) {
39739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
39740 }
39741 arg1 = reinterpret_cast< wxMenu * >(argp1);
39742 {
39743 PyThreadState* __tstate = wxPyBeginAllowThreads();
39744 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
39745 wxPyEndAllowThreads(__tstate);
39746 if (PyErr_Occurred()) SWIG_fail;
39747 }
39748 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
39749 return resultobj;
39750 fail:
39751 return NULL;
39752 }
39753
39754
39755 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39756 PyObject *resultobj = 0;
39757 wxMenu *arg1 = (wxMenu *) 0 ;
39758 PyObject *result = 0 ;
39759 void *argp1 = 0 ;
39760 int res1 = 0 ;
39761 PyObject *swig_obj[1] ;
39762
39763 if (!args) SWIG_fail;
39764 swig_obj[0] = args;
39765 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39766 if (!SWIG_IsOK(res1)) {
39767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
39768 }
39769 arg1 = reinterpret_cast< wxMenu * >(argp1);
39770 {
39771 PyThreadState* __tstate = wxPyBeginAllowThreads();
39772 result = (PyObject *)wxMenu_GetMenuItems(arg1);
39773 wxPyEndAllowThreads(__tstate);
39774 if (PyErr_Occurred()) SWIG_fail;
39775 }
39776 resultobj = result;
39777 return resultobj;
39778 fail:
39779 return NULL;
39780 }
39781
39782
39783 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39784 PyObject *resultobj = 0;
39785 wxMenu *arg1 = (wxMenu *) 0 ;
39786 wxString *arg2 = 0 ;
39787 int result;
39788 void *argp1 = 0 ;
39789 int res1 = 0 ;
39790 bool temp2 = false ;
39791 PyObject * obj0 = 0 ;
39792 PyObject * obj1 = 0 ;
39793 char * kwnames[] = {
39794 (char *) "self",(char *) "item", NULL
39795 };
39796
39797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
39798 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39799 if (!SWIG_IsOK(res1)) {
39800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
39801 }
39802 arg1 = reinterpret_cast< wxMenu * >(argp1);
39803 {
39804 arg2 = wxString_in_helper(obj1);
39805 if (arg2 == NULL) SWIG_fail;
39806 temp2 = true;
39807 }
39808 {
39809 PyThreadState* __tstate = wxPyBeginAllowThreads();
39810 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
39811 wxPyEndAllowThreads(__tstate);
39812 if (PyErr_Occurred()) SWIG_fail;
39813 }
39814 resultobj = SWIG_From_int(static_cast< int >(result));
39815 {
39816 if (temp2)
39817 delete arg2;
39818 }
39819 return resultobj;
39820 fail:
39821 {
39822 if (temp2)
39823 delete arg2;
39824 }
39825 return NULL;
39826 }
39827
39828
39829 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39830 PyObject *resultobj = 0;
39831 wxMenu *arg1 = (wxMenu *) 0 ;
39832 int arg2 ;
39833 wxMenuItem *result = 0 ;
39834 void *argp1 = 0 ;
39835 int res1 = 0 ;
39836 int val2 ;
39837 int ecode2 = 0 ;
39838 PyObject * obj0 = 0 ;
39839 PyObject * obj1 = 0 ;
39840 char * kwnames[] = {
39841 (char *) "self",(char *) "id", NULL
39842 };
39843
39844 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
39845 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39846 if (!SWIG_IsOK(res1)) {
39847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
39848 }
39849 arg1 = reinterpret_cast< wxMenu * >(argp1);
39850 ecode2 = SWIG_AsVal_int(obj1, &val2);
39851 if (!SWIG_IsOK(ecode2)) {
39852 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
39853 }
39854 arg2 = static_cast< int >(val2);
39855 {
39856 PyThreadState* __tstate = wxPyBeginAllowThreads();
39857 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
39858 wxPyEndAllowThreads(__tstate);
39859 if (PyErr_Occurred()) SWIG_fail;
39860 }
39861 {
39862 resultobj = wxPyMake_wxObject(result, (bool)0);
39863 }
39864 return resultobj;
39865 fail:
39866 return NULL;
39867 }
39868
39869
39870 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39871 PyObject *resultobj = 0;
39872 wxMenu *arg1 = (wxMenu *) 0 ;
39873 size_t arg2 ;
39874 wxMenuItem *result = 0 ;
39875 void *argp1 = 0 ;
39876 int res1 = 0 ;
39877 size_t val2 ;
39878 int ecode2 = 0 ;
39879 PyObject * obj0 = 0 ;
39880 PyObject * obj1 = 0 ;
39881 char * kwnames[] = {
39882 (char *) "self",(char *) "position", NULL
39883 };
39884
39885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
39886 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39887 if (!SWIG_IsOK(res1)) {
39888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
39889 }
39890 arg1 = reinterpret_cast< wxMenu * >(argp1);
39891 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39892 if (!SWIG_IsOK(ecode2)) {
39893 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
39894 }
39895 arg2 = static_cast< size_t >(val2);
39896 {
39897 PyThreadState* __tstate = wxPyBeginAllowThreads();
39898 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
39899 wxPyEndAllowThreads(__tstate);
39900 if (PyErr_Occurred()) SWIG_fail;
39901 }
39902 {
39903 resultobj = wxPyMake_wxObject(result, (bool)0);
39904 }
39905 return resultobj;
39906 fail:
39907 return NULL;
39908 }
39909
39910
39911 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39912 PyObject *resultobj = 0;
39913 wxMenu *arg1 = (wxMenu *) 0 ;
39914 int arg2 ;
39915 bool arg3 ;
39916 void *argp1 = 0 ;
39917 int res1 = 0 ;
39918 int val2 ;
39919 int ecode2 = 0 ;
39920 bool val3 ;
39921 int ecode3 = 0 ;
39922 PyObject * obj0 = 0 ;
39923 PyObject * obj1 = 0 ;
39924 PyObject * obj2 = 0 ;
39925 char * kwnames[] = {
39926 (char *) "self",(char *) "id",(char *) "enable", NULL
39927 };
39928
39929 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39930 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39931 if (!SWIG_IsOK(res1)) {
39932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
39933 }
39934 arg1 = reinterpret_cast< wxMenu * >(argp1);
39935 ecode2 = SWIG_AsVal_int(obj1, &val2);
39936 if (!SWIG_IsOK(ecode2)) {
39937 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
39938 }
39939 arg2 = static_cast< int >(val2);
39940 ecode3 = SWIG_AsVal_bool(obj2, &val3);
39941 if (!SWIG_IsOK(ecode3)) {
39942 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
39943 }
39944 arg3 = static_cast< bool >(val3);
39945 {
39946 PyThreadState* __tstate = wxPyBeginAllowThreads();
39947 (arg1)->Enable(arg2,arg3);
39948 wxPyEndAllowThreads(__tstate);
39949 if (PyErr_Occurred()) SWIG_fail;
39950 }
39951 resultobj = SWIG_Py_Void();
39952 return resultobj;
39953 fail:
39954 return NULL;
39955 }
39956
39957
39958 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39959 PyObject *resultobj = 0;
39960 wxMenu *arg1 = (wxMenu *) 0 ;
39961 int arg2 ;
39962 bool result;
39963 void *argp1 = 0 ;
39964 int res1 = 0 ;
39965 int val2 ;
39966 int ecode2 = 0 ;
39967 PyObject * obj0 = 0 ;
39968 PyObject * obj1 = 0 ;
39969 char * kwnames[] = {
39970 (char *) "self",(char *) "id", NULL
39971 };
39972
39973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
39974 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39975 if (!SWIG_IsOK(res1)) {
39976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
39977 }
39978 arg1 = reinterpret_cast< wxMenu * >(argp1);
39979 ecode2 = SWIG_AsVal_int(obj1, &val2);
39980 if (!SWIG_IsOK(ecode2)) {
39981 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
39982 }
39983 arg2 = static_cast< int >(val2);
39984 {
39985 PyThreadState* __tstate = wxPyBeginAllowThreads();
39986 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
39987 wxPyEndAllowThreads(__tstate);
39988 if (PyErr_Occurred()) SWIG_fail;
39989 }
39990 {
39991 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39992 }
39993 return resultobj;
39994 fail:
39995 return NULL;
39996 }
39997
39998
39999 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40000 PyObject *resultobj = 0;
40001 wxMenu *arg1 = (wxMenu *) 0 ;
40002 int arg2 ;
40003 bool arg3 ;
40004 void *argp1 = 0 ;
40005 int res1 = 0 ;
40006 int val2 ;
40007 int ecode2 = 0 ;
40008 bool val3 ;
40009 int ecode3 = 0 ;
40010 PyObject * obj0 = 0 ;
40011 PyObject * obj1 = 0 ;
40012 PyObject * obj2 = 0 ;
40013 char * kwnames[] = {
40014 (char *) "self",(char *) "id",(char *) "check", NULL
40015 };
40016
40017 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40018 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40019 if (!SWIG_IsOK(res1)) {
40020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
40021 }
40022 arg1 = reinterpret_cast< wxMenu * >(argp1);
40023 ecode2 = SWIG_AsVal_int(obj1, &val2);
40024 if (!SWIG_IsOK(ecode2)) {
40025 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
40026 }
40027 arg2 = static_cast< int >(val2);
40028 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40029 if (!SWIG_IsOK(ecode3)) {
40030 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
40031 }
40032 arg3 = static_cast< bool >(val3);
40033 {
40034 PyThreadState* __tstate = wxPyBeginAllowThreads();
40035 (arg1)->Check(arg2,arg3);
40036 wxPyEndAllowThreads(__tstate);
40037 if (PyErr_Occurred()) SWIG_fail;
40038 }
40039 resultobj = SWIG_Py_Void();
40040 return resultobj;
40041 fail:
40042 return NULL;
40043 }
40044
40045
40046 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40047 PyObject *resultobj = 0;
40048 wxMenu *arg1 = (wxMenu *) 0 ;
40049 int arg2 ;
40050 bool result;
40051 void *argp1 = 0 ;
40052 int res1 = 0 ;
40053 int val2 ;
40054 int ecode2 = 0 ;
40055 PyObject * obj0 = 0 ;
40056 PyObject * obj1 = 0 ;
40057 char * kwnames[] = {
40058 (char *) "self",(char *) "id", NULL
40059 };
40060
40061 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
40062 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40063 if (!SWIG_IsOK(res1)) {
40064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
40065 }
40066 arg1 = reinterpret_cast< wxMenu * >(argp1);
40067 ecode2 = SWIG_AsVal_int(obj1, &val2);
40068 if (!SWIG_IsOK(ecode2)) {
40069 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
40070 }
40071 arg2 = static_cast< int >(val2);
40072 {
40073 PyThreadState* __tstate = wxPyBeginAllowThreads();
40074 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
40075 wxPyEndAllowThreads(__tstate);
40076 if (PyErr_Occurred()) SWIG_fail;
40077 }
40078 {
40079 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40080 }
40081 return resultobj;
40082 fail:
40083 return NULL;
40084 }
40085
40086
40087 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40088 PyObject *resultobj = 0;
40089 wxMenu *arg1 = (wxMenu *) 0 ;
40090 int arg2 ;
40091 wxString *arg3 = 0 ;
40092 void *argp1 = 0 ;
40093 int res1 = 0 ;
40094 int val2 ;
40095 int ecode2 = 0 ;
40096 bool temp3 = false ;
40097 PyObject * obj0 = 0 ;
40098 PyObject * obj1 = 0 ;
40099 PyObject * obj2 = 0 ;
40100 char * kwnames[] = {
40101 (char *) "self",(char *) "id",(char *) "label", NULL
40102 };
40103
40104 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40105 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40106 if (!SWIG_IsOK(res1)) {
40107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
40108 }
40109 arg1 = reinterpret_cast< wxMenu * >(argp1);
40110 ecode2 = SWIG_AsVal_int(obj1, &val2);
40111 if (!SWIG_IsOK(ecode2)) {
40112 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
40113 }
40114 arg2 = static_cast< int >(val2);
40115 {
40116 arg3 = wxString_in_helper(obj2);
40117 if (arg3 == NULL) SWIG_fail;
40118 temp3 = true;
40119 }
40120 {
40121 PyThreadState* __tstate = wxPyBeginAllowThreads();
40122 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
40123 wxPyEndAllowThreads(__tstate);
40124 if (PyErr_Occurred()) SWIG_fail;
40125 }
40126 resultobj = SWIG_Py_Void();
40127 {
40128 if (temp3)
40129 delete arg3;
40130 }
40131 return resultobj;
40132 fail:
40133 {
40134 if (temp3)
40135 delete arg3;
40136 }
40137 return NULL;
40138 }
40139
40140
40141 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40142 PyObject *resultobj = 0;
40143 wxMenu *arg1 = (wxMenu *) 0 ;
40144 int arg2 ;
40145 wxString result;
40146 void *argp1 = 0 ;
40147 int res1 = 0 ;
40148 int val2 ;
40149 int ecode2 = 0 ;
40150 PyObject * obj0 = 0 ;
40151 PyObject * obj1 = 0 ;
40152 char * kwnames[] = {
40153 (char *) "self",(char *) "id", NULL
40154 };
40155
40156 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
40157 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40158 if (!SWIG_IsOK(res1)) {
40159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
40160 }
40161 arg1 = reinterpret_cast< wxMenu * >(argp1);
40162 ecode2 = SWIG_AsVal_int(obj1, &val2);
40163 if (!SWIG_IsOK(ecode2)) {
40164 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
40165 }
40166 arg2 = static_cast< int >(val2);
40167 {
40168 PyThreadState* __tstate = wxPyBeginAllowThreads();
40169 result = ((wxMenu const *)arg1)->GetLabel(arg2);
40170 wxPyEndAllowThreads(__tstate);
40171 if (PyErr_Occurred()) SWIG_fail;
40172 }
40173 {
40174 #if wxUSE_UNICODE
40175 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40176 #else
40177 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40178 #endif
40179 }
40180 return resultobj;
40181 fail:
40182 return NULL;
40183 }
40184
40185
40186 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40187 PyObject *resultobj = 0;
40188 wxMenu *arg1 = (wxMenu *) 0 ;
40189 int arg2 ;
40190 wxString *arg3 = 0 ;
40191 void *argp1 = 0 ;
40192 int res1 = 0 ;
40193 int val2 ;
40194 int ecode2 = 0 ;
40195 bool temp3 = false ;
40196 PyObject * obj0 = 0 ;
40197 PyObject * obj1 = 0 ;
40198 PyObject * obj2 = 0 ;
40199 char * kwnames[] = {
40200 (char *) "self",(char *) "id",(char *) "helpString", NULL
40201 };
40202
40203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40204 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40205 if (!SWIG_IsOK(res1)) {
40206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
40207 }
40208 arg1 = reinterpret_cast< wxMenu * >(argp1);
40209 ecode2 = SWIG_AsVal_int(obj1, &val2);
40210 if (!SWIG_IsOK(ecode2)) {
40211 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
40212 }
40213 arg2 = static_cast< int >(val2);
40214 {
40215 arg3 = wxString_in_helper(obj2);
40216 if (arg3 == NULL) SWIG_fail;
40217 temp3 = true;
40218 }
40219 {
40220 PyThreadState* __tstate = wxPyBeginAllowThreads();
40221 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
40222 wxPyEndAllowThreads(__tstate);
40223 if (PyErr_Occurred()) SWIG_fail;
40224 }
40225 resultobj = SWIG_Py_Void();
40226 {
40227 if (temp3)
40228 delete arg3;
40229 }
40230 return resultobj;
40231 fail:
40232 {
40233 if (temp3)
40234 delete arg3;
40235 }
40236 return NULL;
40237 }
40238
40239
40240 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40241 PyObject *resultobj = 0;
40242 wxMenu *arg1 = (wxMenu *) 0 ;
40243 int arg2 ;
40244 wxString result;
40245 void *argp1 = 0 ;
40246 int res1 = 0 ;
40247 int val2 ;
40248 int ecode2 = 0 ;
40249 PyObject * obj0 = 0 ;
40250 PyObject * obj1 = 0 ;
40251 char * kwnames[] = {
40252 (char *) "self",(char *) "id", NULL
40253 };
40254
40255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
40256 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40257 if (!SWIG_IsOK(res1)) {
40258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
40259 }
40260 arg1 = reinterpret_cast< wxMenu * >(argp1);
40261 ecode2 = SWIG_AsVal_int(obj1, &val2);
40262 if (!SWIG_IsOK(ecode2)) {
40263 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
40264 }
40265 arg2 = static_cast< int >(val2);
40266 {
40267 PyThreadState* __tstate = wxPyBeginAllowThreads();
40268 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
40269 wxPyEndAllowThreads(__tstate);
40270 if (PyErr_Occurred()) SWIG_fail;
40271 }
40272 {
40273 #if wxUSE_UNICODE
40274 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40275 #else
40276 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40277 #endif
40278 }
40279 return resultobj;
40280 fail:
40281 return NULL;
40282 }
40283
40284
40285 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40286 PyObject *resultobj = 0;
40287 wxMenu *arg1 = (wxMenu *) 0 ;
40288 wxString *arg2 = 0 ;
40289 void *argp1 = 0 ;
40290 int res1 = 0 ;
40291 bool temp2 = false ;
40292 PyObject * obj0 = 0 ;
40293 PyObject * obj1 = 0 ;
40294 char * kwnames[] = {
40295 (char *) "self",(char *) "title", NULL
40296 };
40297
40298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
40299 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40300 if (!SWIG_IsOK(res1)) {
40301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
40302 }
40303 arg1 = reinterpret_cast< wxMenu * >(argp1);
40304 {
40305 arg2 = wxString_in_helper(obj1);
40306 if (arg2 == NULL) SWIG_fail;
40307 temp2 = true;
40308 }
40309 {
40310 PyThreadState* __tstate = wxPyBeginAllowThreads();
40311 (arg1)->SetTitle((wxString const &)*arg2);
40312 wxPyEndAllowThreads(__tstate);
40313 if (PyErr_Occurred()) SWIG_fail;
40314 }
40315 resultobj = SWIG_Py_Void();
40316 {
40317 if (temp2)
40318 delete arg2;
40319 }
40320 return resultobj;
40321 fail:
40322 {
40323 if (temp2)
40324 delete arg2;
40325 }
40326 return NULL;
40327 }
40328
40329
40330 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40331 PyObject *resultobj = 0;
40332 wxMenu *arg1 = (wxMenu *) 0 ;
40333 wxString result;
40334 void *argp1 = 0 ;
40335 int res1 = 0 ;
40336 PyObject *swig_obj[1] ;
40337
40338 if (!args) SWIG_fail;
40339 swig_obj[0] = args;
40340 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40341 if (!SWIG_IsOK(res1)) {
40342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40343 }
40344 arg1 = reinterpret_cast< wxMenu * >(argp1);
40345 {
40346 PyThreadState* __tstate = wxPyBeginAllowThreads();
40347 result = ((wxMenu const *)arg1)->GetTitle();
40348 wxPyEndAllowThreads(__tstate);
40349 if (PyErr_Occurred()) SWIG_fail;
40350 }
40351 {
40352 #if wxUSE_UNICODE
40353 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40354 #else
40355 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40356 #endif
40357 }
40358 return resultobj;
40359 fail:
40360 return NULL;
40361 }
40362
40363
40364 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40365 PyObject *resultobj = 0;
40366 wxMenu *arg1 = (wxMenu *) 0 ;
40367 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
40368 void *argp1 = 0 ;
40369 int res1 = 0 ;
40370 void *argp2 = 0 ;
40371 int res2 = 0 ;
40372 PyObject * obj0 = 0 ;
40373 PyObject * obj1 = 0 ;
40374 char * kwnames[] = {
40375 (char *) "self",(char *) "handler", NULL
40376 };
40377
40378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
40379 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40380 if (!SWIG_IsOK(res1)) {
40381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
40382 }
40383 arg1 = reinterpret_cast< wxMenu * >(argp1);
40384 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40385 if (!SWIG_IsOK(res2)) {
40386 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40387 }
40388 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40389 {
40390 PyThreadState* __tstate = wxPyBeginAllowThreads();
40391 (arg1)->SetEventHandler(arg2);
40392 wxPyEndAllowThreads(__tstate);
40393 if (PyErr_Occurred()) SWIG_fail;
40394 }
40395 resultobj = SWIG_Py_Void();
40396 return resultobj;
40397 fail:
40398 return NULL;
40399 }
40400
40401
40402 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40403 PyObject *resultobj = 0;
40404 wxMenu *arg1 = (wxMenu *) 0 ;
40405 wxEvtHandler *result = 0 ;
40406 void *argp1 = 0 ;
40407 int res1 = 0 ;
40408 PyObject *swig_obj[1] ;
40409
40410 if (!args) SWIG_fail;
40411 swig_obj[0] = args;
40412 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40413 if (!SWIG_IsOK(res1)) {
40414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
40415 }
40416 arg1 = reinterpret_cast< wxMenu * >(argp1);
40417 {
40418 PyThreadState* __tstate = wxPyBeginAllowThreads();
40419 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
40420 wxPyEndAllowThreads(__tstate);
40421 if (PyErr_Occurred()) SWIG_fail;
40422 }
40423 {
40424 resultobj = wxPyMake_wxObject(result, 0);
40425 }
40426 return resultobj;
40427 fail:
40428 return NULL;
40429 }
40430
40431
40432 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40433 PyObject *resultobj = 0;
40434 wxMenu *arg1 = (wxMenu *) 0 ;
40435 wxWindow *arg2 = (wxWindow *) 0 ;
40436 void *argp1 = 0 ;
40437 int res1 = 0 ;
40438 void *argp2 = 0 ;
40439 int res2 = 0 ;
40440 PyObject * obj0 = 0 ;
40441 PyObject * obj1 = 0 ;
40442 char * kwnames[] = {
40443 (char *) "self",(char *) "win", NULL
40444 };
40445
40446 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
40447 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40448 if (!SWIG_IsOK(res1)) {
40449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
40450 }
40451 arg1 = reinterpret_cast< wxMenu * >(argp1);
40452 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
40453 if (!SWIG_IsOK(res2)) {
40454 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
40455 }
40456 arg2 = reinterpret_cast< wxWindow * >(argp2);
40457 {
40458 PyThreadState* __tstate = wxPyBeginAllowThreads();
40459 (arg1)->SetInvokingWindow(arg2);
40460 wxPyEndAllowThreads(__tstate);
40461 if (PyErr_Occurred()) SWIG_fail;
40462 }
40463 resultobj = SWIG_Py_Void();
40464 return resultobj;
40465 fail:
40466 return NULL;
40467 }
40468
40469
40470 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40471 PyObject *resultobj = 0;
40472 wxMenu *arg1 = (wxMenu *) 0 ;
40473 wxWindow *result = 0 ;
40474 void *argp1 = 0 ;
40475 int res1 = 0 ;
40476 PyObject *swig_obj[1] ;
40477
40478 if (!args) SWIG_fail;
40479 swig_obj[0] = args;
40480 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40481 if (!SWIG_IsOK(res1)) {
40482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
40483 }
40484 arg1 = reinterpret_cast< wxMenu * >(argp1);
40485 {
40486 PyThreadState* __tstate = wxPyBeginAllowThreads();
40487 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
40488 wxPyEndAllowThreads(__tstate);
40489 if (PyErr_Occurred()) SWIG_fail;
40490 }
40491 {
40492 resultobj = wxPyMake_wxObject(result, 0);
40493 }
40494 return resultobj;
40495 fail:
40496 return NULL;
40497 }
40498
40499
40500 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40501 PyObject *resultobj = 0;
40502 wxMenu *arg1 = (wxMenu *) 0 ;
40503 long result;
40504 void *argp1 = 0 ;
40505 int res1 = 0 ;
40506 PyObject *swig_obj[1] ;
40507
40508 if (!args) SWIG_fail;
40509 swig_obj[0] = args;
40510 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40511 if (!SWIG_IsOK(res1)) {
40512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40513 }
40514 arg1 = reinterpret_cast< wxMenu * >(argp1);
40515 {
40516 PyThreadState* __tstate = wxPyBeginAllowThreads();
40517 result = (long)((wxMenu const *)arg1)->GetStyle();
40518 wxPyEndAllowThreads(__tstate);
40519 if (PyErr_Occurred()) SWIG_fail;
40520 }
40521 resultobj = SWIG_From_long(static_cast< long >(result));
40522 return resultobj;
40523 fail:
40524 return NULL;
40525 }
40526
40527
40528 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40529 PyObject *resultobj = 0;
40530 wxMenu *arg1 = (wxMenu *) 0 ;
40531 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
40532 void *argp1 = 0 ;
40533 int res1 = 0 ;
40534 void *argp2 = 0 ;
40535 int res2 = 0 ;
40536 PyObject * obj0 = 0 ;
40537 PyObject * obj1 = 0 ;
40538 char * kwnames[] = {
40539 (char *) "self",(char *) "source", NULL
40540 };
40541
40542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
40543 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40544 if (!SWIG_IsOK(res1)) {
40545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
40546 }
40547 arg1 = reinterpret_cast< wxMenu * >(argp1);
40548 if (obj1) {
40549 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40550 if (!SWIG_IsOK(res2)) {
40551 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40552 }
40553 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40554 }
40555 {
40556 PyThreadState* __tstate = wxPyBeginAllowThreads();
40557 (arg1)->UpdateUI(arg2);
40558 wxPyEndAllowThreads(__tstate);
40559 if (PyErr_Occurred()) SWIG_fail;
40560 }
40561 resultobj = SWIG_Py_Void();
40562 return resultobj;
40563 fail:
40564 return NULL;
40565 }
40566
40567
40568 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40569 PyObject *resultobj = 0;
40570 wxMenu *arg1 = (wxMenu *) 0 ;
40571 wxMenuBar *result = 0 ;
40572 void *argp1 = 0 ;
40573 int res1 = 0 ;
40574 PyObject *swig_obj[1] ;
40575
40576 if (!args) SWIG_fail;
40577 swig_obj[0] = args;
40578 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40579 if (!SWIG_IsOK(res1)) {
40580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
40581 }
40582 arg1 = reinterpret_cast< wxMenu * >(argp1);
40583 {
40584 PyThreadState* __tstate = wxPyBeginAllowThreads();
40585 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
40586 wxPyEndAllowThreads(__tstate);
40587 if (PyErr_Occurred()) SWIG_fail;
40588 }
40589 {
40590 resultobj = wxPyMake_wxObject(result, (bool)0);
40591 }
40592 return resultobj;
40593 fail:
40594 return NULL;
40595 }
40596
40597
40598 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40599 PyObject *resultobj = 0;
40600 wxMenu *arg1 = (wxMenu *) 0 ;
40601 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
40602 void *argp1 = 0 ;
40603 int res1 = 0 ;
40604 void *argp2 = 0 ;
40605 int res2 = 0 ;
40606 PyObject * obj0 = 0 ;
40607 PyObject * obj1 = 0 ;
40608 char * kwnames[] = {
40609 (char *) "self",(char *) "menubar", NULL
40610 };
40611
40612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
40613 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40614 if (!SWIG_IsOK(res1)) {
40615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
40616 }
40617 arg1 = reinterpret_cast< wxMenu * >(argp1);
40618 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
40619 if (!SWIG_IsOK(res2)) {
40620 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
40621 }
40622 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
40623 {
40624 PyThreadState* __tstate = wxPyBeginAllowThreads();
40625 (arg1)->Attach(arg2);
40626 wxPyEndAllowThreads(__tstate);
40627 if (PyErr_Occurred()) SWIG_fail;
40628 }
40629 resultobj = SWIG_Py_Void();
40630 return resultobj;
40631 fail:
40632 return NULL;
40633 }
40634
40635
40636 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40637 PyObject *resultobj = 0;
40638 wxMenu *arg1 = (wxMenu *) 0 ;
40639 void *argp1 = 0 ;
40640 int res1 = 0 ;
40641 PyObject *swig_obj[1] ;
40642
40643 if (!args) SWIG_fail;
40644 swig_obj[0] = args;
40645 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40646 if (!SWIG_IsOK(res1)) {
40647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
40648 }
40649 arg1 = reinterpret_cast< wxMenu * >(argp1);
40650 {
40651 PyThreadState* __tstate = wxPyBeginAllowThreads();
40652 (arg1)->Detach();
40653 wxPyEndAllowThreads(__tstate);
40654 if (PyErr_Occurred()) SWIG_fail;
40655 }
40656 resultobj = SWIG_Py_Void();
40657 return resultobj;
40658 fail:
40659 return NULL;
40660 }
40661
40662
40663 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40664 PyObject *resultobj = 0;
40665 wxMenu *arg1 = (wxMenu *) 0 ;
40666 bool result;
40667 void *argp1 = 0 ;
40668 int res1 = 0 ;
40669 PyObject *swig_obj[1] ;
40670
40671 if (!args) SWIG_fail;
40672 swig_obj[0] = args;
40673 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40674 if (!SWIG_IsOK(res1)) {
40675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
40676 }
40677 arg1 = reinterpret_cast< wxMenu * >(argp1);
40678 {
40679 PyThreadState* __tstate = wxPyBeginAllowThreads();
40680 result = (bool)((wxMenu const *)arg1)->IsAttached();
40681 wxPyEndAllowThreads(__tstate);
40682 if (PyErr_Occurred()) SWIG_fail;
40683 }
40684 {
40685 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40686 }
40687 return resultobj;
40688 fail:
40689 return NULL;
40690 }
40691
40692
40693 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40694 PyObject *resultobj = 0;
40695 wxMenu *arg1 = (wxMenu *) 0 ;
40696 wxMenu *arg2 = (wxMenu *) 0 ;
40697 void *argp1 = 0 ;
40698 int res1 = 0 ;
40699 void *argp2 = 0 ;
40700 int res2 = 0 ;
40701 PyObject * obj0 = 0 ;
40702 PyObject * obj1 = 0 ;
40703 char * kwnames[] = {
40704 (char *) "self",(char *) "parent", NULL
40705 };
40706
40707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
40708 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40709 if (!SWIG_IsOK(res1)) {
40710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
40711 }
40712 arg1 = reinterpret_cast< wxMenu * >(argp1);
40713 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
40714 if (!SWIG_IsOK(res2)) {
40715 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
40716 }
40717 arg2 = reinterpret_cast< wxMenu * >(argp2);
40718 {
40719 PyThreadState* __tstate = wxPyBeginAllowThreads();
40720 (arg1)->SetParent(arg2);
40721 wxPyEndAllowThreads(__tstate);
40722 if (PyErr_Occurred()) SWIG_fail;
40723 }
40724 resultobj = SWIG_Py_Void();
40725 return resultobj;
40726 fail:
40727 return NULL;
40728 }
40729
40730
40731 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40732 PyObject *resultobj = 0;
40733 wxMenu *arg1 = (wxMenu *) 0 ;
40734 wxMenu *result = 0 ;
40735 void *argp1 = 0 ;
40736 int res1 = 0 ;
40737 PyObject *swig_obj[1] ;
40738
40739 if (!args) SWIG_fail;
40740 swig_obj[0] = args;
40741 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40742 if (!SWIG_IsOK(res1)) {
40743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
40744 }
40745 arg1 = reinterpret_cast< wxMenu * >(argp1);
40746 {
40747 PyThreadState* __tstate = wxPyBeginAllowThreads();
40748 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
40749 wxPyEndAllowThreads(__tstate);
40750 if (PyErr_Occurred()) SWIG_fail;
40751 }
40752 {
40753 resultobj = wxPyMake_wxObject(result, 0);
40754 }
40755 return resultobj;
40756 fail:
40757 return NULL;
40758 }
40759
40760
40761 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40762 PyObject *obj;
40763 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
40764 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
40765 return SWIG_Py_Void();
40766 }
40767
40768 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40769 return SWIG_Python_InitShadowInstance(args);
40770 }
40771
40772 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40773 PyObject *resultobj = 0;
40774 long arg1 = (long) 0 ;
40775 wxMenuBar *result = 0 ;
40776 long val1 ;
40777 int ecode1 = 0 ;
40778 PyObject * obj0 = 0 ;
40779 char * kwnames[] = {
40780 (char *) "style", NULL
40781 };
40782
40783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
40784 if (obj0) {
40785 ecode1 = SWIG_AsVal_long(obj0, &val1);
40786 if (!SWIG_IsOK(ecode1)) {
40787 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
40788 }
40789 arg1 = static_cast< long >(val1);
40790 }
40791 {
40792 if (!wxPyCheckForApp()) SWIG_fail;
40793 PyThreadState* __tstate = wxPyBeginAllowThreads();
40794 result = (wxMenuBar *)new wxMenuBar(arg1);
40795 wxPyEndAllowThreads(__tstate);
40796 if (PyErr_Occurred()) SWIG_fail;
40797 }
40798 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
40799 return resultobj;
40800 fail:
40801 return NULL;
40802 }
40803
40804
40805 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40806 PyObject *resultobj = 0;
40807 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40808 wxMenu *arg2 = (wxMenu *) 0 ;
40809 wxString *arg3 = 0 ;
40810 bool result;
40811 void *argp1 = 0 ;
40812 int res1 = 0 ;
40813 void *argp2 = 0 ;
40814 int res2 = 0 ;
40815 bool temp3 = false ;
40816 PyObject * obj0 = 0 ;
40817 PyObject * obj1 = 0 ;
40818 PyObject * obj2 = 0 ;
40819 char * kwnames[] = {
40820 (char *) "self",(char *) "menu",(char *) "title", NULL
40821 };
40822
40823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40825 if (!SWIG_IsOK(res1)) {
40826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40827 }
40828 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40829 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
40830 if (!SWIG_IsOK(res2)) {
40831 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
40832 }
40833 arg2 = reinterpret_cast< wxMenu * >(argp2);
40834 {
40835 arg3 = wxString_in_helper(obj2);
40836 if (arg3 == NULL) SWIG_fail;
40837 temp3 = true;
40838 }
40839 {
40840 PyThreadState* __tstate = wxPyBeginAllowThreads();
40841 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
40842 wxPyEndAllowThreads(__tstate);
40843 if (PyErr_Occurred()) SWIG_fail;
40844 }
40845 {
40846 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40847 }
40848 {
40849 if (temp3)
40850 delete arg3;
40851 }
40852 return resultobj;
40853 fail:
40854 {
40855 if (temp3)
40856 delete arg3;
40857 }
40858 return NULL;
40859 }
40860
40861
40862 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40863 PyObject *resultobj = 0;
40864 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40865 size_t arg2 ;
40866 wxMenu *arg3 = (wxMenu *) 0 ;
40867 wxString *arg4 = 0 ;
40868 bool result;
40869 void *argp1 = 0 ;
40870 int res1 = 0 ;
40871 size_t val2 ;
40872 int ecode2 = 0 ;
40873 void *argp3 = 0 ;
40874 int res3 = 0 ;
40875 bool temp4 = false ;
40876 PyObject * obj0 = 0 ;
40877 PyObject * obj1 = 0 ;
40878 PyObject * obj2 = 0 ;
40879 PyObject * obj3 = 0 ;
40880 char * kwnames[] = {
40881 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
40882 };
40883
40884 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40885 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40886 if (!SWIG_IsOK(res1)) {
40887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40888 }
40889 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40890 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40891 if (!SWIG_IsOK(ecode2)) {
40892 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
40893 }
40894 arg2 = static_cast< size_t >(val2);
40895 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
40896 if (!SWIG_IsOK(res3)) {
40897 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
40898 }
40899 arg3 = reinterpret_cast< wxMenu * >(argp3);
40900 {
40901 arg4 = wxString_in_helper(obj3);
40902 if (arg4 == NULL) SWIG_fail;
40903 temp4 = true;
40904 }
40905 {
40906 PyThreadState* __tstate = wxPyBeginAllowThreads();
40907 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
40908 wxPyEndAllowThreads(__tstate);
40909 if (PyErr_Occurred()) SWIG_fail;
40910 }
40911 {
40912 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40913 }
40914 {
40915 if (temp4)
40916 delete arg4;
40917 }
40918 return resultobj;
40919 fail:
40920 {
40921 if (temp4)
40922 delete arg4;
40923 }
40924 return NULL;
40925 }
40926
40927
40928 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40929 PyObject *resultobj = 0;
40930 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40931 size_t result;
40932 void *argp1 = 0 ;
40933 int res1 = 0 ;
40934 PyObject *swig_obj[1] ;
40935
40936 if (!args) SWIG_fail;
40937 swig_obj[0] = args;
40938 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40939 if (!SWIG_IsOK(res1)) {
40940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
40941 }
40942 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40943 {
40944 PyThreadState* __tstate = wxPyBeginAllowThreads();
40945 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
40946 wxPyEndAllowThreads(__tstate);
40947 if (PyErr_Occurred()) SWIG_fail;
40948 }
40949 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
40950 return resultobj;
40951 fail:
40952 return NULL;
40953 }
40954
40955
40956 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40957 PyObject *resultobj = 0;
40958 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40959 size_t arg2 ;
40960 wxMenu *result = 0 ;
40961 void *argp1 = 0 ;
40962 int res1 = 0 ;
40963 size_t val2 ;
40964 int ecode2 = 0 ;
40965 PyObject * obj0 = 0 ;
40966 PyObject * obj1 = 0 ;
40967 char * kwnames[] = {
40968 (char *) "self",(char *) "pos", NULL
40969 };
40970
40971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
40972 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40973 if (!SWIG_IsOK(res1)) {
40974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
40975 }
40976 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40977 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40978 if (!SWIG_IsOK(ecode2)) {
40979 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
40980 }
40981 arg2 = static_cast< size_t >(val2);
40982 {
40983 PyThreadState* __tstate = wxPyBeginAllowThreads();
40984 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
40985 wxPyEndAllowThreads(__tstate);
40986 if (PyErr_Occurred()) SWIG_fail;
40987 }
40988 {
40989 resultobj = wxPyMake_wxObject(result, 0);
40990 }
40991 return resultobj;
40992 fail:
40993 return NULL;
40994 }
40995
40996
40997 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40998 PyObject *resultobj = 0;
40999 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41000 size_t arg2 ;
41001 wxMenu *arg3 = (wxMenu *) 0 ;
41002 wxString *arg4 = 0 ;
41003 wxMenu *result = 0 ;
41004 void *argp1 = 0 ;
41005 int res1 = 0 ;
41006 size_t val2 ;
41007 int ecode2 = 0 ;
41008 void *argp3 = 0 ;
41009 int res3 = 0 ;
41010 bool temp4 = false ;
41011 PyObject * obj0 = 0 ;
41012 PyObject * obj1 = 0 ;
41013 PyObject * obj2 = 0 ;
41014 PyObject * obj3 = 0 ;
41015 char * kwnames[] = {
41016 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
41017 };
41018
41019 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41020 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41021 if (!SWIG_IsOK(res1)) {
41022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41023 }
41024 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41025 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41026 if (!SWIG_IsOK(ecode2)) {
41027 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
41028 }
41029 arg2 = static_cast< size_t >(val2);
41030 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
41031 if (!SWIG_IsOK(res3)) {
41032 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
41033 }
41034 arg3 = reinterpret_cast< wxMenu * >(argp3);
41035 {
41036 arg4 = wxString_in_helper(obj3);
41037 if (arg4 == NULL) SWIG_fail;
41038 temp4 = true;
41039 }
41040 {
41041 PyThreadState* __tstate = wxPyBeginAllowThreads();
41042 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
41043 wxPyEndAllowThreads(__tstate);
41044 if (PyErr_Occurred()) SWIG_fail;
41045 }
41046 {
41047 resultobj = wxPyMake_wxObject(result, 0);
41048 }
41049 {
41050 if (temp4)
41051 delete arg4;
41052 }
41053 return resultobj;
41054 fail:
41055 {
41056 if (temp4)
41057 delete arg4;
41058 }
41059 return NULL;
41060 }
41061
41062
41063 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41064 PyObject *resultobj = 0;
41065 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41066 size_t arg2 ;
41067 wxMenu *result = 0 ;
41068 void *argp1 = 0 ;
41069 int res1 = 0 ;
41070 size_t val2 ;
41071 int ecode2 = 0 ;
41072 PyObject * obj0 = 0 ;
41073 PyObject * obj1 = 0 ;
41074 char * kwnames[] = {
41075 (char *) "self",(char *) "pos", NULL
41076 };
41077
41078 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
41079 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41080 if (!SWIG_IsOK(res1)) {
41081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41082 }
41083 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41084 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41085 if (!SWIG_IsOK(ecode2)) {
41086 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
41087 }
41088 arg2 = static_cast< size_t >(val2);
41089 {
41090 PyThreadState* __tstate = wxPyBeginAllowThreads();
41091 result = (wxMenu *)(arg1)->Remove(arg2);
41092 wxPyEndAllowThreads(__tstate);
41093 if (PyErr_Occurred()) SWIG_fail;
41094 }
41095 {
41096 resultobj = wxPyMake_wxObject(result, 0);
41097 }
41098 return resultobj;
41099 fail:
41100 return NULL;
41101 }
41102
41103
41104 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41105 PyObject *resultobj = 0;
41106 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41107 size_t arg2 ;
41108 bool arg3 ;
41109 void *argp1 = 0 ;
41110 int res1 = 0 ;
41111 size_t val2 ;
41112 int ecode2 = 0 ;
41113 bool val3 ;
41114 int ecode3 = 0 ;
41115 PyObject * obj0 = 0 ;
41116 PyObject * obj1 = 0 ;
41117 PyObject * obj2 = 0 ;
41118 char * kwnames[] = {
41119 (char *) "self",(char *) "pos",(char *) "enable", NULL
41120 };
41121
41122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41123 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41124 if (!SWIG_IsOK(res1)) {
41125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41126 }
41127 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41128 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41129 if (!SWIG_IsOK(ecode2)) {
41130 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
41131 }
41132 arg2 = static_cast< size_t >(val2);
41133 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41134 if (!SWIG_IsOK(ecode3)) {
41135 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
41136 }
41137 arg3 = static_cast< bool >(val3);
41138 {
41139 PyThreadState* __tstate = wxPyBeginAllowThreads();
41140 (arg1)->EnableTop(arg2,arg3);
41141 wxPyEndAllowThreads(__tstate);
41142 if (PyErr_Occurred()) SWIG_fail;
41143 }
41144 resultobj = SWIG_Py_Void();
41145 return resultobj;
41146 fail:
41147 return NULL;
41148 }
41149
41150
41151 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41152 PyObject *resultobj = 0;
41153 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41154 size_t arg2 ;
41155 bool result;
41156 void *argp1 = 0 ;
41157 int res1 = 0 ;
41158 size_t val2 ;
41159 int ecode2 = 0 ;
41160 PyObject * obj0 = 0 ;
41161 PyObject * obj1 = 0 ;
41162 char * kwnames[] = {
41163 (char *) "self",(char *) "pos", NULL
41164 };
41165
41166 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
41167 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41168 if (!SWIG_IsOK(res1)) {
41169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41170 }
41171 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41172 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41173 if (!SWIG_IsOK(ecode2)) {
41174 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
41175 }
41176 arg2 = static_cast< size_t >(val2);
41177 {
41178 PyThreadState* __tstate = wxPyBeginAllowThreads();
41179 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
41180 wxPyEndAllowThreads(__tstate);
41181 if (PyErr_Occurred()) SWIG_fail;
41182 }
41183 {
41184 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41185 }
41186 return resultobj;
41187 fail:
41188 return NULL;
41189 }
41190
41191
41192 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41193 PyObject *resultobj = 0;
41194 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41195 size_t arg2 ;
41196 wxString *arg3 = 0 ;
41197 void *argp1 = 0 ;
41198 int res1 = 0 ;
41199 size_t val2 ;
41200 int ecode2 = 0 ;
41201 bool temp3 = false ;
41202 PyObject * obj0 = 0 ;
41203 PyObject * obj1 = 0 ;
41204 PyObject * obj2 = 0 ;
41205 char * kwnames[] = {
41206 (char *) "self",(char *) "pos",(char *) "label", NULL
41207 };
41208
41209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41210 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41211 if (!SWIG_IsOK(res1)) {
41212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41213 }
41214 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41215 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41216 if (!SWIG_IsOK(ecode2)) {
41217 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41218 }
41219 arg2 = static_cast< size_t >(val2);
41220 {
41221 arg3 = wxString_in_helper(obj2);
41222 if (arg3 == NULL) SWIG_fail;
41223 temp3 = true;
41224 }
41225 {
41226 PyThreadState* __tstate = wxPyBeginAllowThreads();
41227 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
41228 wxPyEndAllowThreads(__tstate);
41229 if (PyErr_Occurred()) SWIG_fail;
41230 }
41231 resultobj = SWIG_Py_Void();
41232 {
41233 if (temp3)
41234 delete arg3;
41235 }
41236 return resultobj;
41237 fail:
41238 {
41239 if (temp3)
41240 delete arg3;
41241 }
41242 return NULL;
41243 }
41244
41245
41246 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41247 PyObject *resultobj = 0;
41248 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41249 size_t arg2 ;
41250 wxString result;
41251 void *argp1 = 0 ;
41252 int res1 = 0 ;
41253 size_t val2 ;
41254 int ecode2 = 0 ;
41255 PyObject * obj0 = 0 ;
41256 PyObject * obj1 = 0 ;
41257 char * kwnames[] = {
41258 (char *) "self",(char *) "pos", NULL
41259 };
41260
41261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
41262 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41263 if (!SWIG_IsOK(res1)) {
41264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41265 }
41266 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41267 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41268 if (!SWIG_IsOK(ecode2)) {
41269 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41270 }
41271 arg2 = static_cast< size_t >(val2);
41272 {
41273 PyThreadState* __tstate = wxPyBeginAllowThreads();
41274 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
41275 wxPyEndAllowThreads(__tstate);
41276 if (PyErr_Occurred()) SWIG_fail;
41277 }
41278 {
41279 #if wxUSE_UNICODE
41280 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41281 #else
41282 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41283 #endif
41284 }
41285 return resultobj;
41286 fail:
41287 return NULL;
41288 }
41289
41290
41291 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41292 PyObject *resultobj = 0;
41293 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41294 wxString *arg2 = 0 ;
41295 wxString *arg3 = 0 ;
41296 int result;
41297 void *argp1 = 0 ;
41298 int res1 = 0 ;
41299 bool temp2 = false ;
41300 bool temp3 = false ;
41301 PyObject * obj0 = 0 ;
41302 PyObject * obj1 = 0 ;
41303 PyObject * obj2 = 0 ;
41304 char * kwnames[] = {
41305 (char *) "self",(char *) "menu",(char *) "item", NULL
41306 };
41307
41308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41310 if (!SWIG_IsOK(res1)) {
41311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41312 }
41313 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41314 {
41315 arg2 = wxString_in_helper(obj1);
41316 if (arg2 == NULL) SWIG_fail;
41317 temp2 = true;
41318 }
41319 {
41320 arg3 = wxString_in_helper(obj2);
41321 if (arg3 == NULL) SWIG_fail;
41322 temp3 = true;
41323 }
41324 {
41325 PyThreadState* __tstate = wxPyBeginAllowThreads();
41326 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
41327 wxPyEndAllowThreads(__tstate);
41328 if (PyErr_Occurred()) SWIG_fail;
41329 }
41330 resultobj = SWIG_From_int(static_cast< int >(result));
41331 {
41332 if (temp2)
41333 delete arg2;
41334 }
41335 {
41336 if (temp3)
41337 delete arg3;
41338 }
41339 return resultobj;
41340 fail:
41341 {
41342 if (temp2)
41343 delete arg2;
41344 }
41345 {
41346 if (temp3)
41347 delete arg3;
41348 }
41349 return NULL;
41350 }
41351
41352
41353 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41354 PyObject *resultobj = 0;
41355 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41356 int arg2 ;
41357 wxMenuItem *result = 0 ;
41358 void *argp1 = 0 ;
41359 int res1 = 0 ;
41360 int val2 ;
41361 int ecode2 = 0 ;
41362 PyObject * obj0 = 0 ;
41363 PyObject * obj1 = 0 ;
41364 char * kwnames[] = {
41365 (char *) "self",(char *) "id", NULL
41366 };
41367
41368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
41369 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41370 if (!SWIG_IsOK(res1)) {
41371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41372 }
41373 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41374 ecode2 = SWIG_AsVal_int(obj1, &val2);
41375 if (!SWIG_IsOK(ecode2)) {
41376 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
41377 }
41378 arg2 = static_cast< int >(val2);
41379 {
41380 PyThreadState* __tstate = wxPyBeginAllowThreads();
41381 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
41382 wxPyEndAllowThreads(__tstate);
41383 if (PyErr_Occurred()) SWIG_fail;
41384 }
41385 {
41386 resultobj = wxPyMake_wxObject(result, (bool)0);
41387 }
41388 return resultobj;
41389 fail:
41390 return NULL;
41391 }
41392
41393
41394 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41395 PyObject *resultobj = 0;
41396 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41397 wxString *arg2 = 0 ;
41398 int result;
41399 void *argp1 = 0 ;
41400 int res1 = 0 ;
41401 bool temp2 = false ;
41402 PyObject * obj0 = 0 ;
41403 PyObject * obj1 = 0 ;
41404 char * kwnames[] = {
41405 (char *) "self",(char *) "title", NULL
41406 };
41407
41408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41409 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41410 if (!SWIG_IsOK(res1)) {
41411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41412 }
41413 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41414 {
41415 arg2 = wxString_in_helper(obj1);
41416 if (arg2 == NULL) SWIG_fail;
41417 temp2 = true;
41418 }
41419 {
41420 PyThreadState* __tstate = wxPyBeginAllowThreads();
41421 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
41422 wxPyEndAllowThreads(__tstate);
41423 if (PyErr_Occurred()) SWIG_fail;
41424 }
41425 resultobj = SWIG_From_int(static_cast< int >(result));
41426 {
41427 if (temp2)
41428 delete arg2;
41429 }
41430 return resultobj;
41431 fail:
41432 {
41433 if (temp2)
41434 delete arg2;
41435 }
41436 return NULL;
41437 }
41438
41439
41440 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41441 PyObject *resultobj = 0;
41442 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41443 int arg2 ;
41444 bool arg3 ;
41445 void *argp1 = 0 ;
41446 int res1 = 0 ;
41447 int val2 ;
41448 int ecode2 = 0 ;
41449 bool val3 ;
41450 int ecode3 = 0 ;
41451 PyObject * obj0 = 0 ;
41452 PyObject * obj1 = 0 ;
41453 PyObject * obj2 = 0 ;
41454 char * kwnames[] = {
41455 (char *) "self",(char *) "id",(char *) "enable", NULL
41456 };
41457
41458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41460 if (!SWIG_IsOK(res1)) {
41461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41462 }
41463 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41464 ecode2 = SWIG_AsVal_int(obj1, &val2);
41465 if (!SWIG_IsOK(ecode2)) {
41466 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
41467 }
41468 arg2 = static_cast< int >(val2);
41469 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41470 if (!SWIG_IsOK(ecode3)) {
41471 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
41472 }
41473 arg3 = static_cast< bool >(val3);
41474 {
41475 PyThreadState* __tstate = wxPyBeginAllowThreads();
41476 (arg1)->Enable(arg2,arg3);
41477 wxPyEndAllowThreads(__tstate);
41478 if (PyErr_Occurred()) SWIG_fail;
41479 }
41480 resultobj = SWIG_Py_Void();
41481 return resultobj;
41482 fail:
41483 return NULL;
41484 }
41485
41486
41487 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41488 PyObject *resultobj = 0;
41489 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41490 int arg2 ;
41491 bool arg3 ;
41492 void *argp1 = 0 ;
41493 int res1 = 0 ;
41494 int val2 ;
41495 int ecode2 = 0 ;
41496 bool val3 ;
41497 int ecode3 = 0 ;
41498 PyObject * obj0 = 0 ;
41499 PyObject * obj1 = 0 ;
41500 PyObject * obj2 = 0 ;
41501 char * kwnames[] = {
41502 (char *) "self",(char *) "id",(char *) "check", NULL
41503 };
41504
41505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41506 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41507 if (!SWIG_IsOK(res1)) {
41508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41509 }
41510 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41511 ecode2 = SWIG_AsVal_int(obj1, &val2);
41512 if (!SWIG_IsOK(ecode2)) {
41513 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
41514 }
41515 arg2 = static_cast< int >(val2);
41516 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41517 if (!SWIG_IsOK(ecode3)) {
41518 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
41519 }
41520 arg3 = static_cast< bool >(val3);
41521 {
41522 PyThreadState* __tstate = wxPyBeginAllowThreads();
41523 (arg1)->Check(arg2,arg3);
41524 wxPyEndAllowThreads(__tstate);
41525 if (PyErr_Occurred()) SWIG_fail;
41526 }
41527 resultobj = SWIG_Py_Void();
41528 return resultobj;
41529 fail:
41530 return NULL;
41531 }
41532
41533
41534 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41535 PyObject *resultobj = 0;
41536 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41537 int arg2 ;
41538 bool result;
41539 void *argp1 = 0 ;
41540 int res1 = 0 ;
41541 int val2 ;
41542 int ecode2 = 0 ;
41543 PyObject * obj0 = 0 ;
41544 PyObject * obj1 = 0 ;
41545 char * kwnames[] = {
41546 (char *) "self",(char *) "id", NULL
41547 };
41548
41549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
41550 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41551 if (!SWIG_IsOK(res1)) {
41552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41553 }
41554 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41555 ecode2 = SWIG_AsVal_int(obj1, &val2);
41556 if (!SWIG_IsOK(ecode2)) {
41557 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
41558 }
41559 arg2 = static_cast< int >(val2);
41560 {
41561 PyThreadState* __tstate = wxPyBeginAllowThreads();
41562 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
41563 wxPyEndAllowThreads(__tstate);
41564 if (PyErr_Occurred()) SWIG_fail;
41565 }
41566 {
41567 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41568 }
41569 return resultobj;
41570 fail:
41571 return NULL;
41572 }
41573
41574
41575 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41576 PyObject *resultobj = 0;
41577 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41578 int arg2 ;
41579 bool result;
41580 void *argp1 = 0 ;
41581 int res1 = 0 ;
41582 int val2 ;
41583 int ecode2 = 0 ;
41584 PyObject * obj0 = 0 ;
41585 PyObject * obj1 = 0 ;
41586 char * kwnames[] = {
41587 (char *) "self",(char *) "id", NULL
41588 };
41589
41590 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
41591 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41592 if (!SWIG_IsOK(res1)) {
41593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41594 }
41595 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41596 ecode2 = SWIG_AsVal_int(obj1, &val2);
41597 if (!SWIG_IsOK(ecode2)) {
41598 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
41599 }
41600 arg2 = static_cast< int >(val2);
41601 {
41602 PyThreadState* __tstate = wxPyBeginAllowThreads();
41603 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
41604 wxPyEndAllowThreads(__tstate);
41605 if (PyErr_Occurred()) SWIG_fail;
41606 }
41607 {
41608 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41609 }
41610 return resultobj;
41611 fail:
41612 return NULL;
41613 }
41614
41615
41616 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41617 PyObject *resultobj = 0;
41618 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41619 int arg2 ;
41620 wxString *arg3 = 0 ;
41621 void *argp1 = 0 ;
41622 int res1 = 0 ;
41623 int val2 ;
41624 int ecode2 = 0 ;
41625 bool temp3 = false ;
41626 PyObject * obj0 = 0 ;
41627 PyObject * obj1 = 0 ;
41628 PyObject * obj2 = 0 ;
41629 char * kwnames[] = {
41630 (char *) "self",(char *) "id",(char *) "label", NULL
41631 };
41632
41633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41634 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41635 if (!SWIG_IsOK(res1)) {
41636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41637 }
41638 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41639 ecode2 = SWIG_AsVal_int(obj1, &val2);
41640 if (!SWIG_IsOK(ecode2)) {
41641 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
41642 }
41643 arg2 = static_cast< int >(val2);
41644 {
41645 arg3 = wxString_in_helper(obj2);
41646 if (arg3 == NULL) SWIG_fail;
41647 temp3 = true;
41648 }
41649 {
41650 PyThreadState* __tstate = wxPyBeginAllowThreads();
41651 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
41652 wxPyEndAllowThreads(__tstate);
41653 if (PyErr_Occurred()) SWIG_fail;
41654 }
41655 resultobj = SWIG_Py_Void();
41656 {
41657 if (temp3)
41658 delete arg3;
41659 }
41660 return resultobj;
41661 fail:
41662 {
41663 if (temp3)
41664 delete arg3;
41665 }
41666 return NULL;
41667 }
41668
41669
41670 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41671 PyObject *resultobj = 0;
41672 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41673 int arg2 ;
41674 wxString result;
41675 void *argp1 = 0 ;
41676 int res1 = 0 ;
41677 int val2 ;
41678 int ecode2 = 0 ;
41679 PyObject * obj0 = 0 ;
41680 PyObject * obj1 = 0 ;
41681 char * kwnames[] = {
41682 (char *) "self",(char *) "id", NULL
41683 };
41684
41685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41686 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41687 if (!SWIG_IsOK(res1)) {
41688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41689 }
41690 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41691 ecode2 = SWIG_AsVal_int(obj1, &val2);
41692 if (!SWIG_IsOK(ecode2)) {
41693 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
41694 }
41695 arg2 = static_cast< int >(val2);
41696 {
41697 PyThreadState* __tstate = wxPyBeginAllowThreads();
41698 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
41699 wxPyEndAllowThreads(__tstate);
41700 if (PyErr_Occurred()) SWIG_fail;
41701 }
41702 {
41703 #if wxUSE_UNICODE
41704 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41705 #else
41706 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41707 #endif
41708 }
41709 return resultobj;
41710 fail:
41711 return NULL;
41712 }
41713
41714
41715 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41716 PyObject *resultobj = 0;
41717 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41718 int arg2 ;
41719 wxString *arg3 = 0 ;
41720 void *argp1 = 0 ;
41721 int res1 = 0 ;
41722 int val2 ;
41723 int ecode2 = 0 ;
41724 bool temp3 = false ;
41725 PyObject * obj0 = 0 ;
41726 PyObject * obj1 = 0 ;
41727 PyObject * obj2 = 0 ;
41728 char * kwnames[] = {
41729 (char *) "self",(char *) "id",(char *) "helpString", NULL
41730 };
41731
41732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41733 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41734 if (!SWIG_IsOK(res1)) {
41735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41736 }
41737 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41738 ecode2 = SWIG_AsVal_int(obj1, &val2);
41739 if (!SWIG_IsOK(ecode2)) {
41740 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
41741 }
41742 arg2 = static_cast< int >(val2);
41743 {
41744 arg3 = wxString_in_helper(obj2);
41745 if (arg3 == NULL) SWIG_fail;
41746 temp3 = true;
41747 }
41748 {
41749 PyThreadState* __tstate = wxPyBeginAllowThreads();
41750 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
41751 wxPyEndAllowThreads(__tstate);
41752 if (PyErr_Occurred()) SWIG_fail;
41753 }
41754 resultobj = SWIG_Py_Void();
41755 {
41756 if (temp3)
41757 delete arg3;
41758 }
41759 return resultobj;
41760 fail:
41761 {
41762 if (temp3)
41763 delete arg3;
41764 }
41765 return NULL;
41766 }
41767
41768
41769 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41770 PyObject *resultobj = 0;
41771 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41772 int arg2 ;
41773 wxString result;
41774 void *argp1 = 0 ;
41775 int res1 = 0 ;
41776 int val2 ;
41777 int ecode2 = 0 ;
41778 PyObject * obj0 = 0 ;
41779 PyObject * obj1 = 0 ;
41780 char * kwnames[] = {
41781 (char *) "self",(char *) "id", NULL
41782 };
41783
41784 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
41785 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41786 if (!SWIG_IsOK(res1)) {
41787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41788 }
41789 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41790 ecode2 = SWIG_AsVal_int(obj1, &val2);
41791 if (!SWIG_IsOK(ecode2)) {
41792 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
41793 }
41794 arg2 = static_cast< int >(val2);
41795 {
41796 PyThreadState* __tstate = wxPyBeginAllowThreads();
41797 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
41798 wxPyEndAllowThreads(__tstate);
41799 if (PyErr_Occurred()) SWIG_fail;
41800 }
41801 {
41802 #if wxUSE_UNICODE
41803 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41804 #else
41805 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41806 #endif
41807 }
41808 return resultobj;
41809 fail:
41810 return NULL;
41811 }
41812
41813
41814 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41815 PyObject *resultobj = 0;
41816 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41817 wxFrame *result = 0 ;
41818 void *argp1 = 0 ;
41819 int res1 = 0 ;
41820 PyObject *swig_obj[1] ;
41821
41822 if (!args) SWIG_fail;
41823 swig_obj[0] = args;
41824 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41825 if (!SWIG_IsOK(res1)) {
41826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41827 }
41828 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41829 {
41830 PyThreadState* __tstate = wxPyBeginAllowThreads();
41831 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
41832 wxPyEndAllowThreads(__tstate);
41833 if (PyErr_Occurred()) SWIG_fail;
41834 }
41835 {
41836 resultobj = wxPyMake_wxObject(result, (bool)0);
41837 }
41838 return resultobj;
41839 fail:
41840 return NULL;
41841 }
41842
41843
41844 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41845 PyObject *resultobj = 0;
41846 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41847 bool result;
41848 void *argp1 = 0 ;
41849 int res1 = 0 ;
41850 PyObject *swig_obj[1] ;
41851
41852 if (!args) SWIG_fail;
41853 swig_obj[0] = args;
41854 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41855 if (!SWIG_IsOK(res1)) {
41856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41857 }
41858 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41859 {
41860 PyThreadState* __tstate = wxPyBeginAllowThreads();
41861 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
41862 wxPyEndAllowThreads(__tstate);
41863 if (PyErr_Occurred()) SWIG_fail;
41864 }
41865 {
41866 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41867 }
41868 return resultobj;
41869 fail:
41870 return NULL;
41871 }
41872
41873
41874 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41875 PyObject *resultobj = 0;
41876 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41877 wxFrame *arg2 = (wxFrame *) 0 ;
41878 void *argp1 = 0 ;
41879 int res1 = 0 ;
41880 void *argp2 = 0 ;
41881 int res2 = 0 ;
41882 PyObject * obj0 = 0 ;
41883 PyObject * obj1 = 0 ;
41884 char * kwnames[] = {
41885 (char *) "self",(char *) "frame", NULL
41886 };
41887
41888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
41889 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41890 if (!SWIG_IsOK(res1)) {
41891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41892 }
41893 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41894 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
41895 if (!SWIG_IsOK(res2)) {
41896 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
41897 }
41898 arg2 = reinterpret_cast< wxFrame * >(argp2);
41899 {
41900 PyThreadState* __tstate = wxPyBeginAllowThreads();
41901 (arg1)->Attach(arg2);
41902 wxPyEndAllowThreads(__tstate);
41903 if (PyErr_Occurred()) SWIG_fail;
41904 }
41905 resultobj = SWIG_Py_Void();
41906 return resultobj;
41907 fail:
41908 return NULL;
41909 }
41910
41911
41912 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41913 PyObject *resultobj = 0;
41914 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41915 void *argp1 = 0 ;
41916 int res1 = 0 ;
41917 PyObject *swig_obj[1] ;
41918
41919 if (!args) SWIG_fail;
41920 swig_obj[0] = args;
41921 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41922 if (!SWIG_IsOK(res1)) {
41923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41924 }
41925 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41926 {
41927 PyThreadState* __tstate = wxPyBeginAllowThreads();
41928 (arg1)->Detach();
41929 wxPyEndAllowThreads(__tstate);
41930 if (PyErr_Occurred()) SWIG_fail;
41931 }
41932 resultobj = SWIG_Py_Void();
41933 return resultobj;
41934 fail:
41935 return NULL;
41936 }
41937
41938
41939 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41940 PyObject *resultobj = 0;
41941 bool arg1 ;
41942 bool val1 ;
41943 int ecode1 = 0 ;
41944 PyObject * obj0 = 0 ;
41945 char * kwnames[] = {
41946 (char *) "enable", NULL
41947 };
41948
41949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
41950 ecode1 = SWIG_AsVal_bool(obj0, &val1);
41951 if (!SWIG_IsOK(ecode1)) {
41952 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
41953 }
41954 arg1 = static_cast< bool >(val1);
41955 {
41956 PyThreadState* __tstate = wxPyBeginAllowThreads();
41957 wxMenuBar::SetAutoWindowMenu(arg1);
41958 wxPyEndAllowThreads(__tstate);
41959 if (PyErr_Occurred()) SWIG_fail;
41960 }
41961 resultobj = SWIG_Py_Void();
41962 return resultobj;
41963 fail:
41964 return NULL;
41965 }
41966
41967
41968 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41969 PyObject *resultobj = 0;
41970 bool result;
41971
41972 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
41973 {
41974 PyThreadState* __tstate = wxPyBeginAllowThreads();
41975 result = (bool)wxMenuBar::GetAutoWindowMenu();
41976 wxPyEndAllowThreads(__tstate);
41977 if (PyErr_Occurred()) SWIG_fail;
41978 }
41979 {
41980 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41981 }
41982 return resultobj;
41983 fail:
41984 return NULL;
41985 }
41986
41987
41988 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41989 PyObject *obj;
41990 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41991 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
41992 return SWIG_Py_Void();
41993 }
41994
41995 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41996 return SWIG_Python_InitShadowInstance(args);
41997 }
41998
41999 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42000 PyObject *resultobj = 0;
42001 wxMenu *arg1 = (wxMenu *) NULL ;
42002 int arg2 = (int) wxID_ANY ;
42003 wxString const &arg3_defvalue = wxPyEmptyString ;
42004 wxString *arg3 = (wxString *) &arg3_defvalue ;
42005 wxString const &arg4_defvalue = wxPyEmptyString ;
42006 wxString *arg4 = (wxString *) &arg4_defvalue ;
42007 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
42008 wxMenu *arg6 = (wxMenu *) NULL ;
42009 wxMenuItem *result = 0 ;
42010 void *argp1 = 0 ;
42011 int res1 = 0 ;
42012 int val2 ;
42013 int ecode2 = 0 ;
42014 bool temp3 = false ;
42015 bool temp4 = false ;
42016 int val5 ;
42017 int ecode5 = 0 ;
42018 void *argp6 = 0 ;
42019 int res6 = 0 ;
42020 PyObject * obj0 = 0 ;
42021 PyObject * obj1 = 0 ;
42022 PyObject * obj2 = 0 ;
42023 PyObject * obj3 = 0 ;
42024 PyObject * obj4 = 0 ;
42025 PyObject * obj5 = 0 ;
42026 char * kwnames[] = {
42027 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
42028 };
42029
42030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42031 if (obj0) {
42032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42033 if (!SWIG_IsOK(res1)) {
42034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42035 }
42036 arg1 = reinterpret_cast< wxMenu * >(argp1);
42037 }
42038 if (obj1) {
42039 ecode2 = SWIG_AsVal_int(obj1, &val2);
42040 if (!SWIG_IsOK(ecode2)) {
42041 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
42042 }
42043 arg2 = static_cast< int >(val2);
42044 }
42045 if (obj2) {
42046 {
42047 arg3 = wxString_in_helper(obj2);
42048 if (arg3 == NULL) SWIG_fail;
42049 temp3 = true;
42050 }
42051 }
42052 if (obj3) {
42053 {
42054 arg4 = wxString_in_helper(obj3);
42055 if (arg4 == NULL) SWIG_fail;
42056 temp4 = true;
42057 }
42058 }
42059 if (obj4) {
42060 ecode5 = SWIG_AsVal_int(obj4, &val5);
42061 if (!SWIG_IsOK(ecode5)) {
42062 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
42063 }
42064 arg5 = static_cast< wxItemKind >(val5);
42065 }
42066 if (obj5) {
42067 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
42068 if (!SWIG_IsOK(res6)) {
42069 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
42070 }
42071 arg6 = reinterpret_cast< wxMenu * >(argp6);
42072 }
42073 {
42074 PyThreadState* __tstate = wxPyBeginAllowThreads();
42075 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
42076 wxPyEndAllowThreads(__tstate);
42077 if (PyErr_Occurred()) SWIG_fail;
42078 }
42079 {
42080 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
42081 }
42082 {
42083 if (temp3)
42084 delete arg3;
42085 }
42086 {
42087 if (temp4)
42088 delete arg4;
42089 }
42090 return resultobj;
42091 fail:
42092 {
42093 if (temp3)
42094 delete arg3;
42095 }
42096 {
42097 if (temp4)
42098 delete arg4;
42099 }
42100 return NULL;
42101 }
42102
42103
42104 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42105 PyObject *resultobj = 0;
42106 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42107 void *argp1 = 0 ;
42108 int res1 = 0 ;
42109 PyObject *swig_obj[1] ;
42110
42111 if (!args) SWIG_fail;
42112 swig_obj[0] = args;
42113 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42114 if (!SWIG_IsOK(res1)) {
42115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42116 }
42117 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42118 {
42119 PyThreadState* __tstate = wxPyBeginAllowThreads();
42120 delete arg1;
42121
42122 wxPyEndAllowThreads(__tstate);
42123 if (PyErr_Occurred()) SWIG_fail;
42124 }
42125 resultobj = SWIG_Py_Void();
42126 return resultobj;
42127 fail:
42128 return NULL;
42129 }
42130
42131
42132 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42133 PyObject *resultobj = 0;
42134 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42135 wxMenu *result = 0 ;
42136 void *argp1 = 0 ;
42137 int res1 = 0 ;
42138 PyObject *swig_obj[1] ;
42139
42140 if (!args) SWIG_fail;
42141 swig_obj[0] = args;
42142 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42143 if (!SWIG_IsOK(res1)) {
42144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42145 }
42146 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42147 {
42148 PyThreadState* __tstate = wxPyBeginAllowThreads();
42149 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
42150 wxPyEndAllowThreads(__tstate);
42151 if (PyErr_Occurred()) SWIG_fail;
42152 }
42153 {
42154 resultobj = wxPyMake_wxObject(result, 0);
42155 }
42156 return resultobj;
42157 fail:
42158 return NULL;
42159 }
42160
42161
42162 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42163 PyObject *resultobj = 0;
42164 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42165 wxMenu *arg2 = (wxMenu *) 0 ;
42166 void *argp1 = 0 ;
42167 int res1 = 0 ;
42168 void *argp2 = 0 ;
42169 int res2 = 0 ;
42170 PyObject * obj0 = 0 ;
42171 PyObject * obj1 = 0 ;
42172 char * kwnames[] = {
42173 (char *) "self",(char *) "menu", NULL
42174 };
42175
42176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42177 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42178 if (!SWIG_IsOK(res1)) {
42179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42180 }
42181 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42182 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42183 if (!SWIG_IsOK(res2)) {
42184 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42185 }
42186 arg2 = reinterpret_cast< wxMenu * >(argp2);
42187 {
42188 PyThreadState* __tstate = wxPyBeginAllowThreads();
42189 (arg1)->SetMenu(arg2);
42190 wxPyEndAllowThreads(__tstate);
42191 if (PyErr_Occurred()) SWIG_fail;
42192 }
42193 resultobj = SWIG_Py_Void();
42194 return resultobj;
42195 fail:
42196 return NULL;
42197 }
42198
42199
42200 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42201 PyObject *resultobj = 0;
42202 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42203 int arg2 ;
42204 void *argp1 = 0 ;
42205 int res1 = 0 ;
42206 int val2 ;
42207 int ecode2 = 0 ;
42208 PyObject * obj0 = 0 ;
42209 PyObject * obj1 = 0 ;
42210 char * kwnames[] = {
42211 (char *) "self",(char *) "id", NULL
42212 };
42213
42214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
42215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42216 if (!SWIG_IsOK(res1)) {
42217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42218 }
42219 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42220 ecode2 = SWIG_AsVal_int(obj1, &val2);
42221 if (!SWIG_IsOK(ecode2)) {
42222 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
42223 }
42224 arg2 = static_cast< int >(val2);
42225 {
42226 PyThreadState* __tstate = wxPyBeginAllowThreads();
42227 (arg1)->SetId(arg2);
42228 wxPyEndAllowThreads(__tstate);
42229 if (PyErr_Occurred()) SWIG_fail;
42230 }
42231 resultobj = SWIG_Py_Void();
42232 return resultobj;
42233 fail:
42234 return NULL;
42235 }
42236
42237
42238 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42239 PyObject *resultobj = 0;
42240 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42241 int result;
42242 void *argp1 = 0 ;
42243 int res1 = 0 ;
42244 PyObject *swig_obj[1] ;
42245
42246 if (!args) SWIG_fail;
42247 swig_obj[0] = args;
42248 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42249 if (!SWIG_IsOK(res1)) {
42250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42251 }
42252 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42253 {
42254 PyThreadState* __tstate = wxPyBeginAllowThreads();
42255 result = (int)((wxMenuItem const *)arg1)->GetId();
42256 wxPyEndAllowThreads(__tstate);
42257 if (PyErr_Occurred()) SWIG_fail;
42258 }
42259 resultobj = SWIG_From_int(static_cast< int >(result));
42260 return resultobj;
42261 fail:
42262 return NULL;
42263 }
42264
42265
42266 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42267 PyObject *resultobj = 0;
42268 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42269 bool result;
42270 void *argp1 = 0 ;
42271 int res1 = 0 ;
42272 PyObject *swig_obj[1] ;
42273
42274 if (!args) SWIG_fail;
42275 swig_obj[0] = args;
42276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42277 if (!SWIG_IsOK(res1)) {
42278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42279 }
42280 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42281 {
42282 PyThreadState* __tstate = wxPyBeginAllowThreads();
42283 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
42284 wxPyEndAllowThreads(__tstate);
42285 if (PyErr_Occurred()) SWIG_fail;
42286 }
42287 {
42288 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42289 }
42290 return resultobj;
42291 fail:
42292 return NULL;
42293 }
42294
42295
42296 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42297 PyObject *resultobj = 0;
42298 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42299 wxString *arg2 = 0 ;
42300 void *argp1 = 0 ;
42301 int res1 = 0 ;
42302 bool temp2 = false ;
42303 PyObject * obj0 = 0 ;
42304 PyObject * obj1 = 0 ;
42305 char * kwnames[] = {
42306 (char *) "self",(char *) "str", NULL
42307 };
42308
42309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
42310 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42311 if (!SWIG_IsOK(res1)) {
42312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42313 }
42314 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42315 {
42316 arg2 = wxString_in_helper(obj1);
42317 if (arg2 == NULL) SWIG_fail;
42318 temp2 = true;
42319 }
42320 {
42321 PyThreadState* __tstate = wxPyBeginAllowThreads();
42322 (arg1)->SetText((wxString const &)*arg2);
42323 wxPyEndAllowThreads(__tstate);
42324 if (PyErr_Occurred()) SWIG_fail;
42325 }
42326 resultobj = SWIG_Py_Void();
42327 {
42328 if (temp2)
42329 delete arg2;
42330 }
42331 return resultobj;
42332 fail:
42333 {
42334 if (temp2)
42335 delete arg2;
42336 }
42337 return NULL;
42338 }
42339
42340
42341 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42342 PyObject *resultobj = 0;
42343 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42344 wxString result;
42345 void *argp1 = 0 ;
42346 int res1 = 0 ;
42347 PyObject *swig_obj[1] ;
42348
42349 if (!args) SWIG_fail;
42350 swig_obj[0] = args;
42351 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42352 if (!SWIG_IsOK(res1)) {
42353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42354 }
42355 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42356 {
42357 PyThreadState* __tstate = wxPyBeginAllowThreads();
42358 result = ((wxMenuItem const *)arg1)->GetLabel();
42359 wxPyEndAllowThreads(__tstate);
42360 if (PyErr_Occurred()) SWIG_fail;
42361 }
42362 {
42363 #if wxUSE_UNICODE
42364 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42365 #else
42366 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42367 #endif
42368 }
42369 return resultobj;
42370 fail:
42371 return NULL;
42372 }
42373
42374
42375 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42376 PyObject *resultobj = 0;
42377 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42378 wxString *result = 0 ;
42379 void *argp1 = 0 ;
42380 int res1 = 0 ;
42381 PyObject *swig_obj[1] ;
42382
42383 if (!args) SWIG_fail;
42384 swig_obj[0] = args;
42385 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42386 if (!SWIG_IsOK(res1)) {
42387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42388 }
42389 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42390 {
42391 PyThreadState* __tstate = wxPyBeginAllowThreads();
42392 {
42393 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
42394 result = (wxString *) &_result_ref;
42395 }
42396 wxPyEndAllowThreads(__tstate);
42397 if (PyErr_Occurred()) SWIG_fail;
42398 }
42399 {
42400 #if wxUSE_UNICODE
42401 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
42402 #else
42403 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
42404 #endif
42405 }
42406 return resultobj;
42407 fail:
42408 return NULL;
42409 }
42410
42411
42412 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42413 PyObject *resultobj = 0;
42414 wxString *arg1 = 0 ;
42415 wxString result;
42416 bool temp1 = false ;
42417 PyObject * obj0 = 0 ;
42418 char * kwnames[] = {
42419 (char *) "text", NULL
42420 };
42421
42422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
42423 {
42424 arg1 = wxString_in_helper(obj0);
42425 if (arg1 == NULL) SWIG_fail;
42426 temp1 = true;
42427 }
42428 {
42429 PyThreadState* __tstate = wxPyBeginAllowThreads();
42430 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
42431 wxPyEndAllowThreads(__tstate);
42432 if (PyErr_Occurred()) SWIG_fail;
42433 }
42434 {
42435 #if wxUSE_UNICODE
42436 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42437 #else
42438 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42439 #endif
42440 }
42441 {
42442 if (temp1)
42443 delete arg1;
42444 }
42445 return resultobj;
42446 fail:
42447 {
42448 if (temp1)
42449 delete arg1;
42450 }
42451 return NULL;
42452 }
42453
42454
42455 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42456 PyObject *resultobj = 0;
42457 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42458 wxItemKind result;
42459 void *argp1 = 0 ;
42460 int res1 = 0 ;
42461 PyObject *swig_obj[1] ;
42462
42463 if (!args) SWIG_fail;
42464 swig_obj[0] = args;
42465 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42466 if (!SWIG_IsOK(res1)) {
42467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42468 }
42469 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42470 {
42471 PyThreadState* __tstate = wxPyBeginAllowThreads();
42472 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
42473 wxPyEndAllowThreads(__tstate);
42474 if (PyErr_Occurred()) SWIG_fail;
42475 }
42476 resultobj = SWIG_From_int(static_cast< int >(result));
42477 return resultobj;
42478 fail:
42479 return NULL;
42480 }
42481
42482
42483 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42484 PyObject *resultobj = 0;
42485 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42486 wxItemKind arg2 ;
42487 void *argp1 = 0 ;
42488 int res1 = 0 ;
42489 int val2 ;
42490 int ecode2 = 0 ;
42491 PyObject * obj0 = 0 ;
42492 PyObject * obj1 = 0 ;
42493 char * kwnames[] = {
42494 (char *) "self",(char *) "kind", NULL
42495 };
42496
42497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
42498 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42499 if (!SWIG_IsOK(res1)) {
42500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42501 }
42502 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42503 ecode2 = SWIG_AsVal_int(obj1, &val2);
42504 if (!SWIG_IsOK(ecode2)) {
42505 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
42506 }
42507 arg2 = static_cast< wxItemKind >(val2);
42508 {
42509 PyThreadState* __tstate = wxPyBeginAllowThreads();
42510 (arg1)->SetKind(arg2);
42511 wxPyEndAllowThreads(__tstate);
42512 if (PyErr_Occurred()) SWIG_fail;
42513 }
42514 resultobj = SWIG_Py_Void();
42515 return resultobj;
42516 fail:
42517 return NULL;
42518 }
42519
42520
42521 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42522 PyObject *resultobj = 0;
42523 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42524 bool arg2 ;
42525 void *argp1 = 0 ;
42526 int res1 = 0 ;
42527 bool val2 ;
42528 int ecode2 = 0 ;
42529 PyObject * obj0 = 0 ;
42530 PyObject * obj1 = 0 ;
42531 char * kwnames[] = {
42532 (char *) "self",(char *) "checkable", NULL
42533 };
42534
42535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
42536 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42537 if (!SWIG_IsOK(res1)) {
42538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42539 }
42540 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42541 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42542 if (!SWIG_IsOK(ecode2)) {
42543 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
42544 }
42545 arg2 = static_cast< bool >(val2);
42546 {
42547 PyThreadState* __tstate = wxPyBeginAllowThreads();
42548 (arg1)->SetCheckable(arg2);
42549 wxPyEndAllowThreads(__tstate);
42550 if (PyErr_Occurred()) SWIG_fail;
42551 }
42552 resultobj = SWIG_Py_Void();
42553 return resultobj;
42554 fail:
42555 return NULL;
42556 }
42557
42558
42559 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42560 PyObject *resultobj = 0;
42561 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42562 bool result;
42563 void *argp1 = 0 ;
42564 int res1 = 0 ;
42565 PyObject *swig_obj[1] ;
42566
42567 if (!args) SWIG_fail;
42568 swig_obj[0] = args;
42569 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42570 if (!SWIG_IsOK(res1)) {
42571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42572 }
42573 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42574 {
42575 PyThreadState* __tstate = wxPyBeginAllowThreads();
42576 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
42577 wxPyEndAllowThreads(__tstate);
42578 if (PyErr_Occurred()) SWIG_fail;
42579 }
42580 {
42581 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42582 }
42583 return resultobj;
42584 fail:
42585 return NULL;
42586 }
42587
42588
42589 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42590 PyObject *resultobj = 0;
42591 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42592 bool result;
42593 void *argp1 = 0 ;
42594 int res1 = 0 ;
42595 PyObject *swig_obj[1] ;
42596
42597 if (!args) SWIG_fail;
42598 swig_obj[0] = args;
42599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42600 if (!SWIG_IsOK(res1)) {
42601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42602 }
42603 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42604 {
42605 PyThreadState* __tstate = wxPyBeginAllowThreads();
42606 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
42607 wxPyEndAllowThreads(__tstate);
42608 if (PyErr_Occurred()) SWIG_fail;
42609 }
42610 {
42611 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42612 }
42613 return resultobj;
42614 fail:
42615 return NULL;
42616 }
42617
42618
42619 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42620 PyObject *resultobj = 0;
42621 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42622 wxMenu *arg2 = (wxMenu *) 0 ;
42623 void *argp1 = 0 ;
42624 int res1 = 0 ;
42625 void *argp2 = 0 ;
42626 int res2 = 0 ;
42627 PyObject * obj0 = 0 ;
42628 PyObject * obj1 = 0 ;
42629 char * kwnames[] = {
42630 (char *) "self",(char *) "menu", NULL
42631 };
42632
42633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42634 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42635 if (!SWIG_IsOK(res1)) {
42636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42637 }
42638 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42639 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42640 if (!SWIG_IsOK(res2)) {
42641 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42642 }
42643 arg2 = reinterpret_cast< wxMenu * >(argp2);
42644 {
42645 PyThreadState* __tstate = wxPyBeginAllowThreads();
42646 (arg1)->SetSubMenu(arg2);
42647 wxPyEndAllowThreads(__tstate);
42648 if (PyErr_Occurred()) SWIG_fail;
42649 }
42650 resultobj = SWIG_Py_Void();
42651 return resultobj;
42652 fail:
42653 return NULL;
42654 }
42655
42656
42657 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42658 PyObject *resultobj = 0;
42659 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42660 wxMenu *result = 0 ;
42661 void *argp1 = 0 ;
42662 int res1 = 0 ;
42663 PyObject *swig_obj[1] ;
42664
42665 if (!args) SWIG_fail;
42666 swig_obj[0] = args;
42667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42668 if (!SWIG_IsOK(res1)) {
42669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42670 }
42671 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42672 {
42673 PyThreadState* __tstate = wxPyBeginAllowThreads();
42674 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
42675 wxPyEndAllowThreads(__tstate);
42676 if (PyErr_Occurred()) SWIG_fail;
42677 }
42678 {
42679 resultobj = wxPyMake_wxObject(result, 0);
42680 }
42681 return resultobj;
42682 fail:
42683 return NULL;
42684 }
42685
42686
42687 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42688 PyObject *resultobj = 0;
42689 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42690 bool arg2 = (bool) true ;
42691 void *argp1 = 0 ;
42692 int res1 = 0 ;
42693 bool val2 ;
42694 int ecode2 = 0 ;
42695 PyObject * obj0 = 0 ;
42696 PyObject * obj1 = 0 ;
42697 char * kwnames[] = {
42698 (char *) "self",(char *) "enable", NULL
42699 };
42700
42701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
42702 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42703 if (!SWIG_IsOK(res1)) {
42704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42705 }
42706 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42707 if (obj1) {
42708 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42709 if (!SWIG_IsOK(ecode2)) {
42710 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
42711 }
42712 arg2 = static_cast< bool >(val2);
42713 }
42714 {
42715 PyThreadState* __tstate = wxPyBeginAllowThreads();
42716 (arg1)->Enable(arg2);
42717 wxPyEndAllowThreads(__tstate);
42718 if (PyErr_Occurred()) SWIG_fail;
42719 }
42720 resultobj = SWIG_Py_Void();
42721 return resultobj;
42722 fail:
42723 return NULL;
42724 }
42725
42726
42727 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42728 PyObject *resultobj = 0;
42729 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42730 bool result;
42731 void *argp1 = 0 ;
42732 int res1 = 0 ;
42733 PyObject *swig_obj[1] ;
42734
42735 if (!args) SWIG_fail;
42736 swig_obj[0] = args;
42737 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42738 if (!SWIG_IsOK(res1)) {
42739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42740 }
42741 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42742 {
42743 PyThreadState* __tstate = wxPyBeginAllowThreads();
42744 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
42745 wxPyEndAllowThreads(__tstate);
42746 if (PyErr_Occurred()) SWIG_fail;
42747 }
42748 {
42749 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42750 }
42751 return resultobj;
42752 fail:
42753 return NULL;
42754 }
42755
42756
42757 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42758 PyObject *resultobj = 0;
42759 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42760 bool arg2 = (bool) true ;
42761 void *argp1 = 0 ;
42762 int res1 = 0 ;
42763 bool val2 ;
42764 int ecode2 = 0 ;
42765 PyObject * obj0 = 0 ;
42766 PyObject * obj1 = 0 ;
42767 char * kwnames[] = {
42768 (char *) "self",(char *) "check", NULL
42769 };
42770
42771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
42772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42773 if (!SWIG_IsOK(res1)) {
42774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42775 }
42776 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42777 if (obj1) {
42778 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42779 if (!SWIG_IsOK(ecode2)) {
42780 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
42781 }
42782 arg2 = static_cast< bool >(val2);
42783 }
42784 {
42785 PyThreadState* __tstate = wxPyBeginAllowThreads();
42786 (arg1)->Check(arg2);
42787 wxPyEndAllowThreads(__tstate);
42788 if (PyErr_Occurred()) SWIG_fail;
42789 }
42790 resultobj = SWIG_Py_Void();
42791 return resultobj;
42792 fail:
42793 return NULL;
42794 }
42795
42796
42797 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42798 PyObject *resultobj = 0;
42799 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42800 bool result;
42801 void *argp1 = 0 ;
42802 int res1 = 0 ;
42803 PyObject *swig_obj[1] ;
42804
42805 if (!args) SWIG_fail;
42806 swig_obj[0] = args;
42807 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42808 if (!SWIG_IsOK(res1)) {
42809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42810 }
42811 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42812 {
42813 PyThreadState* __tstate = wxPyBeginAllowThreads();
42814 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
42815 wxPyEndAllowThreads(__tstate);
42816 if (PyErr_Occurred()) SWIG_fail;
42817 }
42818 {
42819 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42820 }
42821 return resultobj;
42822 fail:
42823 return NULL;
42824 }
42825
42826
42827 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42828 PyObject *resultobj = 0;
42829 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42830 void *argp1 = 0 ;
42831 int res1 = 0 ;
42832 PyObject *swig_obj[1] ;
42833
42834 if (!args) SWIG_fail;
42835 swig_obj[0] = args;
42836 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42837 if (!SWIG_IsOK(res1)) {
42838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42839 }
42840 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42841 {
42842 PyThreadState* __tstate = wxPyBeginAllowThreads();
42843 (arg1)->Toggle();
42844 wxPyEndAllowThreads(__tstate);
42845 if (PyErr_Occurred()) SWIG_fail;
42846 }
42847 resultobj = SWIG_Py_Void();
42848 return resultobj;
42849 fail:
42850 return NULL;
42851 }
42852
42853
42854 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42855 PyObject *resultobj = 0;
42856 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42857 wxString *arg2 = 0 ;
42858 void *argp1 = 0 ;
42859 int res1 = 0 ;
42860 bool temp2 = false ;
42861 PyObject * obj0 = 0 ;
42862 PyObject * obj1 = 0 ;
42863 char * kwnames[] = {
42864 (char *) "self",(char *) "str", NULL
42865 };
42866
42867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
42868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42869 if (!SWIG_IsOK(res1)) {
42870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42871 }
42872 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42873 {
42874 arg2 = wxString_in_helper(obj1);
42875 if (arg2 == NULL) SWIG_fail;
42876 temp2 = true;
42877 }
42878 {
42879 PyThreadState* __tstate = wxPyBeginAllowThreads();
42880 (arg1)->SetHelp((wxString const &)*arg2);
42881 wxPyEndAllowThreads(__tstate);
42882 if (PyErr_Occurred()) SWIG_fail;
42883 }
42884 resultobj = SWIG_Py_Void();
42885 {
42886 if (temp2)
42887 delete arg2;
42888 }
42889 return resultobj;
42890 fail:
42891 {
42892 if (temp2)
42893 delete arg2;
42894 }
42895 return NULL;
42896 }
42897
42898
42899 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42900 PyObject *resultobj = 0;
42901 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42902 wxString *result = 0 ;
42903 void *argp1 = 0 ;
42904 int res1 = 0 ;
42905 PyObject *swig_obj[1] ;
42906
42907 if (!args) SWIG_fail;
42908 swig_obj[0] = args;
42909 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42910 if (!SWIG_IsOK(res1)) {
42911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42912 }
42913 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42914 {
42915 PyThreadState* __tstate = wxPyBeginAllowThreads();
42916 {
42917 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
42918 result = (wxString *) &_result_ref;
42919 }
42920 wxPyEndAllowThreads(__tstate);
42921 if (PyErr_Occurred()) SWIG_fail;
42922 }
42923 {
42924 #if wxUSE_UNICODE
42925 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
42926 #else
42927 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
42928 #endif
42929 }
42930 return resultobj;
42931 fail:
42932 return NULL;
42933 }
42934
42935
42936 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42937 PyObject *resultobj = 0;
42938 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42939 wxAcceleratorEntry *result = 0 ;
42940 void *argp1 = 0 ;
42941 int res1 = 0 ;
42942 PyObject *swig_obj[1] ;
42943
42944 if (!args) SWIG_fail;
42945 swig_obj[0] = args;
42946 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42947 if (!SWIG_IsOK(res1)) {
42948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42949 }
42950 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42951 {
42952 PyThreadState* __tstate = wxPyBeginAllowThreads();
42953 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
42954 wxPyEndAllowThreads(__tstate);
42955 if (PyErr_Occurred()) SWIG_fail;
42956 }
42957 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
42958 return resultobj;
42959 fail:
42960 return NULL;
42961 }
42962
42963
42964 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42965 PyObject *resultobj = 0;
42966 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42967 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
42968 void *argp1 = 0 ;
42969 int res1 = 0 ;
42970 void *argp2 = 0 ;
42971 int res2 = 0 ;
42972 PyObject * obj0 = 0 ;
42973 PyObject * obj1 = 0 ;
42974 char * kwnames[] = {
42975 (char *) "self",(char *) "accel", NULL
42976 };
42977
42978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
42979 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42980 if (!SWIG_IsOK(res1)) {
42981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42982 }
42983 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42984 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
42985 if (!SWIG_IsOK(res2)) {
42986 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
42987 }
42988 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
42989 {
42990 PyThreadState* __tstate = wxPyBeginAllowThreads();
42991 (arg1)->SetAccel(arg2);
42992 wxPyEndAllowThreads(__tstate);
42993 if (PyErr_Occurred()) SWIG_fail;
42994 }
42995 resultobj = SWIG_Py_Void();
42996 return resultobj;
42997 fail:
42998 return NULL;
42999 }
43000
43001
43002 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43003 PyObject *resultobj = 0;
43004 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43005 wxBitmap *arg2 = 0 ;
43006 void *argp1 = 0 ;
43007 int res1 = 0 ;
43008 void *argp2 = 0 ;
43009 int res2 = 0 ;
43010 PyObject * obj0 = 0 ;
43011 PyObject * obj1 = 0 ;
43012 char * kwnames[] = {
43013 (char *) "self",(char *) "bitmap", NULL
43014 };
43015
43016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43017 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43018 if (!SWIG_IsOK(res1)) {
43019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43020 }
43021 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43022 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43023 if (!SWIG_IsOK(res2)) {
43024 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43025 }
43026 if (!argp2) {
43027 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43028 }
43029 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43030 {
43031 PyThreadState* __tstate = wxPyBeginAllowThreads();
43032 (arg1)->SetBitmap((wxBitmap const &)*arg2);
43033 wxPyEndAllowThreads(__tstate);
43034 if (PyErr_Occurred()) SWIG_fail;
43035 }
43036 resultobj = SWIG_Py_Void();
43037 return resultobj;
43038 fail:
43039 return NULL;
43040 }
43041
43042
43043 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43044 PyObject *resultobj = 0;
43045 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43046 wxBitmap *result = 0 ;
43047 void *argp1 = 0 ;
43048 int res1 = 0 ;
43049 PyObject *swig_obj[1] ;
43050
43051 if (!args) SWIG_fail;
43052 swig_obj[0] = args;
43053 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43054 if (!SWIG_IsOK(res1)) {
43055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43056 }
43057 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43058 {
43059 PyThreadState* __tstate = wxPyBeginAllowThreads();
43060 {
43061 wxBitmap const &_result_ref = (arg1)->GetBitmap();
43062 result = (wxBitmap *) &_result_ref;
43063 }
43064 wxPyEndAllowThreads(__tstate);
43065 if (PyErr_Occurred()) SWIG_fail;
43066 }
43067 {
43068 wxBitmap* resultptr = new wxBitmap(*result);
43069 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43070 }
43071 return resultobj;
43072 fail:
43073 return NULL;
43074 }
43075
43076
43077 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43078 PyObject *resultobj = 0;
43079 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43080 wxFont *arg2 = 0 ;
43081 void *argp1 = 0 ;
43082 int res1 = 0 ;
43083 void *argp2 = 0 ;
43084 int res2 = 0 ;
43085 PyObject * obj0 = 0 ;
43086 PyObject * obj1 = 0 ;
43087 char * kwnames[] = {
43088 (char *) "self",(char *) "font", NULL
43089 };
43090
43091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
43092 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43093 if (!SWIG_IsOK(res1)) {
43094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43095 }
43096 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43097 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
43098 if (!SWIG_IsOK(res2)) {
43099 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
43100 }
43101 if (!argp2) {
43102 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
43103 }
43104 arg2 = reinterpret_cast< wxFont * >(argp2);
43105 {
43106 PyThreadState* __tstate = wxPyBeginAllowThreads();
43107 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
43108 wxPyEndAllowThreads(__tstate);
43109 if (PyErr_Occurred()) SWIG_fail;
43110 }
43111 resultobj = SWIG_Py_Void();
43112 return resultobj;
43113 fail:
43114 return NULL;
43115 }
43116
43117
43118 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43119 PyObject *resultobj = 0;
43120 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43121 wxFont result;
43122 void *argp1 = 0 ;
43123 int res1 = 0 ;
43124 PyObject *swig_obj[1] ;
43125
43126 if (!args) SWIG_fail;
43127 swig_obj[0] = args;
43128 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43129 if (!SWIG_IsOK(res1)) {
43130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43131 }
43132 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43133 {
43134 PyThreadState* __tstate = wxPyBeginAllowThreads();
43135 result = wxMenuItem_GetFont(arg1);
43136 wxPyEndAllowThreads(__tstate);
43137 if (PyErr_Occurred()) SWIG_fail;
43138 }
43139 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
43140 return resultobj;
43141 fail:
43142 return NULL;
43143 }
43144
43145
43146 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43147 PyObject *resultobj = 0;
43148 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43149 wxColour *arg2 = 0 ;
43150 void *argp1 = 0 ;
43151 int res1 = 0 ;
43152 wxColour temp2 ;
43153 PyObject * obj0 = 0 ;
43154 PyObject * obj1 = 0 ;
43155 char * kwnames[] = {
43156 (char *) "self",(char *) "colText", NULL
43157 };
43158
43159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
43160 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43161 if (!SWIG_IsOK(res1)) {
43162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43163 }
43164 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43165 {
43166 arg2 = &temp2;
43167 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43168 }
43169 {
43170 PyThreadState* __tstate = wxPyBeginAllowThreads();
43171 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
43172 wxPyEndAllowThreads(__tstate);
43173 if (PyErr_Occurred()) SWIG_fail;
43174 }
43175 resultobj = SWIG_Py_Void();
43176 return resultobj;
43177 fail:
43178 return NULL;
43179 }
43180
43181
43182 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43183 PyObject *resultobj = 0;
43184 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43185 wxColour result;
43186 void *argp1 = 0 ;
43187 int res1 = 0 ;
43188 PyObject *swig_obj[1] ;
43189
43190 if (!args) SWIG_fail;
43191 swig_obj[0] = args;
43192 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43193 if (!SWIG_IsOK(res1)) {
43194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43195 }
43196 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43197 {
43198 PyThreadState* __tstate = wxPyBeginAllowThreads();
43199 result = wxMenuItem_GetTextColour(arg1);
43200 wxPyEndAllowThreads(__tstate);
43201 if (PyErr_Occurred()) SWIG_fail;
43202 }
43203 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43204 return resultobj;
43205 fail:
43206 return NULL;
43207 }
43208
43209
43210 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43211 PyObject *resultobj = 0;
43212 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43213 wxColour *arg2 = 0 ;
43214 void *argp1 = 0 ;
43215 int res1 = 0 ;
43216 wxColour temp2 ;
43217 PyObject * obj0 = 0 ;
43218 PyObject * obj1 = 0 ;
43219 char * kwnames[] = {
43220 (char *) "self",(char *) "colBack", NULL
43221 };
43222
43223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
43224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43225 if (!SWIG_IsOK(res1)) {
43226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43227 }
43228 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43229 {
43230 arg2 = &temp2;
43231 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43232 }
43233 {
43234 PyThreadState* __tstate = wxPyBeginAllowThreads();
43235 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
43236 wxPyEndAllowThreads(__tstate);
43237 if (PyErr_Occurred()) SWIG_fail;
43238 }
43239 resultobj = SWIG_Py_Void();
43240 return resultobj;
43241 fail:
43242 return NULL;
43243 }
43244
43245
43246 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43247 PyObject *resultobj = 0;
43248 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43249 wxColour result;
43250 void *argp1 = 0 ;
43251 int res1 = 0 ;
43252 PyObject *swig_obj[1] ;
43253
43254 if (!args) SWIG_fail;
43255 swig_obj[0] = args;
43256 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43257 if (!SWIG_IsOK(res1)) {
43258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43259 }
43260 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43261 {
43262 PyThreadState* __tstate = wxPyBeginAllowThreads();
43263 result = wxMenuItem_GetBackgroundColour(arg1);
43264 wxPyEndAllowThreads(__tstate);
43265 if (PyErr_Occurred()) SWIG_fail;
43266 }
43267 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43268 return resultobj;
43269 fail:
43270 return NULL;
43271 }
43272
43273
43274 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43275 PyObject *resultobj = 0;
43276 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43277 wxBitmap *arg2 = 0 ;
43278 wxBitmap const &arg3_defvalue = wxNullBitmap ;
43279 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
43280 void *argp1 = 0 ;
43281 int res1 = 0 ;
43282 void *argp2 = 0 ;
43283 int res2 = 0 ;
43284 void *argp3 = 0 ;
43285 int res3 = 0 ;
43286 PyObject * obj0 = 0 ;
43287 PyObject * obj1 = 0 ;
43288 PyObject * obj2 = 0 ;
43289 char * kwnames[] = {
43290 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
43291 };
43292
43293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43294 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43295 if (!SWIG_IsOK(res1)) {
43296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43297 }
43298 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43299 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43300 if (!SWIG_IsOK(res2)) {
43301 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43302 }
43303 if (!argp2) {
43304 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43305 }
43306 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43307 if (obj2) {
43308 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
43309 if (!SWIG_IsOK(res3)) {
43310 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43311 }
43312 if (!argp3) {
43313 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43314 }
43315 arg3 = reinterpret_cast< wxBitmap * >(argp3);
43316 }
43317 {
43318 PyThreadState* __tstate = wxPyBeginAllowThreads();
43319 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
43320 wxPyEndAllowThreads(__tstate);
43321 if (PyErr_Occurred()) SWIG_fail;
43322 }
43323 resultobj = SWIG_Py_Void();
43324 return resultobj;
43325 fail:
43326 return NULL;
43327 }
43328
43329
43330 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43331 PyObject *resultobj = 0;
43332 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43333 wxBitmap *arg2 = 0 ;
43334 void *argp1 = 0 ;
43335 int res1 = 0 ;
43336 void *argp2 = 0 ;
43337 int res2 = 0 ;
43338 PyObject * obj0 = 0 ;
43339 PyObject * obj1 = 0 ;
43340 char * kwnames[] = {
43341 (char *) "self",(char *) "bmpDisabled", NULL
43342 };
43343
43344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43345 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43346 if (!SWIG_IsOK(res1)) {
43347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43348 }
43349 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43350 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43351 if (!SWIG_IsOK(res2)) {
43352 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43353 }
43354 if (!argp2) {
43355 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43356 }
43357 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43358 {
43359 PyThreadState* __tstate = wxPyBeginAllowThreads();
43360 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
43361 wxPyEndAllowThreads(__tstate);
43362 if (PyErr_Occurred()) SWIG_fail;
43363 }
43364 resultobj = SWIG_Py_Void();
43365 return resultobj;
43366 fail:
43367 return NULL;
43368 }
43369
43370
43371 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43372 PyObject *resultobj = 0;
43373 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43374 wxBitmap *result = 0 ;
43375 void *argp1 = 0 ;
43376 int res1 = 0 ;
43377 PyObject *swig_obj[1] ;
43378
43379 if (!args) SWIG_fail;
43380 swig_obj[0] = args;
43381 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43382 if (!SWIG_IsOK(res1)) {
43383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43384 }
43385 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43386 {
43387 PyThreadState* __tstate = wxPyBeginAllowThreads();
43388 {
43389 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
43390 result = (wxBitmap *) &_result_ref;
43391 }
43392 wxPyEndAllowThreads(__tstate);
43393 if (PyErr_Occurred()) SWIG_fail;
43394 }
43395 {
43396 wxBitmap* resultptr = new wxBitmap(*result);
43397 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43398 }
43399 return resultobj;
43400 fail:
43401 return NULL;
43402 }
43403
43404
43405 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43406 PyObject *resultobj = 0;
43407 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43408 int arg2 ;
43409 void *argp1 = 0 ;
43410 int res1 = 0 ;
43411 int val2 ;
43412 int ecode2 = 0 ;
43413 PyObject * obj0 = 0 ;
43414 PyObject * obj1 = 0 ;
43415 char * kwnames[] = {
43416 (char *) "self",(char *) "nWidth", NULL
43417 };
43418
43419 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
43420 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43421 if (!SWIG_IsOK(res1)) {
43422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43423 }
43424 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43425 ecode2 = SWIG_AsVal_int(obj1, &val2);
43426 if (!SWIG_IsOK(ecode2)) {
43427 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
43428 }
43429 arg2 = static_cast< int >(val2);
43430 {
43431 PyThreadState* __tstate = wxPyBeginAllowThreads();
43432 wxMenuItem_SetMarginWidth(arg1,arg2);
43433 wxPyEndAllowThreads(__tstate);
43434 if (PyErr_Occurred()) SWIG_fail;
43435 }
43436 resultobj = SWIG_Py_Void();
43437 return resultobj;
43438 fail:
43439 return NULL;
43440 }
43441
43442
43443 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43444 PyObject *resultobj = 0;
43445 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43446 int result;
43447 void *argp1 = 0 ;
43448 int res1 = 0 ;
43449 PyObject *swig_obj[1] ;
43450
43451 if (!args) SWIG_fail;
43452 swig_obj[0] = args;
43453 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43454 if (!SWIG_IsOK(res1)) {
43455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43456 }
43457 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43458 {
43459 PyThreadState* __tstate = wxPyBeginAllowThreads();
43460 result = (int)wxMenuItem_GetMarginWidth(arg1);
43461 wxPyEndAllowThreads(__tstate);
43462 if (PyErr_Occurred()) SWIG_fail;
43463 }
43464 resultobj = SWIG_From_int(static_cast< int >(result));
43465 return resultobj;
43466 fail:
43467 return NULL;
43468 }
43469
43470
43471 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43472 PyObject *resultobj = 0;
43473 int result;
43474
43475 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
43476 {
43477 PyThreadState* __tstate = wxPyBeginAllowThreads();
43478 result = (int)wxMenuItem_GetDefaultMarginWidth();
43479 wxPyEndAllowThreads(__tstate);
43480 if (PyErr_Occurred()) SWIG_fail;
43481 }
43482 resultobj = SWIG_From_int(static_cast< int >(result));
43483 return resultobj;
43484 fail:
43485 return NULL;
43486 }
43487
43488
43489 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43490 PyObject *resultobj = 0;
43491 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43492 bool result;
43493 void *argp1 = 0 ;
43494 int res1 = 0 ;
43495 PyObject *swig_obj[1] ;
43496
43497 if (!args) SWIG_fail;
43498 swig_obj[0] = args;
43499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43500 if (!SWIG_IsOK(res1)) {
43501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43502 }
43503 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43504 {
43505 PyThreadState* __tstate = wxPyBeginAllowThreads();
43506 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
43507 wxPyEndAllowThreads(__tstate);
43508 if (PyErr_Occurred()) SWIG_fail;
43509 }
43510 {
43511 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43512 }
43513 return resultobj;
43514 fail:
43515 return NULL;
43516 }
43517
43518
43519 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43520 PyObject *resultobj = 0;
43521 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43522 bool arg2 = (bool) true ;
43523 void *argp1 = 0 ;
43524 int res1 = 0 ;
43525 bool val2 ;
43526 int ecode2 = 0 ;
43527 PyObject * obj0 = 0 ;
43528 PyObject * obj1 = 0 ;
43529 char * kwnames[] = {
43530 (char *) "self",(char *) "ownerDrawn", NULL
43531 };
43532
43533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
43534 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43535 if (!SWIG_IsOK(res1)) {
43536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43537 }
43538 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43539 if (obj1) {
43540 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43541 if (!SWIG_IsOK(ecode2)) {
43542 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
43543 }
43544 arg2 = static_cast< bool >(val2);
43545 }
43546 {
43547 PyThreadState* __tstate = wxPyBeginAllowThreads();
43548 wxMenuItem_SetOwnerDrawn(arg1,arg2);
43549 wxPyEndAllowThreads(__tstate);
43550 if (PyErr_Occurred()) SWIG_fail;
43551 }
43552 resultobj = SWIG_Py_Void();
43553 return resultobj;
43554 fail:
43555 return NULL;
43556 }
43557
43558
43559 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43560 PyObject *resultobj = 0;
43561 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43562 void *argp1 = 0 ;
43563 int res1 = 0 ;
43564 PyObject *swig_obj[1] ;
43565
43566 if (!args) SWIG_fail;
43567 swig_obj[0] = args;
43568 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43569 if (!SWIG_IsOK(res1)) {
43570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43571 }
43572 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43573 {
43574 PyThreadState* __tstate = wxPyBeginAllowThreads();
43575 wxMenuItem_ResetOwnerDrawn(arg1);
43576 wxPyEndAllowThreads(__tstate);
43577 if (PyErr_Occurred()) SWIG_fail;
43578 }
43579 resultobj = SWIG_Py_Void();
43580 return resultobj;
43581 fail:
43582 return NULL;
43583 }
43584
43585
43586 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43587 PyObject *obj;
43588 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
43589 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
43590 return SWIG_Py_Void();
43591 }
43592
43593 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43594 return SWIG_Python_InitShadowInstance(args);
43595 }
43596
43597 SWIGINTERN int ControlNameStr_set(PyObject *) {
43598 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
43599 return 1;
43600 }
43601
43602
43603 SWIGINTERN PyObject *ControlNameStr_get(void) {
43604 PyObject *pyobj = 0;
43605
43606 {
43607 #if wxUSE_UNICODE
43608 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
43609 #else
43610 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
43611 #endif
43612 }
43613 return pyobj;
43614 }
43615
43616
43617 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43618 PyObject *resultobj = 0;
43619 wxWindow *arg1 = (wxWindow *) 0 ;
43620 int arg2 = (int) -1 ;
43621 wxPoint const &arg3_defvalue = wxDefaultPosition ;
43622 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
43623 wxSize const &arg4_defvalue = wxDefaultSize ;
43624 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
43625 long arg5 = (long) 0 ;
43626 wxValidator const &arg6_defvalue = wxDefaultValidator ;
43627 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
43628 wxString const &arg7_defvalue = wxPyControlNameStr ;
43629 wxString *arg7 = (wxString *) &arg7_defvalue ;
43630 wxControl *result = 0 ;
43631 void *argp1 = 0 ;
43632 int res1 = 0 ;
43633 int val2 ;
43634 int ecode2 = 0 ;
43635 wxPoint temp3 ;
43636 wxSize temp4 ;
43637 long val5 ;
43638 int ecode5 = 0 ;
43639 void *argp6 = 0 ;
43640 int res6 = 0 ;
43641 bool temp7 = false ;
43642 PyObject * obj0 = 0 ;
43643 PyObject * obj1 = 0 ;
43644 PyObject * obj2 = 0 ;
43645 PyObject * obj3 = 0 ;
43646 PyObject * obj4 = 0 ;
43647 PyObject * obj5 = 0 ;
43648 PyObject * obj6 = 0 ;
43649 char * kwnames[] = {
43650 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
43651 };
43652
43653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
43654 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
43655 if (!SWIG_IsOK(res1)) {
43656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
43657 }
43658 arg1 = reinterpret_cast< wxWindow * >(argp1);
43659 if (obj1) {
43660 ecode2 = SWIG_AsVal_int(obj1, &val2);
43661 if (!SWIG_IsOK(ecode2)) {
43662 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
43663 }
43664 arg2 = static_cast< int >(val2);
43665 }
43666 if (obj2) {
43667 {
43668 arg3 = &temp3;
43669 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
43670 }
43671 }
43672 if (obj3) {
43673 {
43674 arg4 = &temp4;
43675 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
43676 }
43677 }
43678 if (obj4) {
43679 ecode5 = SWIG_AsVal_long(obj4, &val5);
43680 if (!SWIG_IsOK(ecode5)) {
43681 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
43682 }
43683 arg5 = static_cast< long >(val5);
43684 }
43685 if (obj5) {
43686 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
43687 if (!SWIG_IsOK(res6)) {
43688 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
43689 }
43690 if (!argp6) {
43691 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
43692 }
43693 arg6 = reinterpret_cast< wxValidator * >(argp6);
43694 }
43695 if (obj6) {
43696 {
43697 arg7 = wxString_in_helper(obj6);
43698 if (arg7 == NULL) SWIG_fail;
43699 temp7 = true;
43700 }
43701 }
43702 {
43703 if (!wxPyCheckForApp()) SWIG_fail;
43704 PyThreadState* __tstate = wxPyBeginAllowThreads();
43705 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
43706 wxPyEndAllowThreads(__tstate);
43707 if (PyErr_Occurred()) SWIG_fail;
43708 }
43709 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
43710 {
43711 if (temp7)
43712 delete arg7;
43713 }
43714 return resultobj;
43715 fail:
43716 {
43717 if (temp7)
43718 delete arg7;
43719 }
43720 return NULL;
43721 }
43722
43723
43724 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43725 PyObject *resultobj = 0;
43726 wxControl *result = 0 ;
43727
43728 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
43729 {
43730 if (!wxPyCheckForApp()) SWIG_fail;
43731 PyThreadState* __tstate = wxPyBeginAllowThreads();
43732 result = (wxControl *)new wxControl();
43733 wxPyEndAllowThreads(__tstate);
43734 if (PyErr_Occurred()) SWIG_fail;
43735 }
43736 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
43737 return resultobj;
43738 fail:
43739 return NULL;
43740 }
43741
43742
43743 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43744 PyObject *resultobj = 0;
43745 wxControl *arg1 = (wxControl *) 0 ;
43746 wxWindow *arg2 = (wxWindow *) 0 ;
43747 int arg3 = (int) -1 ;
43748 wxPoint const &arg4_defvalue = wxDefaultPosition ;
43749 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
43750 wxSize const &arg5_defvalue = wxDefaultSize ;
43751 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
43752 long arg6 = (long) 0 ;
43753 wxValidator const &arg7_defvalue = wxDefaultValidator ;
43754 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
43755 wxString const &arg8_defvalue = wxPyControlNameStr ;
43756 wxString *arg8 = (wxString *) &arg8_defvalue ;
43757 bool result;
43758 void *argp1 = 0 ;
43759 int res1 = 0 ;
43760 void *argp2 = 0 ;
43761 int res2 = 0 ;
43762 int val3 ;
43763 int ecode3 = 0 ;
43764 wxPoint temp4 ;
43765 wxSize temp5 ;
43766 long val6 ;
43767 int ecode6 = 0 ;
43768 void *argp7 = 0 ;
43769 int res7 = 0 ;
43770 bool temp8 = false ;
43771 PyObject * obj0 = 0 ;
43772 PyObject * obj1 = 0 ;
43773 PyObject * obj2 = 0 ;
43774 PyObject * obj3 = 0 ;
43775 PyObject * obj4 = 0 ;
43776 PyObject * obj5 = 0 ;
43777 PyObject * obj6 = 0 ;
43778 PyObject * obj7 = 0 ;
43779 char * kwnames[] = {
43780 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
43781 };
43782
43783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
43784 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
43785 if (!SWIG_IsOK(res1)) {
43786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
43787 }
43788 arg1 = reinterpret_cast< wxControl * >(argp1);
43789 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
43790 if (!SWIG_IsOK(res2)) {
43791 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
43792 }
43793 arg2 = reinterpret_cast< wxWindow * >(argp2);
43794 if (obj2) {
43795 ecode3 = SWIG_AsVal_int(obj2, &val3);
43796 if (!SWIG_IsOK(ecode3)) {
43797 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
43798 }
43799 arg3 = static_cast< int >(val3);
43800 }
43801 if (obj3) {
43802 {
43803 arg4 = &temp4;
43804 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
43805 }
43806 }
43807 if (obj4) {
43808 {
43809 arg5 = &temp5;
43810 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
43811 }
43812 }
43813 if (obj5) {
43814 ecode6 = SWIG_AsVal_long(obj5, &val6);
43815 if (!SWIG_IsOK(ecode6)) {
43816 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
43817 }
43818 arg6 = static_cast< long >(val6);
43819 }
43820 if (obj6) {
43821 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
43822 if (!SWIG_IsOK(res7)) {
43823 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
43824 }
43825 if (!argp7) {
43826 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
43827 }
43828 arg7 = reinterpret_cast< wxValidator * >(argp7);
43829 }
43830 if (obj7) {
43831 {
43832 arg8 = wxString_in_helper(obj7);
43833 if (arg8 == NULL) SWIG_fail;
43834 temp8 = true;
43835 }
43836 }
43837 {
43838 PyThreadState* __tstate = wxPyBeginAllowThreads();
43839 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
43840 wxPyEndAllowThreads(__tstate);
43841 if (PyErr_Occurred()) SWIG_fail;
43842 }
43843 {
43844 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43845 }
43846 {
43847 if (temp8)
43848 delete arg8;
43849 }
43850 return resultobj;
43851 fail:
43852 {
43853 if (temp8)
43854 delete arg8;
43855 }
43856 return NULL;
43857 }
43858
43859
43860 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43861 PyObject *resultobj = 0;
43862 wxControl *arg1 = (wxControl *) 0 ;
43863 wxCommandEvent *arg2 = 0 ;
43864 void *argp1 = 0 ;
43865 int res1 = 0 ;
43866 void *argp2 = 0 ;
43867 int res2 = 0 ;
43868 PyObject * obj0 = 0 ;
43869 PyObject * obj1 = 0 ;
43870 char * kwnames[] = {
43871 (char *) "self",(char *) "event", NULL
43872 };
43873
43874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
43875 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
43876 if (!SWIG_IsOK(res1)) {
43877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
43878 }
43879 arg1 = reinterpret_cast< wxControl * >(argp1);
43880 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
43881 if (!SWIG_IsOK(res2)) {
43882 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
43883 }
43884 if (!argp2) {
43885 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
43886 }
43887 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
43888 {
43889 PyThreadState* __tstate = wxPyBeginAllowThreads();
43890 (arg1)->Command(*arg2);
43891 wxPyEndAllowThreads(__tstate);
43892 if (PyErr_Occurred()) SWIG_fail;
43893 }
43894 resultobj = SWIG_Py_Void();
43895 return resultobj;
43896 fail:
43897 return NULL;
43898 }
43899
43900
43901 SWIGINTERN PyObject *_wrap_Control_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43902 PyObject *resultobj = 0;
43903 wxControl *arg1 = (wxControl *) 0 ;
43904 wxString result;
43905 void *argp1 = 0 ;
43906 int res1 = 0 ;
43907 PyObject *swig_obj[1] ;
43908
43909 if (!args) SWIG_fail;
43910 swig_obj[0] = args;
43911 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
43912 if (!SWIG_IsOK(res1)) {
43913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabel" "', expected argument " "1"" of type '" "wxControl *""'");
43914 }
43915 arg1 = reinterpret_cast< wxControl * >(argp1);
43916 {
43917 PyThreadState* __tstate = wxPyBeginAllowThreads();
43918 result = (arg1)->GetLabel();
43919 wxPyEndAllowThreads(__tstate);
43920 if (PyErr_Occurred()) SWIG_fail;
43921 }
43922 {
43923 #if wxUSE_UNICODE
43924 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43925 #else
43926 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43927 #endif
43928 }
43929 return resultobj;
43930 fail:
43931 return NULL;
43932 }
43933
43934
43935 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43936 PyObject *resultobj = 0;
43937 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
43938 SwigValueWrapper<wxVisualAttributes > result;
43939 int val1 ;
43940 int ecode1 = 0 ;
43941 PyObject * obj0 = 0 ;
43942 char * kwnames[] = {
43943 (char *) "variant", NULL
43944 };
43945
43946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
43947 if (obj0) {
43948 ecode1 = SWIG_AsVal_int(obj0, &val1);
43949 if (!SWIG_IsOK(ecode1)) {
43950 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
43951 }
43952 arg1 = static_cast< wxWindowVariant >(val1);
43953 }
43954 {
43955 if (!wxPyCheckForApp()) SWIG_fail;
43956 PyThreadState* __tstate = wxPyBeginAllowThreads();
43957 result = wxControl::GetClassDefaultAttributes(arg1);
43958 wxPyEndAllowThreads(__tstate);
43959 if (PyErr_Occurred()) SWIG_fail;
43960 }
43961 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
43962 return resultobj;
43963 fail:
43964 return NULL;
43965 }
43966
43967
43968 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43969 PyObject *obj;
43970 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
43971 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
43972 return SWIG_Py_Void();
43973 }
43974
43975 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43976 return SWIG_Python_InitShadowInstance(args);
43977 }
43978
43979 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43980 PyObject *resultobj = 0;
43981 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
43982 wxString *arg2 = 0 ;
43983 PyObject *arg3 = (PyObject *) NULL ;
43984 int result;
43985 void *argp1 = 0 ;
43986 int res1 = 0 ;
43987 bool temp2 = false ;
43988 PyObject * obj0 = 0 ;
43989 PyObject * obj1 = 0 ;
43990 PyObject * obj2 = 0 ;
43991 char * kwnames[] = {
43992 (char *) "self",(char *) "item",(char *) "clientData", NULL
43993 };
43994
43995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43996 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
43997 if (!SWIG_IsOK(res1)) {
43998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
43999 }
44000 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44001 {
44002 arg2 = wxString_in_helper(obj1);
44003 if (arg2 == NULL) SWIG_fail;
44004 temp2 = true;
44005 }
44006 if (obj2) {
44007 arg3 = obj2;
44008 }
44009 {
44010 PyThreadState* __tstate = wxPyBeginAllowThreads();
44011 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
44012 wxPyEndAllowThreads(__tstate);
44013 if (PyErr_Occurred()) SWIG_fail;
44014 }
44015 resultobj = SWIG_From_int(static_cast< int >(result));
44016 {
44017 if (temp2)
44018 delete arg2;
44019 }
44020 return resultobj;
44021 fail:
44022 {
44023 if (temp2)
44024 delete arg2;
44025 }
44026 return NULL;
44027 }
44028
44029
44030 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44031 PyObject *resultobj = 0;
44032 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44033 wxArrayString *arg2 = 0 ;
44034 void *argp1 = 0 ;
44035 int res1 = 0 ;
44036 bool temp2 = false ;
44037 PyObject * obj0 = 0 ;
44038 PyObject * obj1 = 0 ;
44039 char * kwnames[] = {
44040 (char *) "self",(char *) "strings", NULL
44041 };
44042
44043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
44044 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44045 if (!SWIG_IsOK(res1)) {
44046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44047 }
44048 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44049 {
44050 if (! PySequence_Check(obj1)) {
44051 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
44052 SWIG_fail;
44053 }
44054 arg2 = new wxArrayString;
44055 temp2 = true;
44056 int i, len=PySequence_Length(obj1);
44057 for (i=0; i<len; i++) {
44058 PyObject* item = PySequence_GetItem(obj1, i);
44059 wxString* s = wxString_in_helper(item);
44060 if (PyErr_Occurred()) SWIG_fail;
44061 arg2->Add(*s);
44062 delete s;
44063 Py_DECREF(item);
44064 }
44065 }
44066 {
44067 PyThreadState* __tstate = wxPyBeginAllowThreads();
44068 (arg1)->Append((wxArrayString const &)*arg2);
44069 wxPyEndAllowThreads(__tstate);
44070 if (PyErr_Occurred()) SWIG_fail;
44071 }
44072 resultobj = SWIG_Py_Void();
44073 {
44074 if (temp2) delete arg2;
44075 }
44076 return resultobj;
44077 fail:
44078 {
44079 if (temp2) delete arg2;
44080 }
44081 return NULL;
44082 }
44083
44084
44085 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44086 PyObject *resultobj = 0;
44087 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44088 wxString *arg2 = 0 ;
44089 unsigned int arg3 ;
44090 PyObject *arg4 = (PyObject *) NULL ;
44091 int result;
44092 void *argp1 = 0 ;
44093 int res1 = 0 ;
44094 bool temp2 = false ;
44095 unsigned int val3 ;
44096 int ecode3 = 0 ;
44097 PyObject * obj0 = 0 ;
44098 PyObject * obj1 = 0 ;
44099 PyObject * obj2 = 0 ;
44100 PyObject * obj3 = 0 ;
44101 char * kwnames[] = {
44102 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
44103 };
44104
44105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44106 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44107 if (!SWIG_IsOK(res1)) {
44108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44109 }
44110 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44111 {
44112 arg2 = wxString_in_helper(obj1);
44113 if (arg2 == NULL) SWIG_fail;
44114 temp2 = true;
44115 }
44116 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
44117 if (!SWIG_IsOK(ecode3)) {
44118 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "unsigned int""'");
44119 }
44120 arg3 = static_cast< unsigned int >(val3);
44121 if (obj3) {
44122 arg4 = obj3;
44123 }
44124 {
44125 PyThreadState* __tstate = wxPyBeginAllowThreads();
44126 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
44127 wxPyEndAllowThreads(__tstate);
44128 if (PyErr_Occurred()) SWIG_fail;
44129 }
44130 resultobj = SWIG_From_int(static_cast< int >(result));
44131 {
44132 if (temp2)
44133 delete arg2;
44134 }
44135 return resultobj;
44136 fail:
44137 {
44138 if (temp2)
44139 delete arg2;
44140 }
44141 return NULL;
44142 }
44143
44144
44145 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44146 PyObject *resultobj = 0;
44147 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44148 void *argp1 = 0 ;
44149 int res1 = 0 ;
44150 PyObject *swig_obj[1] ;
44151
44152 if (!args) SWIG_fail;
44153 swig_obj[0] = args;
44154 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44155 if (!SWIG_IsOK(res1)) {
44156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44157 }
44158 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44159 {
44160 PyThreadState* __tstate = wxPyBeginAllowThreads();
44161 (arg1)->Clear();
44162 wxPyEndAllowThreads(__tstate);
44163 if (PyErr_Occurred()) SWIG_fail;
44164 }
44165 resultobj = SWIG_Py_Void();
44166 return resultobj;
44167 fail:
44168 return NULL;
44169 }
44170
44171
44172 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44173 PyObject *resultobj = 0;
44174 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44175 unsigned int arg2 ;
44176 void *argp1 = 0 ;
44177 int res1 = 0 ;
44178 unsigned int val2 ;
44179 int ecode2 = 0 ;
44180 PyObject * obj0 = 0 ;
44181 PyObject * obj1 = 0 ;
44182 char * kwnames[] = {
44183 (char *) "self",(char *) "n", NULL
44184 };
44185
44186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
44187 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44188 if (!SWIG_IsOK(res1)) {
44189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44190 }
44191 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44192 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44193 if (!SWIG_IsOK(ecode2)) {
44194 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "unsigned int""'");
44195 }
44196 arg2 = static_cast< unsigned int >(val2);
44197 {
44198 PyThreadState* __tstate = wxPyBeginAllowThreads();
44199 (arg1)->Delete(arg2);
44200 wxPyEndAllowThreads(__tstate);
44201 if (PyErr_Occurred()) SWIG_fail;
44202 }
44203 resultobj = SWIG_Py_Void();
44204 return resultobj;
44205 fail:
44206 return NULL;
44207 }
44208
44209
44210 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44211 PyObject *resultobj = 0;
44212 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44213 unsigned int arg2 ;
44214 PyObject *result = 0 ;
44215 void *argp1 = 0 ;
44216 int res1 = 0 ;
44217 unsigned int val2 ;
44218 int ecode2 = 0 ;
44219 PyObject * obj0 = 0 ;
44220 PyObject * obj1 = 0 ;
44221 char * kwnames[] = {
44222 (char *) "self",(char *) "n", NULL
44223 };
44224
44225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
44226 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44227 if (!SWIG_IsOK(res1)) {
44228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44229 }
44230 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44231 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44232 if (!SWIG_IsOK(ecode2)) {
44233 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44234 }
44235 arg2 = static_cast< unsigned int >(val2);
44236 {
44237 PyThreadState* __tstate = wxPyBeginAllowThreads();
44238 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
44239 wxPyEndAllowThreads(__tstate);
44240 if (PyErr_Occurred()) SWIG_fail;
44241 }
44242 resultobj = result;
44243 return resultobj;
44244 fail:
44245 return NULL;
44246 }
44247
44248
44249 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44250 PyObject *resultobj = 0;
44251 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44252 unsigned int arg2 ;
44253 PyObject *arg3 = (PyObject *) 0 ;
44254 void *argp1 = 0 ;
44255 int res1 = 0 ;
44256 unsigned int val2 ;
44257 int ecode2 = 0 ;
44258 PyObject * obj0 = 0 ;
44259 PyObject * obj1 = 0 ;
44260 PyObject * obj2 = 0 ;
44261 char * kwnames[] = {
44262 (char *) "self",(char *) "n",(char *) "clientData", NULL
44263 };
44264
44265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44266 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44267 if (!SWIG_IsOK(res1)) {
44268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44269 }
44270 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44271 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44272 if (!SWIG_IsOK(ecode2)) {
44273 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44274 }
44275 arg2 = static_cast< unsigned int >(val2);
44276 arg3 = obj2;
44277 {
44278 PyThreadState* __tstate = wxPyBeginAllowThreads();
44279 wxItemContainer_SetClientData(arg1,arg2,arg3);
44280 wxPyEndAllowThreads(__tstate);
44281 if (PyErr_Occurred()) SWIG_fail;
44282 }
44283 resultobj = SWIG_Py_Void();
44284 return resultobj;
44285 fail:
44286 return NULL;
44287 }
44288
44289
44290 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44291 PyObject *resultobj = 0;
44292 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44293 unsigned int result;
44294 void *argp1 = 0 ;
44295 int res1 = 0 ;
44296 PyObject *swig_obj[1] ;
44297
44298 if (!args) SWIG_fail;
44299 swig_obj[0] = args;
44300 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44301 if (!SWIG_IsOK(res1)) {
44302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44303 }
44304 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44305 {
44306 PyThreadState* __tstate = wxPyBeginAllowThreads();
44307 result = (unsigned int)((wxItemContainer const *)arg1)->GetCount();
44308 wxPyEndAllowThreads(__tstate);
44309 if (PyErr_Occurred()) SWIG_fail;
44310 }
44311 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
44312 return resultobj;
44313 fail:
44314 return NULL;
44315 }
44316
44317
44318 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44319 PyObject *resultobj = 0;
44320 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44321 bool result;
44322 void *argp1 = 0 ;
44323 int res1 = 0 ;
44324 PyObject *swig_obj[1] ;
44325
44326 if (!args) SWIG_fail;
44327 swig_obj[0] = args;
44328 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44329 if (!SWIG_IsOK(res1)) {
44330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44331 }
44332 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44333 {
44334 PyThreadState* __tstate = wxPyBeginAllowThreads();
44335 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
44336 wxPyEndAllowThreads(__tstate);
44337 if (PyErr_Occurred()) SWIG_fail;
44338 }
44339 {
44340 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44341 }
44342 return resultobj;
44343 fail:
44344 return NULL;
44345 }
44346
44347
44348 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44349 PyObject *resultobj = 0;
44350 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44351 unsigned int arg2 ;
44352 wxString result;
44353 void *argp1 = 0 ;
44354 int res1 = 0 ;
44355 unsigned int val2 ;
44356 int ecode2 = 0 ;
44357 PyObject * obj0 = 0 ;
44358 PyObject * obj1 = 0 ;
44359 char * kwnames[] = {
44360 (char *) "self",(char *) "n", NULL
44361 };
44362
44363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
44364 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44365 if (!SWIG_IsOK(res1)) {
44366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44367 }
44368 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44369 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44370 if (!SWIG_IsOK(ecode2)) {
44371 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "unsigned int""'");
44372 }
44373 arg2 = static_cast< unsigned int >(val2);
44374 {
44375 PyThreadState* __tstate = wxPyBeginAllowThreads();
44376 result = ((wxItemContainer const *)arg1)->GetString(arg2);
44377 wxPyEndAllowThreads(__tstate);
44378 if (PyErr_Occurred()) SWIG_fail;
44379 }
44380 {
44381 #if wxUSE_UNICODE
44382 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44383 #else
44384 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44385 #endif
44386 }
44387 return resultobj;
44388 fail:
44389 return NULL;
44390 }
44391
44392
44393 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44394 PyObject *resultobj = 0;
44395 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44396 wxArrayString result;
44397 void *argp1 = 0 ;
44398 int res1 = 0 ;
44399 PyObject *swig_obj[1] ;
44400
44401 if (!args) SWIG_fail;
44402 swig_obj[0] = args;
44403 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44404 if (!SWIG_IsOK(res1)) {
44405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44406 }
44407 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44408 {
44409 PyThreadState* __tstate = wxPyBeginAllowThreads();
44410 result = ((wxItemContainer const *)arg1)->GetStrings();
44411 wxPyEndAllowThreads(__tstate);
44412 if (PyErr_Occurred()) SWIG_fail;
44413 }
44414 {
44415 resultobj = wxArrayString2PyList_helper(result);
44416 }
44417 return resultobj;
44418 fail:
44419 return NULL;
44420 }
44421
44422
44423 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44424 PyObject *resultobj = 0;
44425 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44426 unsigned int arg2 ;
44427 wxString *arg3 = 0 ;
44428 void *argp1 = 0 ;
44429 int res1 = 0 ;
44430 unsigned int val2 ;
44431 int ecode2 = 0 ;
44432 bool temp3 = false ;
44433 PyObject * obj0 = 0 ;
44434 PyObject * obj1 = 0 ;
44435 PyObject * obj2 = 0 ;
44436 char * kwnames[] = {
44437 (char *) "self",(char *) "n",(char *) "s", NULL
44438 };
44439
44440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44441 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44442 if (!SWIG_IsOK(res1)) {
44443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44444 }
44445 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44446 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44447 if (!SWIG_IsOK(ecode2)) {
44448 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "unsigned int""'");
44449 }
44450 arg2 = static_cast< unsigned int >(val2);
44451 {
44452 arg3 = wxString_in_helper(obj2);
44453 if (arg3 == NULL) SWIG_fail;
44454 temp3 = true;
44455 }
44456 {
44457 PyThreadState* __tstate = wxPyBeginAllowThreads();
44458 (arg1)->SetString(arg2,(wxString const &)*arg3);
44459 wxPyEndAllowThreads(__tstate);
44460 if (PyErr_Occurred()) SWIG_fail;
44461 }
44462 resultobj = SWIG_Py_Void();
44463 {
44464 if (temp3)
44465 delete arg3;
44466 }
44467 return resultobj;
44468 fail:
44469 {
44470 if (temp3)
44471 delete arg3;
44472 }
44473 return NULL;
44474 }
44475
44476
44477 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44478 PyObject *resultobj = 0;
44479 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44480 wxString *arg2 = 0 ;
44481 int result;
44482 void *argp1 = 0 ;
44483 int res1 = 0 ;
44484 bool temp2 = false ;
44485 PyObject * obj0 = 0 ;
44486 PyObject * obj1 = 0 ;
44487 char * kwnames[] = {
44488 (char *) "self",(char *) "s", NULL
44489 };
44490
44491 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
44492 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44493 if (!SWIG_IsOK(res1)) {
44494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44495 }
44496 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44497 {
44498 arg2 = wxString_in_helper(obj1);
44499 if (arg2 == NULL) SWIG_fail;
44500 temp2 = true;
44501 }
44502 {
44503 PyThreadState* __tstate = wxPyBeginAllowThreads();
44504 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
44505 wxPyEndAllowThreads(__tstate);
44506 if (PyErr_Occurred()) SWIG_fail;
44507 }
44508 resultobj = SWIG_From_int(static_cast< int >(result));
44509 {
44510 if (temp2)
44511 delete arg2;
44512 }
44513 return resultobj;
44514 fail:
44515 {
44516 if (temp2)
44517 delete arg2;
44518 }
44519 return NULL;
44520 }
44521
44522
44523 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44524 PyObject *resultobj = 0;
44525 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44526 int arg2 ;
44527 void *argp1 = 0 ;
44528 int res1 = 0 ;
44529 int val2 ;
44530 int ecode2 = 0 ;
44531 PyObject * obj0 = 0 ;
44532 PyObject * obj1 = 0 ;
44533 char * kwnames[] = {
44534 (char *) "self",(char *) "n", NULL
44535 };
44536
44537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
44538 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44539 if (!SWIG_IsOK(res1)) {
44540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44541 }
44542 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44543 ecode2 = SWIG_AsVal_int(obj1, &val2);
44544 if (!SWIG_IsOK(ecode2)) {
44545 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
44546 }
44547 arg2 = static_cast< int >(val2);
44548 {
44549 PyThreadState* __tstate = wxPyBeginAllowThreads();
44550 (arg1)->SetSelection(arg2);
44551 wxPyEndAllowThreads(__tstate);
44552 if (PyErr_Occurred()) SWIG_fail;
44553 }
44554 resultobj = SWIG_Py_Void();
44555 return resultobj;
44556 fail:
44557 return NULL;
44558 }
44559
44560
44561 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44562 PyObject *resultobj = 0;
44563 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44564 int result;
44565 void *argp1 = 0 ;
44566 int res1 = 0 ;
44567 PyObject *swig_obj[1] ;
44568
44569 if (!args) SWIG_fail;
44570 swig_obj[0] = args;
44571 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44572 if (!SWIG_IsOK(res1)) {
44573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44574 }
44575 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44576 {
44577 PyThreadState* __tstate = wxPyBeginAllowThreads();
44578 result = (int)((wxItemContainer const *)arg1)->GetSelection();
44579 wxPyEndAllowThreads(__tstate);
44580 if (PyErr_Occurred()) SWIG_fail;
44581 }
44582 resultobj = SWIG_From_int(static_cast< int >(result));
44583 return resultobj;
44584 fail:
44585 return NULL;
44586 }
44587
44588
44589 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44590 PyObject *resultobj = 0;
44591 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44592 wxString *arg2 = 0 ;
44593 bool result;
44594 void *argp1 = 0 ;
44595 int res1 = 0 ;
44596 bool temp2 = false ;
44597 PyObject * obj0 = 0 ;
44598 PyObject * obj1 = 0 ;
44599 char * kwnames[] = {
44600 (char *) "self",(char *) "s", NULL
44601 };
44602
44603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
44604 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44605 if (!SWIG_IsOK(res1)) {
44606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44607 }
44608 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44609 {
44610 arg2 = wxString_in_helper(obj1);
44611 if (arg2 == NULL) SWIG_fail;
44612 temp2 = true;
44613 }
44614 {
44615 PyThreadState* __tstate = wxPyBeginAllowThreads();
44616 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
44617 wxPyEndAllowThreads(__tstate);
44618 if (PyErr_Occurred()) SWIG_fail;
44619 }
44620 {
44621 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44622 }
44623 {
44624 if (temp2)
44625 delete arg2;
44626 }
44627 return resultobj;
44628 fail:
44629 {
44630 if (temp2)
44631 delete arg2;
44632 }
44633 return NULL;
44634 }
44635
44636
44637 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44638 PyObject *resultobj = 0;
44639 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44640 wxString result;
44641 void *argp1 = 0 ;
44642 int res1 = 0 ;
44643 PyObject *swig_obj[1] ;
44644
44645 if (!args) SWIG_fail;
44646 swig_obj[0] = args;
44647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44648 if (!SWIG_IsOK(res1)) {
44649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44650 }
44651 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44652 {
44653 PyThreadState* __tstate = wxPyBeginAllowThreads();
44654 result = ((wxItemContainer const *)arg1)->GetStringSelection();
44655 wxPyEndAllowThreads(__tstate);
44656 if (PyErr_Occurred()) SWIG_fail;
44657 }
44658 {
44659 #if wxUSE_UNICODE
44660 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44661 #else
44662 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44663 #endif
44664 }
44665 return resultobj;
44666 fail:
44667 return NULL;
44668 }
44669
44670
44671 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44672 PyObject *resultobj = 0;
44673 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44674 int arg2 ;
44675 void *argp1 = 0 ;
44676 int res1 = 0 ;
44677 int val2 ;
44678 int ecode2 = 0 ;
44679 PyObject * obj0 = 0 ;
44680 PyObject * obj1 = 0 ;
44681 char * kwnames[] = {
44682 (char *) "self",(char *) "n", NULL
44683 };
44684
44685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
44686 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44687 if (!SWIG_IsOK(res1)) {
44688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44689 }
44690 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44691 ecode2 = SWIG_AsVal_int(obj1, &val2);
44692 if (!SWIG_IsOK(ecode2)) {
44693 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
44694 }
44695 arg2 = static_cast< int >(val2);
44696 {
44697 PyThreadState* __tstate = wxPyBeginAllowThreads();
44698 (arg1)->Select(arg2);
44699 wxPyEndAllowThreads(__tstate);
44700 if (PyErr_Occurred()) SWIG_fail;
44701 }
44702 resultobj = SWIG_Py_Void();
44703 return resultobj;
44704 fail:
44705 return NULL;
44706 }
44707
44708
44709 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44710 PyObject *obj;
44711 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44712 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
44713 return SWIG_Py_Void();
44714 }
44715
44716 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44717 PyObject *obj;
44718 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44719 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
44720 return SWIG_Py_Void();
44721 }
44722
44723 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44724 PyObject *resultobj = 0;
44725 wxSizerItem *result = 0 ;
44726
44727 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
44728 {
44729 PyThreadState* __tstate = wxPyBeginAllowThreads();
44730 result = (wxSizerItem *)new wxSizerItem();
44731 wxPyEndAllowThreads(__tstate);
44732 if (PyErr_Occurred()) SWIG_fail;
44733 }
44734 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
44735 return resultobj;
44736 fail:
44737 return NULL;
44738 }
44739
44740
44741 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44742 PyObject *resultobj = 0;
44743 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44744 void *argp1 = 0 ;
44745 int res1 = 0 ;
44746 PyObject *swig_obj[1] ;
44747
44748 if (!args) SWIG_fail;
44749 swig_obj[0] = args;
44750 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
44751 if (!SWIG_IsOK(res1)) {
44752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44753 }
44754 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44755 {
44756 PyThreadState* __tstate = wxPyBeginAllowThreads();
44757 delete arg1;
44758
44759 wxPyEndAllowThreads(__tstate);
44760 if (PyErr_Occurred()) SWIG_fail;
44761 }
44762 resultobj = SWIG_Py_Void();
44763 return resultobj;
44764 fail:
44765 return NULL;
44766 }
44767
44768
44769 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44770 PyObject *resultobj = 0;
44771 wxWindow *arg1 = (wxWindow *) 0 ;
44772 int arg2 ;
44773 int arg3 ;
44774 int arg4 ;
44775 PyObject *arg5 = (PyObject *) NULL ;
44776 wxSizerItem *result = 0 ;
44777 void *argp1 = 0 ;
44778 int res1 = 0 ;
44779 int val2 ;
44780 int ecode2 = 0 ;
44781 int val3 ;
44782 int ecode3 = 0 ;
44783 int val4 ;
44784 int ecode4 = 0 ;
44785 PyObject * obj0 = 0 ;
44786 PyObject * obj1 = 0 ;
44787 PyObject * obj2 = 0 ;
44788 PyObject * obj3 = 0 ;
44789 PyObject * obj4 = 0 ;
44790 char * kwnames[] = {
44791 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
44792 };
44793
44794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
44795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
44796 if (!SWIG_IsOK(res1)) {
44797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
44798 }
44799 arg1 = reinterpret_cast< wxWindow * >(argp1);
44800 ecode2 = SWIG_AsVal_int(obj1, &val2);
44801 if (!SWIG_IsOK(ecode2)) {
44802 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
44803 }
44804 arg2 = static_cast< int >(val2);
44805 ecode3 = SWIG_AsVal_int(obj2, &val3);
44806 if (!SWIG_IsOK(ecode3)) {
44807 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
44808 }
44809 arg3 = static_cast< int >(val3);
44810 ecode4 = SWIG_AsVal_int(obj3, &val4);
44811 if (!SWIG_IsOK(ecode4)) {
44812 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
44813 }
44814 arg4 = static_cast< int >(val4);
44815 if (obj4) {
44816 arg5 = obj4;
44817 }
44818 {
44819 PyThreadState* __tstate = wxPyBeginAllowThreads();
44820 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
44821 wxPyEndAllowThreads(__tstate);
44822 if (PyErr_Occurred()) SWIG_fail;
44823 }
44824 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
44825 return resultobj;
44826 fail:
44827 return NULL;
44828 }
44829
44830
44831 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44832 PyObject *resultobj = 0;
44833 int arg1 ;
44834 int arg2 ;
44835 int arg3 ;
44836 int arg4 ;
44837 int arg5 ;
44838 PyObject *arg6 = (PyObject *) NULL ;
44839 wxSizerItem *result = 0 ;
44840 int val1 ;
44841 int ecode1 = 0 ;
44842 int val2 ;
44843 int ecode2 = 0 ;
44844 int val3 ;
44845 int ecode3 = 0 ;
44846 int val4 ;
44847 int ecode4 = 0 ;
44848 int val5 ;
44849 int ecode5 = 0 ;
44850 PyObject * obj0 = 0 ;
44851 PyObject * obj1 = 0 ;
44852 PyObject * obj2 = 0 ;
44853 PyObject * obj3 = 0 ;
44854 PyObject * obj4 = 0 ;
44855 PyObject * obj5 = 0 ;
44856 char * kwnames[] = {
44857 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
44858 };
44859
44860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
44861 ecode1 = SWIG_AsVal_int(obj0, &val1);
44862 if (!SWIG_IsOK(ecode1)) {
44863 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
44864 }
44865 arg1 = static_cast< int >(val1);
44866 ecode2 = SWIG_AsVal_int(obj1, &val2);
44867 if (!SWIG_IsOK(ecode2)) {
44868 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
44869 }
44870 arg2 = static_cast< int >(val2);
44871 ecode3 = SWIG_AsVal_int(obj2, &val3);
44872 if (!SWIG_IsOK(ecode3)) {
44873 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
44874 }
44875 arg3 = static_cast< int >(val3);
44876 ecode4 = SWIG_AsVal_int(obj3, &val4);
44877 if (!SWIG_IsOK(ecode4)) {
44878 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
44879 }
44880 arg4 = static_cast< int >(val4);
44881 ecode5 = SWIG_AsVal_int(obj4, &val5);
44882 if (!SWIG_IsOK(ecode5)) {
44883 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
44884 }
44885 arg5 = static_cast< int >(val5);
44886 if (obj5) {
44887 arg6 = obj5;
44888 }
44889 {
44890 PyThreadState* __tstate = wxPyBeginAllowThreads();
44891 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
44892 wxPyEndAllowThreads(__tstate);
44893 if (PyErr_Occurred()) SWIG_fail;
44894 }
44895 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
44896 return resultobj;
44897 fail:
44898 return NULL;
44899 }
44900
44901
44902 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44903 PyObject *resultobj = 0;
44904 wxSizer *arg1 = (wxSizer *) 0 ;
44905 int arg2 ;
44906 int arg3 ;
44907 int arg4 ;
44908 PyObject *arg5 = (PyObject *) NULL ;
44909 wxSizerItem *result = 0 ;
44910 int res1 = 0 ;
44911 int val2 ;
44912 int ecode2 = 0 ;
44913 int val3 ;
44914 int ecode3 = 0 ;
44915 int val4 ;
44916 int ecode4 = 0 ;
44917 PyObject * obj0 = 0 ;
44918 PyObject * obj1 = 0 ;
44919 PyObject * obj2 = 0 ;
44920 PyObject * obj3 = 0 ;
44921 PyObject * obj4 = 0 ;
44922 char * kwnames[] = {
44923 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
44924 };
44925
44926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
44927 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
44928 if (!SWIG_IsOK(res1)) {
44929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
44930 }
44931 ecode2 = SWIG_AsVal_int(obj1, &val2);
44932 if (!SWIG_IsOK(ecode2)) {
44933 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
44934 }
44935 arg2 = static_cast< int >(val2);
44936 ecode3 = SWIG_AsVal_int(obj2, &val3);
44937 if (!SWIG_IsOK(ecode3)) {
44938 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
44939 }
44940 arg3 = static_cast< int >(val3);
44941 ecode4 = SWIG_AsVal_int(obj3, &val4);
44942 if (!SWIG_IsOK(ecode4)) {
44943 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
44944 }
44945 arg4 = static_cast< int >(val4);
44946 if (obj4) {
44947 arg5 = obj4;
44948 }
44949 {
44950 PyThreadState* __tstate = wxPyBeginAllowThreads();
44951 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
44952 wxPyEndAllowThreads(__tstate);
44953 if (PyErr_Occurred()) SWIG_fail;
44954 }
44955 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
44956 return resultobj;
44957 fail:
44958 return NULL;
44959 }
44960
44961
44962 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44963 PyObject *resultobj = 0;
44964 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44965 void *argp1 = 0 ;
44966 int res1 = 0 ;
44967 PyObject *swig_obj[1] ;
44968
44969 if (!args) SWIG_fail;
44970 swig_obj[0] = args;
44971 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44972 if (!SWIG_IsOK(res1)) {
44973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44974 }
44975 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44976 {
44977 PyThreadState* __tstate = wxPyBeginAllowThreads();
44978 (arg1)->DeleteWindows();
44979 wxPyEndAllowThreads(__tstate);
44980 if (PyErr_Occurred()) SWIG_fail;
44981 }
44982 resultobj = SWIG_Py_Void();
44983 return resultobj;
44984 fail:
44985 return NULL;
44986 }
44987
44988
44989 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44990 PyObject *resultobj = 0;
44991 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44992 void *argp1 = 0 ;
44993 int res1 = 0 ;
44994 PyObject *swig_obj[1] ;
44995
44996 if (!args) SWIG_fail;
44997 swig_obj[0] = args;
44998 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44999 if (!SWIG_IsOK(res1)) {
45000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45001 }
45002 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45003 {
45004 PyThreadState* __tstate = wxPyBeginAllowThreads();
45005 (arg1)->DetachSizer();
45006 wxPyEndAllowThreads(__tstate);
45007 if (PyErr_Occurred()) SWIG_fail;
45008 }
45009 resultobj = SWIG_Py_Void();
45010 return resultobj;
45011 fail:
45012 return NULL;
45013 }
45014
45015
45016 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45017 PyObject *resultobj = 0;
45018 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45019 wxSize result;
45020 void *argp1 = 0 ;
45021 int res1 = 0 ;
45022 PyObject *swig_obj[1] ;
45023
45024 if (!args) SWIG_fail;
45025 swig_obj[0] = args;
45026 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45027 if (!SWIG_IsOK(res1)) {
45028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45029 }
45030 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45031 {
45032 PyThreadState* __tstate = wxPyBeginAllowThreads();
45033 result = (arg1)->GetSize();
45034 wxPyEndAllowThreads(__tstate);
45035 if (PyErr_Occurred()) SWIG_fail;
45036 }
45037 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45038 return resultobj;
45039 fail:
45040 return NULL;
45041 }
45042
45043
45044 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45045 PyObject *resultobj = 0;
45046 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45047 wxSize result;
45048 void *argp1 = 0 ;
45049 int res1 = 0 ;
45050 PyObject *swig_obj[1] ;
45051
45052 if (!args) SWIG_fail;
45053 swig_obj[0] = args;
45054 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45055 if (!SWIG_IsOK(res1)) {
45056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45057 }
45058 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45059 {
45060 PyThreadState* __tstate = wxPyBeginAllowThreads();
45061 result = (arg1)->CalcMin();
45062 wxPyEndAllowThreads(__tstate);
45063 if (PyErr_Occurred()) SWIG_fail;
45064 }
45065 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45066 return resultobj;
45067 fail:
45068 return NULL;
45069 }
45070
45071
45072 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45073 PyObject *resultobj = 0;
45074 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45075 wxPoint *arg2 = 0 ;
45076 wxSize *arg3 = 0 ;
45077 void *argp1 = 0 ;
45078 int res1 = 0 ;
45079 wxPoint temp2 ;
45080 wxSize temp3 ;
45081 PyObject * obj0 = 0 ;
45082 PyObject * obj1 = 0 ;
45083 PyObject * obj2 = 0 ;
45084 char * kwnames[] = {
45085 (char *) "self",(char *) "pos",(char *) "size", NULL
45086 };
45087
45088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45089 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45090 if (!SWIG_IsOK(res1)) {
45091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45092 }
45093 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45094 {
45095 arg2 = &temp2;
45096 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
45097 }
45098 {
45099 arg3 = &temp3;
45100 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
45101 }
45102 {
45103 PyThreadState* __tstate = wxPyBeginAllowThreads();
45104 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
45105 wxPyEndAllowThreads(__tstate);
45106 if (PyErr_Occurred()) SWIG_fail;
45107 }
45108 resultobj = SWIG_Py_Void();
45109 return resultobj;
45110 fail:
45111 return NULL;
45112 }
45113
45114
45115 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45116 PyObject *resultobj = 0;
45117 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45118 wxSize result;
45119 void *argp1 = 0 ;
45120 int res1 = 0 ;
45121 PyObject *swig_obj[1] ;
45122
45123 if (!args) SWIG_fail;
45124 swig_obj[0] = args;
45125 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45126 if (!SWIG_IsOK(res1)) {
45127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45128 }
45129 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45130 {
45131 PyThreadState* __tstate = wxPyBeginAllowThreads();
45132 result = (arg1)->GetMinSize();
45133 wxPyEndAllowThreads(__tstate);
45134 if (PyErr_Occurred()) SWIG_fail;
45135 }
45136 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45137 return resultobj;
45138 fail:
45139 return NULL;
45140 }
45141
45142
45143 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45144 PyObject *resultobj = 0;
45145 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45146 wxSize result;
45147 void *argp1 = 0 ;
45148 int res1 = 0 ;
45149 PyObject *swig_obj[1] ;
45150
45151 if (!args) SWIG_fail;
45152 swig_obj[0] = args;
45153 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45154 if (!SWIG_IsOK(res1)) {
45155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
45156 }
45157 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45158 {
45159 PyThreadState* __tstate = wxPyBeginAllowThreads();
45160 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
45161 wxPyEndAllowThreads(__tstate);
45162 if (PyErr_Occurred()) SWIG_fail;
45163 }
45164 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45165 return resultobj;
45166 fail:
45167 return NULL;
45168 }
45169
45170
45171 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45172 PyObject *resultobj = 0;
45173 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45174 int arg2 ;
45175 int arg3 ;
45176 void *argp1 = 0 ;
45177 int res1 = 0 ;
45178 int val2 ;
45179 int ecode2 = 0 ;
45180 int val3 ;
45181 int ecode3 = 0 ;
45182 PyObject * obj0 = 0 ;
45183 PyObject * obj1 = 0 ;
45184 PyObject * obj2 = 0 ;
45185 char * kwnames[] = {
45186 (char *) "self",(char *) "x",(char *) "y", NULL
45187 };
45188
45189 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45190 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45191 if (!SWIG_IsOK(res1)) {
45192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45193 }
45194 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45195 ecode2 = SWIG_AsVal_int(obj1, &val2);
45196 if (!SWIG_IsOK(ecode2)) {
45197 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
45198 }
45199 arg2 = static_cast< int >(val2);
45200 ecode3 = SWIG_AsVal_int(obj2, &val3);
45201 if (!SWIG_IsOK(ecode3)) {
45202 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
45203 }
45204 arg3 = static_cast< int >(val3);
45205 {
45206 PyThreadState* __tstate = wxPyBeginAllowThreads();
45207 (arg1)->SetInitSize(arg2,arg3);
45208 wxPyEndAllowThreads(__tstate);
45209 if (PyErr_Occurred()) SWIG_fail;
45210 }
45211 resultobj = SWIG_Py_Void();
45212 return resultobj;
45213 fail:
45214 return NULL;
45215 }
45216
45217
45218 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45219 PyObject *resultobj = 0;
45220 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45221 int arg2 ;
45222 int arg3 ;
45223 void *argp1 = 0 ;
45224 int res1 = 0 ;
45225 int val2 ;
45226 int ecode2 = 0 ;
45227 int val3 ;
45228 int ecode3 = 0 ;
45229 PyObject * obj0 = 0 ;
45230 PyObject * obj1 = 0 ;
45231 PyObject * obj2 = 0 ;
45232 char * kwnames[] = {
45233 (char *) "self",(char *) "width",(char *) "height", NULL
45234 };
45235
45236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45237 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45238 if (!SWIG_IsOK(res1)) {
45239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45240 }
45241 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45242 ecode2 = SWIG_AsVal_int(obj1, &val2);
45243 if (!SWIG_IsOK(ecode2)) {
45244 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
45245 }
45246 arg2 = static_cast< int >(val2);
45247 ecode3 = SWIG_AsVal_int(obj2, &val3);
45248 if (!SWIG_IsOK(ecode3)) {
45249 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
45250 }
45251 arg3 = static_cast< int >(val3);
45252 {
45253 PyThreadState* __tstate = wxPyBeginAllowThreads();
45254 (arg1)->SetRatio(arg2,arg3);
45255 wxPyEndAllowThreads(__tstate);
45256 if (PyErr_Occurred()) SWIG_fail;
45257 }
45258 resultobj = SWIG_Py_Void();
45259 return resultobj;
45260 fail:
45261 return NULL;
45262 }
45263
45264
45265 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45266 PyObject *resultobj = 0;
45267 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45268 wxSize *arg2 = 0 ;
45269 void *argp1 = 0 ;
45270 int res1 = 0 ;
45271 wxSize temp2 ;
45272 PyObject * obj0 = 0 ;
45273 PyObject * obj1 = 0 ;
45274 char * kwnames[] = {
45275 (char *) "self",(char *) "size", NULL
45276 };
45277
45278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
45279 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45280 if (!SWIG_IsOK(res1)) {
45281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45282 }
45283 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45284 {
45285 arg2 = &temp2;
45286 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
45287 }
45288 {
45289 PyThreadState* __tstate = wxPyBeginAllowThreads();
45290 (arg1)->SetRatio((wxSize const &)*arg2);
45291 wxPyEndAllowThreads(__tstate);
45292 if (PyErr_Occurred()) SWIG_fail;
45293 }
45294 resultobj = SWIG_Py_Void();
45295 return resultobj;
45296 fail:
45297 return NULL;
45298 }
45299
45300
45301 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45302 PyObject *resultobj = 0;
45303 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45304 float arg2 ;
45305 void *argp1 = 0 ;
45306 int res1 = 0 ;
45307 float val2 ;
45308 int ecode2 = 0 ;
45309 PyObject * obj0 = 0 ;
45310 PyObject * obj1 = 0 ;
45311 char * kwnames[] = {
45312 (char *) "self",(char *) "ratio", NULL
45313 };
45314
45315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
45316 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45317 if (!SWIG_IsOK(res1)) {
45318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45319 }
45320 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45321 ecode2 = SWIG_AsVal_float(obj1, &val2);
45322 if (!SWIG_IsOK(ecode2)) {
45323 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
45324 }
45325 arg2 = static_cast< float >(val2);
45326 {
45327 PyThreadState* __tstate = wxPyBeginAllowThreads();
45328 (arg1)->SetRatio(arg2);
45329 wxPyEndAllowThreads(__tstate);
45330 if (PyErr_Occurred()) SWIG_fail;
45331 }
45332 resultobj = SWIG_Py_Void();
45333 return resultobj;
45334 fail:
45335 return NULL;
45336 }
45337
45338
45339 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45340 PyObject *resultobj = 0;
45341 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45342 float result;
45343 void *argp1 = 0 ;
45344 int res1 = 0 ;
45345 PyObject *swig_obj[1] ;
45346
45347 if (!args) SWIG_fail;
45348 swig_obj[0] = args;
45349 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45350 if (!SWIG_IsOK(res1)) {
45351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45352 }
45353 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45354 {
45355 PyThreadState* __tstate = wxPyBeginAllowThreads();
45356 result = (float)(arg1)->GetRatio();
45357 wxPyEndAllowThreads(__tstate);
45358 if (PyErr_Occurred()) SWIG_fail;
45359 }
45360 resultobj = SWIG_From_float(static_cast< float >(result));
45361 return resultobj;
45362 fail:
45363 return NULL;
45364 }
45365
45366
45367 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45368 PyObject *resultobj = 0;
45369 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45370 wxRect result;
45371 void *argp1 = 0 ;
45372 int res1 = 0 ;
45373 PyObject *swig_obj[1] ;
45374
45375 if (!args) SWIG_fail;
45376 swig_obj[0] = args;
45377 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45378 if (!SWIG_IsOK(res1)) {
45379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45380 }
45381 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45382 {
45383 PyThreadState* __tstate = wxPyBeginAllowThreads();
45384 result = (arg1)->GetRect();
45385 wxPyEndAllowThreads(__tstate);
45386 if (PyErr_Occurred()) SWIG_fail;
45387 }
45388 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
45389 return resultobj;
45390 fail:
45391 return NULL;
45392 }
45393
45394
45395 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45396 PyObject *resultobj = 0;
45397 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45398 bool result;
45399 void *argp1 = 0 ;
45400 int res1 = 0 ;
45401 PyObject *swig_obj[1] ;
45402
45403 if (!args) SWIG_fail;
45404 swig_obj[0] = args;
45405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45406 if (!SWIG_IsOK(res1)) {
45407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45408 }
45409 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45410 {
45411 PyThreadState* __tstate = wxPyBeginAllowThreads();
45412 result = (bool)(arg1)->IsWindow();
45413 wxPyEndAllowThreads(__tstate);
45414 if (PyErr_Occurred()) SWIG_fail;
45415 }
45416 {
45417 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45418 }
45419 return resultobj;
45420 fail:
45421 return NULL;
45422 }
45423
45424
45425 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45426 PyObject *resultobj = 0;
45427 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45428 bool result;
45429 void *argp1 = 0 ;
45430 int res1 = 0 ;
45431 PyObject *swig_obj[1] ;
45432
45433 if (!args) SWIG_fail;
45434 swig_obj[0] = args;
45435 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45436 if (!SWIG_IsOK(res1)) {
45437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45438 }
45439 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45440 {
45441 PyThreadState* __tstate = wxPyBeginAllowThreads();
45442 result = (bool)(arg1)->IsSizer();
45443 wxPyEndAllowThreads(__tstate);
45444 if (PyErr_Occurred()) SWIG_fail;
45445 }
45446 {
45447 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45448 }
45449 return resultobj;
45450 fail:
45451 return NULL;
45452 }
45453
45454
45455 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45456 PyObject *resultobj = 0;
45457 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45458 bool result;
45459 void *argp1 = 0 ;
45460 int res1 = 0 ;
45461 PyObject *swig_obj[1] ;
45462
45463 if (!args) SWIG_fail;
45464 swig_obj[0] = args;
45465 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45466 if (!SWIG_IsOK(res1)) {
45467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45468 }
45469 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45470 {
45471 PyThreadState* __tstate = wxPyBeginAllowThreads();
45472 result = (bool)(arg1)->IsSpacer();
45473 wxPyEndAllowThreads(__tstate);
45474 if (PyErr_Occurred()) SWIG_fail;
45475 }
45476 {
45477 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45478 }
45479 return resultobj;
45480 fail:
45481 return NULL;
45482 }
45483
45484
45485 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45486 PyObject *resultobj = 0;
45487 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45488 int arg2 ;
45489 void *argp1 = 0 ;
45490 int res1 = 0 ;
45491 int val2 ;
45492 int ecode2 = 0 ;
45493 PyObject * obj0 = 0 ;
45494 PyObject * obj1 = 0 ;
45495 char * kwnames[] = {
45496 (char *) "self",(char *) "proportion", NULL
45497 };
45498
45499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
45500 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45501 if (!SWIG_IsOK(res1)) {
45502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45503 }
45504 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45505 ecode2 = SWIG_AsVal_int(obj1, &val2);
45506 if (!SWIG_IsOK(ecode2)) {
45507 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
45508 }
45509 arg2 = static_cast< int >(val2);
45510 {
45511 PyThreadState* __tstate = wxPyBeginAllowThreads();
45512 (arg1)->SetProportion(arg2);
45513 wxPyEndAllowThreads(__tstate);
45514 if (PyErr_Occurred()) SWIG_fail;
45515 }
45516 resultobj = SWIG_Py_Void();
45517 return resultobj;
45518 fail:
45519 return NULL;
45520 }
45521
45522
45523 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45524 PyObject *resultobj = 0;
45525 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45526 int result;
45527 void *argp1 = 0 ;
45528 int res1 = 0 ;
45529 PyObject *swig_obj[1] ;
45530
45531 if (!args) SWIG_fail;
45532 swig_obj[0] = args;
45533 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45534 if (!SWIG_IsOK(res1)) {
45535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45536 }
45537 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45538 {
45539 PyThreadState* __tstate = wxPyBeginAllowThreads();
45540 result = (int)(arg1)->GetProportion();
45541 wxPyEndAllowThreads(__tstate);
45542 if (PyErr_Occurred()) SWIG_fail;
45543 }
45544 resultobj = SWIG_From_int(static_cast< int >(result));
45545 return resultobj;
45546 fail:
45547 return NULL;
45548 }
45549
45550
45551 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45552 PyObject *resultobj = 0;
45553 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45554 int arg2 ;
45555 void *argp1 = 0 ;
45556 int res1 = 0 ;
45557 int val2 ;
45558 int ecode2 = 0 ;
45559 PyObject * obj0 = 0 ;
45560 PyObject * obj1 = 0 ;
45561 char * kwnames[] = {
45562 (char *) "self",(char *) "flag", NULL
45563 };
45564
45565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
45566 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45567 if (!SWIG_IsOK(res1)) {
45568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45569 }
45570 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45571 ecode2 = SWIG_AsVal_int(obj1, &val2);
45572 if (!SWIG_IsOK(ecode2)) {
45573 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
45574 }
45575 arg2 = static_cast< int >(val2);
45576 {
45577 PyThreadState* __tstate = wxPyBeginAllowThreads();
45578 (arg1)->SetFlag(arg2);
45579 wxPyEndAllowThreads(__tstate);
45580 if (PyErr_Occurred()) SWIG_fail;
45581 }
45582 resultobj = SWIG_Py_Void();
45583 return resultobj;
45584 fail:
45585 return NULL;
45586 }
45587
45588
45589 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45590 PyObject *resultobj = 0;
45591 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45592 int result;
45593 void *argp1 = 0 ;
45594 int res1 = 0 ;
45595 PyObject *swig_obj[1] ;
45596
45597 if (!args) SWIG_fail;
45598 swig_obj[0] = args;
45599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45600 if (!SWIG_IsOK(res1)) {
45601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45602 }
45603 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45604 {
45605 PyThreadState* __tstate = wxPyBeginAllowThreads();
45606 result = (int)(arg1)->GetFlag();
45607 wxPyEndAllowThreads(__tstate);
45608 if (PyErr_Occurred()) SWIG_fail;
45609 }
45610 resultobj = SWIG_From_int(static_cast< int >(result));
45611 return resultobj;
45612 fail:
45613 return NULL;
45614 }
45615
45616
45617 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45618 PyObject *resultobj = 0;
45619 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45620 int arg2 ;
45621 void *argp1 = 0 ;
45622 int res1 = 0 ;
45623 int val2 ;
45624 int ecode2 = 0 ;
45625 PyObject * obj0 = 0 ;
45626 PyObject * obj1 = 0 ;
45627 char * kwnames[] = {
45628 (char *) "self",(char *) "border", NULL
45629 };
45630
45631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
45632 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45633 if (!SWIG_IsOK(res1)) {
45634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45635 }
45636 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45637 ecode2 = SWIG_AsVal_int(obj1, &val2);
45638 if (!SWIG_IsOK(ecode2)) {
45639 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
45640 }
45641 arg2 = static_cast< int >(val2);
45642 {
45643 PyThreadState* __tstate = wxPyBeginAllowThreads();
45644 (arg1)->SetBorder(arg2);
45645 wxPyEndAllowThreads(__tstate);
45646 if (PyErr_Occurred()) SWIG_fail;
45647 }
45648 resultobj = SWIG_Py_Void();
45649 return resultobj;
45650 fail:
45651 return NULL;
45652 }
45653
45654
45655 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45656 PyObject *resultobj = 0;
45657 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45658 int result;
45659 void *argp1 = 0 ;
45660 int res1 = 0 ;
45661 PyObject *swig_obj[1] ;
45662
45663 if (!args) SWIG_fail;
45664 swig_obj[0] = args;
45665 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45666 if (!SWIG_IsOK(res1)) {
45667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45668 }
45669 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45670 {
45671 PyThreadState* __tstate = wxPyBeginAllowThreads();
45672 result = (int)(arg1)->GetBorder();
45673 wxPyEndAllowThreads(__tstate);
45674 if (PyErr_Occurred()) SWIG_fail;
45675 }
45676 resultobj = SWIG_From_int(static_cast< int >(result));
45677 return resultobj;
45678 fail:
45679 return NULL;
45680 }
45681
45682
45683 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45684 PyObject *resultobj = 0;
45685 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45686 wxWindow *result = 0 ;
45687 void *argp1 = 0 ;
45688 int res1 = 0 ;
45689 PyObject *swig_obj[1] ;
45690
45691 if (!args) SWIG_fail;
45692 swig_obj[0] = args;
45693 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45694 if (!SWIG_IsOK(res1)) {
45695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45696 }
45697 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45698 {
45699 PyThreadState* __tstate = wxPyBeginAllowThreads();
45700 result = (wxWindow *)(arg1)->GetWindow();
45701 wxPyEndAllowThreads(__tstate);
45702 if (PyErr_Occurred()) SWIG_fail;
45703 }
45704 {
45705 resultobj = wxPyMake_wxObject(result, 0);
45706 }
45707 return resultobj;
45708 fail:
45709 return NULL;
45710 }
45711
45712
45713 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45714 PyObject *resultobj = 0;
45715 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45716 wxWindow *arg2 = (wxWindow *) 0 ;
45717 void *argp1 = 0 ;
45718 int res1 = 0 ;
45719 void *argp2 = 0 ;
45720 int res2 = 0 ;
45721 PyObject * obj0 = 0 ;
45722 PyObject * obj1 = 0 ;
45723 char * kwnames[] = {
45724 (char *) "self",(char *) "window", NULL
45725 };
45726
45727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
45728 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45729 if (!SWIG_IsOK(res1)) {
45730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45731 }
45732 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45733 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
45734 if (!SWIG_IsOK(res2)) {
45735 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
45736 }
45737 arg2 = reinterpret_cast< wxWindow * >(argp2);
45738 {
45739 PyThreadState* __tstate = wxPyBeginAllowThreads();
45740 (arg1)->SetWindow(arg2);
45741 wxPyEndAllowThreads(__tstate);
45742 if (PyErr_Occurred()) SWIG_fail;
45743 }
45744 resultobj = SWIG_Py_Void();
45745 return resultobj;
45746 fail:
45747 return NULL;
45748 }
45749
45750
45751 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45752 PyObject *resultobj = 0;
45753 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45754 wxSizer *result = 0 ;
45755 void *argp1 = 0 ;
45756 int res1 = 0 ;
45757 PyObject *swig_obj[1] ;
45758
45759 if (!args) SWIG_fail;
45760 swig_obj[0] = args;
45761 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45762 if (!SWIG_IsOK(res1)) {
45763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45764 }
45765 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45766 {
45767 PyThreadState* __tstate = wxPyBeginAllowThreads();
45768 result = (wxSizer *)(arg1)->GetSizer();
45769 wxPyEndAllowThreads(__tstate);
45770 if (PyErr_Occurred()) SWIG_fail;
45771 }
45772 {
45773 resultobj = wxPyMake_wxObject(result, (bool)0);
45774 }
45775 return resultobj;
45776 fail:
45777 return NULL;
45778 }
45779
45780
45781 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45782 PyObject *resultobj = 0;
45783 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45784 wxSizer *arg2 = (wxSizer *) 0 ;
45785 void *argp1 = 0 ;
45786 int res1 = 0 ;
45787 int res2 = 0 ;
45788 PyObject * obj0 = 0 ;
45789 PyObject * obj1 = 0 ;
45790 char * kwnames[] = {
45791 (char *) "self",(char *) "sizer", NULL
45792 };
45793
45794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
45795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45796 if (!SWIG_IsOK(res1)) {
45797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45798 }
45799 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45800 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
45801 if (!SWIG_IsOK(res2)) {
45802 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
45803 }
45804 {
45805 PyThreadState* __tstate = wxPyBeginAllowThreads();
45806 (arg1)->SetSizer(arg2);
45807 wxPyEndAllowThreads(__tstate);
45808 if (PyErr_Occurred()) SWIG_fail;
45809 }
45810 resultobj = SWIG_Py_Void();
45811 return resultobj;
45812 fail:
45813 return NULL;
45814 }
45815
45816
45817 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45818 PyObject *resultobj = 0;
45819 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45820 wxSize *result = 0 ;
45821 void *argp1 = 0 ;
45822 int res1 = 0 ;
45823 PyObject *swig_obj[1] ;
45824
45825 if (!args) SWIG_fail;
45826 swig_obj[0] = args;
45827 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45828 if (!SWIG_IsOK(res1)) {
45829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45830 }
45831 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45832 {
45833 PyThreadState* __tstate = wxPyBeginAllowThreads();
45834 {
45835 wxSize const &_result_ref = (arg1)->GetSpacer();
45836 result = (wxSize *) &_result_ref;
45837 }
45838 wxPyEndAllowThreads(__tstate);
45839 if (PyErr_Occurred()) SWIG_fail;
45840 }
45841 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
45842 return resultobj;
45843 fail:
45844 return NULL;
45845 }
45846
45847
45848 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45849 PyObject *resultobj = 0;
45850 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45851 wxSize *arg2 = 0 ;
45852 void *argp1 = 0 ;
45853 int res1 = 0 ;
45854 wxSize temp2 ;
45855 PyObject * obj0 = 0 ;
45856 PyObject * obj1 = 0 ;
45857 char * kwnames[] = {
45858 (char *) "self",(char *) "size", NULL
45859 };
45860
45861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
45862 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45863 if (!SWIG_IsOK(res1)) {
45864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45865 }
45866 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45867 {
45868 arg2 = &temp2;
45869 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
45870 }
45871 {
45872 PyThreadState* __tstate = wxPyBeginAllowThreads();
45873 (arg1)->SetSpacer((wxSize const &)*arg2);
45874 wxPyEndAllowThreads(__tstate);
45875 if (PyErr_Occurred()) SWIG_fail;
45876 }
45877 resultobj = SWIG_Py_Void();
45878 return resultobj;
45879 fail:
45880 return NULL;
45881 }
45882
45883
45884 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45885 PyObject *resultobj = 0;
45886 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45887 bool arg2 ;
45888 void *argp1 = 0 ;
45889 int res1 = 0 ;
45890 bool val2 ;
45891 int ecode2 = 0 ;
45892 PyObject * obj0 = 0 ;
45893 PyObject * obj1 = 0 ;
45894 char * kwnames[] = {
45895 (char *) "self",(char *) "show", NULL
45896 };
45897
45898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
45899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45900 if (!SWIG_IsOK(res1)) {
45901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45902 }
45903 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45904 ecode2 = SWIG_AsVal_bool(obj1, &val2);
45905 if (!SWIG_IsOK(ecode2)) {
45906 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
45907 }
45908 arg2 = static_cast< bool >(val2);
45909 {
45910 PyThreadState* __tstate = wxPyBeginAllowThreads();
45911 (arg1)->Show(arg2);
45912 wxPyEndAllowThreads(__tstate);
45913 if (PyErr_Occurred()) SWIG_fail;
45914 }
45915 resultobj = SWIG_Py_Void();
45916 return resultobj;
45917 fail:
45918 return NULL;
45919 }
45920
45921
45922 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45923 PyObject *resultobj = 0;
45924 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45925 bool result;
45926 void *argp1 = 0 ;
45927 int res1 = 0 ;
45928 PyObject *swig_obj[1] ;
45929
45930 if (!args) SWIG_fail;
45931 swig_obj[0] = args;
45932 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45933 if (!SWIG_IsOK(res1)) {
45934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45935 }
45936 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45937 {
45938 PyThreadState* __tstate = wxPyBeginAllowThreads();
45939 result = (bool)(arg1)->IsShown();
45940 wxPyEndAllowThreads(__tstate);
45941 if (PyErr_Occurred()) SWIG_fail;
45942 }
45943 {
45944 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45945 }
45946 return resultobj;
45947 fail:
45948 return NULL;
45949 }
45950
45951
45952 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45953 PyObject *resultobj = 0;
45954 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45955 wxPoint result;
45956 void *argp1 = 0 ;
45957 int res1 = 0 ;
45958 PyObject *swig_obj[1] ;
45959
45960 if (!args) SWIG_fail;
45961 swig_obj[0] = args;
45962 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45963 if (!SWIG_IsOK(res1)) {
45964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45965 }
45966 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45967 {
45968 PyThreadState* __tstate = wxPyBeginAllowThreads();
45969 result = (arg1)->GetPosition();
45970 wxPyEndAllowThreads(__tstate);
45971 if (PyErr_Occurred()) SWIG_fail;
45972 }
45973 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
45974 return resultobj;
45975 fail:
45976 return NULL;
45977 }
45978
45979
45980 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45981 PyObject *resultobj = 0;
45982 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45983 PyObject *result = 0 ;
45984 void *argp1 = 0 ;
45985 int res1 = 0 ;
45986 PyObject *swig_obj[1] ;
45987
45988 if (!args) SWIG_fail;
45989 swig_obj[0] = args;
45990 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45991 if (!SWIG_IsOK(res1)) {
45992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45993 }
45994 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45995 {
45996 PyThreadState* __tstate = wxPyBeginAllowThreads();
45997 result = (PyObject *)wxSizerItem_GetUserData(arg1);
45998 wxPyEndAllowThreads(__tstate);
45999 if (PyErr_Occurred()) SWIG_fail;
46000 }
46001 resultobj = result;
46002 return resultobj;
46003 fail:
46004 return NULL;
46005 }
46006
46007
46008 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46009 PyObject *resultobj = 0;
46010 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46011 PyObject *arg2 = (PyObject *) 0 ;
46012 void *argp1 = 0 ;
46013 int res1 = 0 ;
46014 PyObject * obj0 = 0 ;
46015 PyObject * obj1 = 0 ;
46016 char * kwnames[] = {
46017 (char *) "self",(char *) "userData", NULL
46018 };
46019
46020 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
46021 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46022 if (!SWIG_IsOK(res1)) {
46023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46024 }
46025 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46026 arg2 = obj1;
46027 {
46028 PyThreadState* __tstate = wxPyBeginAllowThreads();
46029 wxSizerItem_SetUserData(arg1,arg2);
46030 wxPyEndAllowThreads(__tstate);
46031 if (PyErr_Occurred()) SWIG_fail;
46032 }
46033 resultobj = SWIG_Py_Void();
46034 return resultobj;
46035 fail:
46036 return NULL;
46037 }
46038
46039
46040 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46041 PyObject *obj;
46042 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
46043 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
46044 return SWIG_Py_Void();
46045 }
46046
46047 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46048 return SWIG_Python_InitShadowInstance(args);
46049 }
46050
46051 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46052 PyObject *resultobj = 0;
46053 wxSizer *arg1 = (wxSizer *) 0 ;
46054 void *argp1 = 0 ;
46055 int res1 = 0 ;
46056 PyObject *swig_obj[1] ;
46057
46058 if (!args) SWIG_fail;
46059 swig_obj[0] = args;
46060 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46061 if (!SWIG_IsOK(res1)) {
46062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
46063 }
46064 arg1 = reinterpret_cast< wxSizer * >(argp1);
46065 {
46066 PyThreadState* __tstate = wxPyBeginAllowThreads();
46067 delete arg1;
46068
46069 wxPyEndAllowThreads(__tstate);
46070 if (PyErr_Occurred()) SWIG_fail;
46071 }
46072 resultobj = SWIG_Py_Void();
46073 return resultobj;
46074 fail:
46075 return NULL;
46076 }
46077
46078
46079 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46080 PyObject *resultobj = 0;
46081 wxSizer *arg1 = (wxSizer *) 0 ;
46082 PyObject *arg2 = (PyObject *) 0 ;
46083 void *argp1 = 0 ;
46084 int res1 = 0 ;
46085 PyObject * obj0 = 0 ;
46086 PyObject * obj1 = 0 ;
46087 char * kwnames[] = {
46088 (char *) "self",(char *) "_self", NULL
46089 };
46090
46091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
46092 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46093 if (!SWIG_IsOK(res1)) {
46094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
46095 }
46096 arg1 = reinterpret_cast< wxSizer * >(argp1);
46097 arg2 = obj1;
46098 {
46099 PyThreadState* __tstate = wxPyBeginAllowThreads();
46100 wxSizer__setOORInfo(arg1,arg2);
46101 wxPyEndAllowThreads(__tstate);
46102 if (PyErr_Occurred()) SWIG_fail;
46103 }
46104 resultobj = SWIG_Py_Void();
46105 return resultobj;
46106 fail:
46107 return NULL;
46108 }
46109
46110
46111 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46112 PyObject *resultobj = 0;
46113 wxSizer *arg1 = (wxSizer *) 0 ;
46114 PyObject *arg2 = (PyObject *) 0 ;
46115 int arg3 = (int) 0 ;
46116 int arg4 = (int) 0 ;
46117 int arg5 = (int) 0 ;
46118 PyObject *arg6 = (PyObject *) NULL ;
46119 wxSizerItem *result = 0 ;
46120 void *argp1 = 0 ;
46121 int res1 = 0 ;
46122 int val3 ;
46123 int ecode3 = 0 ;
46124 int val4 ;
46125 int ecode4 = 0 ;
46126 int val5 ;
46127 int ecode5 = 0 ;
46128 PyObject * obj0 = 0 ;
46129 PyObject * obj1 = 0 ;
46130 PyObject * obj2 = 0 ;
46131 PyObject * obj3 = 0 ;
46132 PyObject * obj4 = 0 ;
46133 PyObject * obj5 = 0 ;
46134 char * kwnames[] = {
46135 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46136 };
46137
46138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46139 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46140 if (!SWIG_IsOK(res1)) {
46141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
46142 }
46143 arg1 = reinterpret_cast< wxSizer * >(argp1);
46144 arg2 = obj1;
46145 if (obj2) {
46146 ecode3 = SWIG_AsVal_int(obj2, &val3);
46147 if (!SWIG_IsOK(ecode3)) {
46148 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
46149 }
46150 arg3 = static_cast< int >(val3);
46151 }
46152 if (obj3) {
46153 ecode4 = SWIG_AsVal_int(obj3, &val4);
46154 if (!SWIG_IsOK(ecode4)) {
46155 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
46156 }
46157 arg4 = static_cast< int >(val4);
46158 }
46159 if (obj4) {
46160 ecode5 = SWIG_AsVal_int(obj4, &val5);
46161 if (!SWIG_IsOK(ecode5)) {
46162 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
46163 }
46164 arg5 = static_cast< int >(val5);
46165 }
46166 if (obj5) {
46167 arg6 = obj5;
46168 }
46169 {
46170 PyThreadState* __tstate = wxPyBeginAllowThreads();
46171 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
46172 wxPyEndAllowThreads(__tstate);
46173 if (PyErr_Occurred()) SWIG_fail;
46174 }
46175 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46176 return resultobj;
46177 fail:
46178 return NULL;
46179 }
46180
46181
46182 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46183 PyObject *resultobj = 0;
46184 wxSizer *arg1 = (wxSizer *) 0 ;
46185 int arg2 ;
46186 PyObject *arg3 = (PyObject *) 0 ;
46187 int arg4 = (int) 0 ;
46188 int arg5 = (int) 0 ;
46189 int arg6 = (int) 0 ;
46190 PyObject *arg7 = (PyObject *) NULL ;
46191 wxSizerItem *result = 0 ;
46192 void *argp1 = 0 ;
46193 int res1 = 0 ;
46194 int val2 ;
46195 int ecode2 = 0 ;
46196 int val4 ;
46197 int ecode4 = 0 ;
46198 int val5 ;
46199 int ecode5 = 0 ;
46200 int val6 ;
46201 int ecode6 = 0 ;
46202 PyObject * obj0 = 0 ;
46203 PyObject * obj1 = 0 ;
46204 PyObject * obj2 = 0 ;
46205 PyObject * obj3 = 0 ;
46206 PyObject * obj4 = 0 ;
46207 PyObject * obj5 = 0 ;
46208 PyObject * obj6 = 0 ;
46209 char * kwnames[] = {
46210 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46211 };
46212
46213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
46214 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46215 if (!SWIG_IsOK(res1)) {
46216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
46217 }
46218 arg1 = reinterpret_cast< wxSizer * >(argp1);
46219 ecode2 = SWIG_AsVal_int(obj1, &val2);
46220 if (!SWIG_IsOK(ecode2)) {
46221 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
46222 }
46223 arg2 = static_cast< int >(val2);
46224 arg3 = obj2;
46225 if (obj3) {
46226 ecode4 = SWIG_AsVal_int(obj3, &val4);
46227 if (!SWIG_IsOK(ecode4)) {
46228 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
46229 }
46230 arg4 = static_cast< int >(val4);
46231 }
46232 if (obj4) {
46233 ecode5 = SWIG_AsVal_int(obj4, &val5);
46234 if (!SWIG_IsOK(ecode5)) {
46235 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
46236 }
46237 arg5 = static_cast< int >(val5);
46238 }
46239 if (obj5) {
46240 ecode6 = SWIG_AsVal_int(obj5, &val6);
46241 if (!SWIG_IsOK(ecode6)) {
46242 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
46243 }
46244 arg6 = static_cast< int >(val6);
46245 }
46246 if (obj6) {
46247 arg7 = obj6;
46248 }
46249 {
46250 PyThreadState* __tstate = wxPyBeginAllowThreads();
46251 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
46252 wxPyEndAllowThreads(__tstate);
46253 if (PyErr_Occurred()) SWIG_fail;
46254 }
46255 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46256 return resultobj;
46257 fail:
46258 return NULL;
46259 }
46260
46261
46262 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46263 PyObject *resultobj = 0;
46264 wxSizer *arg1 = (wxSizer *) 0 ;
46265 PyObject *arg2 = (PyObject *) 0 ;
46266 int arg3 = (int) 0 ;
46267 int arg4 = (int) 0 ;
46268 int arg5 = (int) 0 ;
46269 PyObject *arg6 = (PyObject *) NULL ;
46270 wxSizerItem *result = 0 ;
46271 void *argp1 = 0 ;
46272 int res1 = 0 ;
46273 int val3 ;
46274 int ecode3 = 0 ;
46275 int val4 ;
46276 int ecode4 = 0 ;
46277 int val5 ;
46278 int ecode5 = 0 ;
46279 PyObject * obj0 = 0 ;
46280 PyObject * obj1 = 0 ;
46281 PyObject * obj2 = 0 ;
46282 PyObject * obj3 = 0 ;
46283 PyObject * obj4 = 0 ;
46284 PyObject * obj5 = 0 ;
46285 char * kwnames[] = {
46286 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46287 };
46288
46289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46290 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46291 if (!SWIG_IsOK(res1)) {
46292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
46293 }
46294 arg1 = reinterpret_cast< wxSizer * >(argp1);
46295 arg2 = obj1;
46296 if (obj2) {
46297 ecode3 = SWIG_AsVal_int(obj2, &val3);
46298 if (!SWIG_IsOK(ecode3)) {
46299 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
46300 }
46301 arg3 = static_cast< int >(val3);
46302 }
46303 if (obj3) {
46304 ecode4 = SWIG_AsVal_int(obj3, &val4);
46305 if (!SWIG_IsOK(ecode4)) {
46306 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
46307 }
46308 arg4 = static_cast< int >(val4);
46309 }
46310 if (obj4) {
46311 ecode5 = SWIG_AsVal_int(obj4, &val5);
46312 if (!SWIG_IsOK(ecode5)) {
46313 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
46314 }
46315 arg5 = static_cast< int >(val5);
46316 }
46317 if (obj5) {
46318 arg6 = obj5;
46319 }
46320 {
46321 PyThreadState* __tstate = wxPyBeginAllowThreads();
46322 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
46323 wxPyEndAllowThreads(__tstate);
46324 if (PyErr_Occurred()) SWIG_fail;
46325 }
46326 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46327 return resultobj;
46328 fail:
46329 return NULL;
46330 }
46331
46332
46333 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46334 PyObject *resultobj = 0;
46335 wxSizer *arg1 = (wxSizer *) 0 ;
46336 PyObject *arg2 = (PyObject *) 0 ;
46337 bool result;
46338 void *argp1 = 0 ;
46339 int res1 = 0 ;
46340 PyObject * obj0 = 0 ;
46341 PyObject * obj1 = 0 ;
46342 char * kwnames[] = {
46343 (char *) "self",(char *) "item", NULL
46344 };
46345
46346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
46347 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46348 if (!SWIG_IsOK(res1)) {
46349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
46350 }
46351 arg1 = reinterpret_cast< wxSizer * >(argp1);
46352 arg2 = obj1;
46353 {
46354 PyThreadState* __tstate = wxPyBeginAllowThreads();
46355 result = (bool)wxSizer_Remove(arg1,arg2);
46356 wxPyEndAllowThreads(__tstate);
46357 if (PyErr_Occurred()) SWIG_fail;
46358 }
46359 {
46360 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46361 }
46362 return resultobj;
46363 fail:
46364 return NULL;
46365 }
46366
46367
46368 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46369 PyObject *resultobj = 0;
46370 wxSizer *arg1 = (wxSizer *) 0 ;
46371 PyObject *arg2 = (PyObject *) 0 ;
46372 bool result;
46373 void *argp1 = 0 ;
46374 int res1 = 0 ;
46375 PyObject * obj0 = 0 ;
46376 PyObject * obj1 = 0 ;
46377 char * kwnames[] = {
46378 (char *) "self",(char *) "item", NULL
46379 };
46380
46381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
46382 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46383 if (!SWIG_IsOK(res1)) {
46384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
46385 }
46386 arg1 = reinterpret_cast< wxSizer * >(argp1);
46387 arg2 = obj1;
46388 {
46389 PyThreadState* __tstate = wxPyBeginAllowThreads();
46390 result = (bool)wxSizer_Detach(arg1,arg2);
46391 wxPyEndAllowThreads(__tstate);
46392 if (PyErr_Occurred()) SWIG_fail;
46393 }
46394 {
46395 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46396 }
46397 return resultobj;
46398 fail:
46399 return NULL;
46400 }
46401
46402
46403 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46404 PyObject *resultobj = 0;
46405 wxSizer *arg1 = (wxSizer *) 0 ;
46406 PyObject *arg2 = (PyObject *) 0 ;
46407 wxSizerItem *result = 0 ;
46408 void *argp1 = 0 ;
46409 int res1 = 0 ;
46410 PyObject * obj0 = 0 ;
46411 PyObject * obj1 = 0 ;
46412 char * kwnames[] = {
46413 (char *) "self",(char *) "item", NULL
46414 };
46415
46416 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
46417 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46418 if (!SWIG_IsOK(res1)) {
46419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46420 }
46421 arg1 = reinterpret_cast< wxSizer * >(argp1);
46422 arg2 = obj1;
46423 {
46424 PyThreadState* __tstate = wxPyBeginAllowThreads();
46425 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
46426 wxPyEndAllowThreads(__tstate);
46427 if (PyErr_Occurred()) SWIG_fail;
46428 }
46429 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46430 return resultobj;
46431 fail:
46432 return NULL;
46433 }
46434
46435
46436 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46437 PyObject *resultobj = 0;
46438 wxSizer *arg1 = (wxSizer *) 0 ;
46439 PyObject *arg2 = (PyObject *) 0 ;
46440 wxSize *arg3 = 0 ;
46441 void *argp1 = 0 ;
46442 int res1 = 0 ;
46443 wxSize temp3 ;
46444 PyObject * obj0 = 0 ;
46445 PyObject * obj1 = 0 ;
46446 PyObject * obj2 = 0 ;
46447 char * kwnames[] = {
46448 (char *) "self",(char *) "item",(char *) "size", NULL
46449 };
46450
46451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46452 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46453 if (!SWIG_IsOK(res1)) {
46454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46455 }
46456 arg1 = reinterpret_cast< wxSizer * >(argp1);
46457 arg2 = obj1;
46458 {
46459 arg3 = &temp3;
46460 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
46461 }
46462 {
46463 PyThreadState* __tstate = wxPyBeginAllowThreads();
46464 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
46465 wxPyEndAllowThreads(__tstate);
46466 if (PyErr_Occurred()) SWIG_fail;
46467 }
46468 resultobj = SWIG_Py_Void();
46469 return resultobj;
46470 fail:
46471 return NULL;
46472 }
46473
46474
46475 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46476 PyObject *resultobj = 0;
46477 wxSizer *arg1 = (wxSizer *) 0 ;
46478 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
46479 wxSizerItem *result = 0 ;
46480 void *argp1 = 0 ;
46481 int res1 = 0 ;
46482 int res2 = 0 ;
46483 PyObject * obj0 = 0 ;
46484 PyObject * obj1 = 0 ;
46485 char * kwnames[] = {
46486 (char *) "self",(char *) "item", NULL
46487 };
46488
46489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
46490 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46491 if (!SWIG_IsOK(res1)) {
46492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46493 }
46494 arg1 = reinterpret_cast< wxSizer * >(argp1);
46495 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46496 if (!SWIG_IsOK(res2)) {
46497 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
46498 }
46499 {
46500 PyThreadState* __tstate = wxPyBeginAllowThreads();
46501 result = (wxSizerItem *)(arg1)->Add(arg2);
46502 wxPyEndAllowThreads(__tstate);
46503 if (PyErr_Occurred()) SWIG_fail;
46504 }
46505 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46506 return resultobj;
46507 fail:
46508 return NULL;
46509 }
46510
46511
46512 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46513 PyObject *resultobj = 0;
46514 wxSizer *arg1 = (wxSizer *) 0 ;
46515 size_t arg2 ;
46516 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
46517 wxSizerItem *result = 0 ;
46518 void *argp1 = 0 ;
46519 int res1 = 0 ;
46520 size_t val2 ;
46521 int ecode2 = 0 ;
46522 int res3 = 0 ;
46523 PyObject * obj0 = 0 ;
46524 PyObject * obj1 = 0 ;
46525 PyObject * obj2 = 0 ;
46526 char * kwnames[] = {
46527 (char *) "self",(char *) "index",(char *) "item", NULL
46528 };
46529
46530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46532 if (!SWIG_IsOK(res1)) {
46533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46534 }
46535 arg1 = reinterpret_cast< wxSizer * >(argp1);
46536 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
46537 if (!SWIG_IsOK(ecode2)) {
46538 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
46539 }
46540 arg2 = static_cast< size_t >(val2);
46541 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46542 if (!SWIG_IsOK(res3)) {
46543 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
46544 }
46545 {
46546 PyThreadState* __tstate = wxPyBeginAllowThreads();
46547 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
46548 wxPyEndAllowThreads(__tstate);
46549 if (PyErr_Occurred()) SWIG_fail;
46550 }
46551 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46552 return resultobj;
46553 fail:
46554 return NULL;
46555 }
46556
46557
46558 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46559 PyObject *resultobj = 0;
46560 wxSizer *arg1 = (wxSizer *) 0 ;
46561 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
46562 wxSizerItem *result = 0 ;
46563 void *argp1 = 0 ;
46564 int res1 = 0 ;
46565 int res2 = 0 ;
46566 PyObject * obj0 = 0 ;
46567 PyObject * obj1 = 0 ;
46568 char * kwnames[] = {
46569 (char *) "self",(char *) "item", NULL
46570 };
46571
46572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
46573 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46574 if (!SWIG_IsOK(res1)) {
46575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46576 }
46577 arg1 = reinterpret_cast< wxSizer * >(argp1);
46578 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46579 if (!SWIG_IsOK(res2)) {
46580 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
46581 }
46582 {
46583 PyThreadState* __tstate = wxPyBeginAllowThreads();
46584 result = (wxSizerItem *)(arg1)->Prepend(arg2);
46585 wxPyEndAllowThreads(__tstate);
46586 if (PyErr_Occurred()) SWIG_fail;
46587 }
46588 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46589 return resultobj;
46590 fail:
46591 return NULL;
46592 }
46593
46594
46595 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46596 PyObject *resultobj = 0;
46597 wxSizer *arg1 = (wxSizer *) 0 ;
46598 int arg2 ;
46599 int arg3 ;
46600 int arg4 ;
46601 int arg5 ;
46602 void *argp1 = 0 ;
46603 int res1 = 0 ;
46604 int val2 ;
46605 int ecode2 = 0 ;
46606 int val3 ;
46607 int ecode3 = 0 ;
46608 int val4 ;
46609 int ecode4 = 0 ;
46610 int val5 ;
46611 int ecode5 = 0 ;
46612 PyObject * obj0 = 0 ;
46613 PyObject * obj1 = 0 ;
46614 PyObject * obj2 = 0 ;
46615 PyObject * obj3 = 0 ;
46616 PyObject * obj4 = 0 ;
46617 char * kwnames[] = {
46618 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
46619 };
46620
46621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
46622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46623 if (!SWIG_IsOK(res1)) {
46624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
46625 }
46626 arg1 = reinterpret_cast< wxSizer * >(argp1);
46627 ecode2 = SWIG_AsVal_int(obj1, &val2);
46628 if (!SWIG_IsOK(ecode2)) {
46629 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
46630 }
46631 arg2 = static_cast< int >(val2);
46632 ecode3 = SWIG_AsVal_int(obj2, &val3);
46633 if (!SWIG_IsOK(ecode3)) {
46634 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
46635 }
46636 arg3 = static_cast< int >(val3);
46637 ecode4 = SWIG_AsVal_int(obj3, &val4);
46638 if (!SWIG_IsOK(ecode4)) {
46639 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
46640 }
46641 arg4 = static_cast< int >(val4);
46642 ecode5 = SWIG_AsVal_int(obj4, &val5);
46643 if (!SWIG_IsOK(ecode5)) {
46644 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
46645 }
46646 arg5 = static_cast< int >(val5);
46647 {
46648 PyThreadState* __tstate = wxPyBeginAllowThreads();
46649 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
46650 wxPyEndAllowThreads(__tstate);
46651 if (PyErr_Occurred()) SWIG_fail;
46652 }
46653 resultobj = SWIG_Py_Void();
46654 return resultobj;
46655 fail:
46656 return NULL;
46657 }
46658
46659
46660 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46661 PyObject *resultobj = 0;
46662 wxSizer *arg1 = (wxSizer *) 0 ;
46663 wxSize *arg2 = 0 ;
46664 void *argp1 = 0 ;
46665 int res1 = 0 ;
46666 wxSize temp2 ;
46667 PyObject * obj0 = 0 ;
46668 PyObject * obj1 = 0 ;
46669 char * kwnames[] = {
46670 (char *) "self",(char *) "size", NULL
46671 };
46672
46673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
46674 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46675 if (!SWIG_IsOK(res1)) {
46676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46677 }
46678 arg1 = reinterpret_cast< wxSizer * >(argp1);
46679 {
46680 arg2 = &temp2;
46681 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46682 }
46683 {
46684 PyThreadState* __tstate = wxPyBeginAllowThreads();
46685 (arg1)->SetMinSize((wxSize const &)*arg2);
46686 wxPyEndAllowThreads(__tstate);
46687 if (PyErr_Occurred()) SWIG_fail;
46688 }
46689 resultobj = SWIG_Py_Void();
46690 return resultobj;
46691 fail:
46692 return NULL;
46693 }
46694
46695
46696 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46697 PyObject *resultobj = 0;
46698 wxSizer *arg1 = (wxSizer *) 0 ;
46699 wxSize result;
46700 void *argp1 = 0 ;
46701 int res1 = 0 ;
46702 PyObject *swig_obj[1] ;
46703
46704 if (!args) SWIG_fail;
46705 swig_obj[0] = args;
46706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46707 if (!SWIG_IsOK(res1)) {
46708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46709 }
46710 arg1 = reinterpret_cast< wxSizer * >(argp1);
46711 {
46712 PyThreadState* __tstate = wxPyBeginAllowThreads();
46713 result = (arg1)->GetSize();
46714 wxPyEndAllowThreads(__tstate);
46715 if (PyErr_Occurred()) SWIG_fail;
46716 }
46717 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46718 return resultobj;
46719 fail:
46720 return NULL;
46721 }
46722
46723
46724 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46725 PyObject *resultobj = 0;
46726 wxSizer *arg1 = (wxSizer *) 0 ;
46727 wxPoint result;
46728 void *argp1 = 0 ;
46729 int res1 = 0 ;
46730 PyObject *swig_obj[1] ;
46731
46732 if (!args) SWIG_fail;
46733 swig_obj[0] = args;
46734 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46735 if (!SWIG_IsOK(res1)) {
46736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
46737 }
46738 arg1 = reinterpret_cast< wxSizer * >(argp1);
46739 {
46740 PyThreadState* __tstate = wxPyBeginAllowThreads();
46741 result = (arg1)->GetPosition();
46742 wxPyEndAllowThreads(__tstate);
46743 if (PyErr_Occurred()) SWIG_fail;
46744 }
46745 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
46746 return resultobj;
46747 fail:
46748 return NULL;
46749 }
46750
46751
46752 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46753 PyObject *resultobj = 0;
46754 wxSizer *arg1 = (wxSizer *) 0 ;
46755 wxSize result;
46756 void *argp1 = 0 ;
46757 int res1 = 0 ;
46758 PyObject *swig_obj[1] ;
46759
46760 if (!args) SWIG_fail;
46761 swig_obj[0] = args;
46762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46763 if (!SWIG_IsOK(res1)) {
46764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46765 }
46766 arg1 = reinterpret_cast< wxSizer * >(argp1);
46767 {
46768 PyThreadState* __tstate = wxPyBeginAllowThreads();
46769 result = (arg1)->GetMinSize();
46770 wxPyEndAllowThreads(__tstate);
46771 if (PyErr_Occurred()) SWIG_fail;
46772 }
46773 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46774 return resultobj;
46775 fail:
46776 return NULL;
46777 }
46778
46779
46780 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46781 PyObject *resultobj = 0;
46782 wxSizer *arg1 = (wxSizer *) 0 ;
46783 void *argp1 = 0 ;
46784 int res1 = 0 ;
46785 PyObject *swig_obj[1] ;
46786
46787 if (!args) SWIG_fail;
46788 swig_obj[0] = args;
46789 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46790 if (!SWIG_IsOK(res1)) {
46791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
46792 }
46793 arg1 = reinterpret_cast< wxSizer * >(argp1);
46794 {
46795 PyThreadState* __tstate = wxPyBeginAllowThreads();
46796 (arg1)->RecalcSizes();
46797 wxPyEndAllowThreads(__tstate);
46798 if (PyErr_Occurred()) SWIG_fail;
46799 }
46800 resultobj = SWIG_Py_Void();
46801 return resultobj;
46802 fail:
46803 return NULL;
46804 }
46805
46806
46807 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46808 PyObject *resultobj = 0;
46809 wxSizer *arg1 = (wxSizer *) 0 ;
46810 wxSize result;
46811 void *argp1 = 0 ;
46812 int res1 = 0 ;
46813 PyObject *swig_obj[1] ;
46814
46815 if (!args) SWIG_fail;
46816 swig_obj[0] = args;
46817 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46818 if (!SWIG_IsOK(res1)) {
46819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
46820 }
46821 arg1 = reinterpret_cast< wxSizer * >(argp1);
46822 {
46823 PyThreadState* __tstate = wxPyBeginAllowThreads();
46824 result = (arg1)->CalcMin();
46825 wxPyEndAllowThreads(__tstate);
46826 if (PyErr_Occurred()) SWIG_fail;
46827 }
46828 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46829 return resultobj;
46830 fail:
46831 return NULL;
46832 }
46833
46834
46835 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46836 PyObject *resultobj = 0;
46837 wxSizer *arg1 = (wxSizer *) 0 ;
46838 void *argp1 = 0 ;
46839 int res1 = 0 ;
46840 PyObject *swig_obj[1] ;
46841
46842 if (!args) SWIG_fail;
46843 swig_obj[0] = args;
46844 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46845 if (!SWIG_IsOK(res1)) {
46846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
46847 }
46848 arg1 = reinterpret_cast< wxSizer * >(argp1);
46849 {
46850 PyThreadState* __tstate = wxPyBeginAllowThreads();
46851 (arg1)->Layout();
46852 wxPyEndAllowThreads(__tstate);
46853 if (PyErr_Occurred()) SWIG_fail;
46854 }
46855 resultobj = SWIG_Py_Void();
46856 return resultobj;
46857 fail:
46858 return NULL;
46859 }
46860
46861
46862 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46863 PyObject *resultobj = 0;
46864 wxSizer *arg1 = (wxSizer *) 0 ;
46865 wxWindow *arg2 = (wxWindow *) 0 ;
46866 wxSize result;
46867 void *argp1 = 0 ;
46868 int res1 = 0 ;
46869 void *argp2 = 0 ;
46870 int res2 = 0 ;
46871 PyObject * obj0 = 0 ;
46872 PyObject * obj1 = 0 ;
46873 char * kwnames[] = {
46874 (char *) "self",(char *) "window", NULL
46875 };
46876
46877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
46878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46879 if (!SWIG_IsOK(res1)) {
46880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
46881 }
46882 arg1 = reinterpret_cast< wxSizer * >(argp1);
46883 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46884 if (!SWIG_IsOK(res2)) {
46885 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
46886 }
46887 arg2 = reinterpret_cast< wxWindow * >(argp2);
46888 {
46889 PyThreadState* __tstate = wxPyBeginAllowThreads();
46890 result = (arg1)->Fit(arg2);
46891 wxPyEndAllowThreads(__tstate);
46892 if (PyErr_Occurred()) SWIG_fail;
46893 }
46894 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46895 return resultobj;
46896 fail:
46897 return NULL;
46898 }
46899
46900
46901 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46902 PyObject *resultobj = 0;
46903 wxSizer *arg1 = (wxSizer *) 0 ;
46904 wxWindow *arg2 = (wxWindow *) 0 ;
46905 void *argp1 = 0 ;
46906 int res1 = 0 ;
46907 void *argp2 = 0 ;
46908 int res2 = 0 ;
46909 PyObject * obj0 = 0 ;
46910 PyObject * obj1 = 0 ;
46911 char * kwnames[] = {
46912 (char *) "self",(char *) "window", NULL
46913 };
46914
46915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
46916 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46917 if (!SWIG_IsOK(res1)) {
46918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
46919 }
46920 arg1 = reinterpret_cast< wxSizer * >(argp1);
46921 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46922 if (!SWIG_IsOK(res2)) {
46923 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
46924 }
46925 arg2 = reinterpret_cast< wxWindow * >(argp2);
46926 {
46927 PyThreadState* __tstate = wxPyBeginAllowThreads();
46928 (arg1)->FitInside(arg2);
46929 wxPyEndAllowThreads(__tstate);
46930 if (PyErr_Occurred()) SWIG_fail;
46931 }
46932 resultobj = SWIG_Py_Void();
46933 return resultobj;
46934 fail:
46935 return NULL;
46936 }
46937
46938
46939 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46940 PyObject *resultobj = 0;
46941 wxSizer *arg1 = (wxSizer *) 0 ;
46942 wxWindow *arg2 = (wxWindow *) 0 ;
46943 void *argp1 = 0 ;
46944 int res1 = 0 ;
46945 void *argp2 = 0 ;
46946 int res2 = 0 ;
46947 PyObject * obj0 = 0 ;
46948 PyObject * obj1 = 0 ;
46949 char * kwnames[] = {
46950 (char *) "self",(char *) "window", NULL
46951 };
46952
46953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
46954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46955 if (!SWIG_IsOK(res1)) {
46956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
46957 }
46958 arg1 = reinterpret_cast< wxSizer * >(argp1);
46959 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46960 if (!SWIG_IsOK(res2)) {
46961 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
46962 }
46963 arg2 = reinterpret_cast< wxWindow * >(argp2);
46964 {
46965 PyThreadState* __tstate = wxPyBeginAllowThreads();
46966 (arg1)->SetSizeHints(arg2);
46967 wxPyEndAllowThreads(__tstate);
46968 if (PyErr_Occurred()) SWIG_fail;
46969 }
46970 resultobj = SWIG_Py_Void();
46971 return resultobj;
46972 fail:
46973 return NULL;
46974 }
46975
46976
46977 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46978 PyObject *resultobj = 0;
46979 wxSizer *arg1 = (wxSizer *) 0 ;
46980 wxWindow *arg2 = (wxWindow *) 0 ;
46981 void *argp1 = 0 ;
46982 int res1 = 0 ;
46983 void *argp2 = 0 ;
46984 int res2 = 0 ;
46985 PyObject * obj0 = 0 ;
46986 PyObject * obj1 = 0 ;
46987 char * kwnames[] = {
46988 (char *) "self",(char *) "window", NULL
46989 };
46990
46991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
46992 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46993 if (!SWIG_IsOK(res1)) {
46994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
46995 }
46996 arg1 = reinterpret_cast< wxSizer * >(argp1);
46997 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46998 if (!SWIG_IsOK(res2)) {
46999 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
47000 }
47001 arg2 = reinterpret_cast< wxWindow * >(argp2);
47002 {
47003 PyThreadState* __tstate = wxPyBeginAllowThreads();
47004 (arg1)->SetVirtualSizeHints(arg2);
47005 wxPyEndAllowThreads(__tstate);
47006 if (PyErr_Occurred()) SWIG_fail;
47007 }
47008 resultobj = SWIG_Py_Void();
47009 return resultobj;
47010 fail:
47011 return NULL;
47012 }
47013
47014
47015 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47016 PyObject *resultobj = 0;
47017 wxSizer *arg1 = (wxSizer *) 0 ;
47018 bool arg2 = (bool) false ;
47019 void *argp1 = 0 ;
47020 int res1 = 0 ;
47021 bool val2 ;
47022 int ecode2 = 0 ;
47023 PyObject * obj0 = 0 ;
47024 PyObject * obj1 = 0 ;
47025 char * kwnames[] = {
47026 (char *) "self",(char *) "deleteWindows", NULL
47027 };
47028
47029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
47030 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47031 if (!SWIG_IsOK(res1)) {
47032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
47033 }
47034 arg1 = reinterpret_cast< wxSizer * >(argp1);
47035 if (obj1) {
47036 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47037 if (!SWIG_IsOK(ecode2)) {
47038 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
47039 }
47040 arg2 = static_cast< bool >(val2);
47041 }
47042 {
47043 PyThreadState* __tstate = wxPyBeginAllowThreads();
47044 (arg1)->Clear(arg2);
47045 wxPyEndAllowThreads(__tstate);
47046 if (PyErr_Occurred()) SWIG_fail;
47047 }
47048 resultobj = SWIG_Py_Void();
47049 return resultobj;
47050 fail:
47051 return NULL;
47052 }
47053
47054
47055 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47056 PyObject *resultobj = 0;
47057 wxSizer *arg1 = (wxSizer *) 0 ;
47058 void *argp1 = 0 ;
47059 int res1 = 0 ;
47060 PyObject *swig_obj[1] ;
47061
47062 if (!args) SWIG_fail;
47063 swig_obj[0] = args;
47064 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47065 if (!SWIG_IsOK(res1)) {
47066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
47067 }
47068 arg1 = reinterpret_cast< wxSizer * >(argp1);
47069 {
47070 PyThreadState* __tstate = wxPyBeginAllowThreads();
47071 (arg1)->DeleteWindows();
47072 wxPyEndAllowThreads(__tstate);
47073 if (PyErr_Occurred()) SWIG_fail;
47074 }
47075 resultobj = SWIG_Py_Void();
47076 return resultobj;
47077 fail:
47078 return NULL;
47079 }
47080
47081
47082 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47083 PyObject *resultobj = 0;
47084 wxSizer *arg1 = (wxSizer *) 0 ;
47085 PyObject *result = 0 ;
47086 void *argp1 = 0 ;
47087 int res1 = 0 ;
47088 PyObject *swig_obj[1] ;
47089
47090 if (!args) SWIG_fail;
47091 swig_obj[0] = args;
47092 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47093 if (!SWIG_IsOK(res1)) {
47094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
47095 }
47096 arg1 = reinterpret_cast< wxSizer * >(argp1);
47097 {
47098 PyThreadState* __tstate = wxPyBeginAllowThreads();
47099 result = (PyObject *)wxSizer_GetChildren(arg1);
47100 wxPyEndAllowThreads(__tstate);
47101 if (PyErr_Occurred()) SWIG_fail;
47102 }
47103 resultobj = result;
47104 return resultobj;
47105 fail:
47106 return NULL;
47107 }
47108
47109
47110 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47111 PyObject *resultobj = 0;
47112 wxSizer *arg1 = (wxSizer *) 0 ;
47113 PyObject *arg2 = (PyObject *) 0 ;
47114 bool arg3 = (bool) true ;
47115 bool arg4 = (bool) false ;
47116 bool result;
47117 void *argp1 = 0 ;
47118 int res1 = 0 ;
47119 bool val3 ;
47120 int ecode3 = 0 ;
47121 bool val4 ;
47122 int ecode4 = 0 ;
47123 PyObject * obj0 = 0 ;
47124 PyObject * obj1 = 0 ;
47125 PyObject * obj2 = 0 ;
47126 PyObject * obj3 = 0 ;
47127 char * kwnames[] = {
47128 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
47129 };
47130
47131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47132 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47133 if (!SWIG_IsOK(res1)) {
47134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
47135 }
47136 arg1 = reinterpret_cast< wxSizer * >(argp1);
47137 arg2 = obj1;
47138 if (obj2) {
47139 ecode3 = SWIG_AsVal_bool(obj2, &val3);
47140 if (!SWIG_IsOK(ecode3)) {
47141 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
47142 }
47143 arg3 = static_cast< bool >(val3);
47144 }
47145 if (obj3) {
47146 ecode4 = SWIG_AsVal_bool(obj3, &val4);
47147 if (!SWIG_IsOK(ecode4)) {
47148 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
47149 }
47150 arg4 = static_cast< bool >(val4);
47151 }
47152 {
47153 PyThreadState* __tstate = wxPyBeginAllowThreads();
47154 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
47155 wxPyEndAllowThreads(__tstate);
47156 if (PyErr_Occurred()) SWIG_fail;
47157 }
47158 {
47159 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47160 }
47161 return resultobj;
47162 fail:
47163 return NULL;
47164 }
47165
47166
47167 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47168 PyObject *resultobj = 0;
47169 wxSizer *arg1 = (wxSizer *) 0 ;
47170 PyObject *arg2 = (PyObject *) 0 ;
47171 bool result;
47172 void *argp1 = 0 ;
47173 int res1 = 0 ;
47174 PyObject * obj0 = 0 ;
47175 PyObject * obj1 = 0 ;
47176 char * kwnames[] = {
47177 (char *) "self",(char *) "item", NULL
47178 };
47179
47180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
47181 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47182 if (!SWIG_IsOK(res1)) {
47183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
47184 }
47185 arg1 = reinterpret_cast< wxSizer * >(argp1);
47186 arg2 = obj1;
47187 {
47188 PyThreadState* __tstate = wxPyBeginAllowThreads();
47189 result = (bool)wxSizer_IsShown(arg1,arg2);
47190 wxPyEndAllowThreads(__tstate);
47191 if (PyErr_Occurred()) SWIG_fail;
47192 }
47193 {
47194 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47195 }
47196 return resultobj;
47197 fail:
47198 return NULL;
47199 }
47200
47201
47202 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47203 PyObject *resultobj = 0;
47204 wxSizer *arg1 = (wxSizer *) 0 ;
47205 bool arg2 ;
47206 void *argp1 = 0 ;
47207 int res1 = 0 ;
47208 bool val2 ;
47209 int ecode2 = 0 ;
47210 PyObject * obj0 = 0 ;
47211 PyObject * obj1 = 0 ;
47212 char * kwnames[] = {
47213 (char *) "self",(char *) "show", NULL
47214 };
47215
47216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
47217 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47218 if (!SWIG_IsOK(res1)) {
47219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
47220 }
47221 arg1 = reinterpret_cast< wxSizer * >(argp1);
47222 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47223 if (!SWIG_IsOK(ecode2)) {
47224 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
47225 }
47226 arg2 = static_cast< bool >(val2);
47227 {
47228 PyThreadState* __tstate = wxPyBeginAllowThreads();
47229 (arg1)->ShowItems(arg2);
47230 wxPyEndAllowThreads(__tstate);
47231 if (PyErr_Occurred()) SWIG_fail;
47232 }
47233 resultobj = SWIG_Py_Void();
47234 return resultobj;
47235 fail:
47236 return NULL;
47237 }
47238
47239
47240 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47241 PyObject *obj;
47242 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47243 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
47244 return SWIG_Py_Void();
47245 }
47246
47247 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47248 PyObject *resultobj = 0;
47249 wxPySizer *result = 0 ;
47250
47251 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
47252 {
47253 PyThreadState* __tstate = wxPyBeginAllowThreads();
47254 result = (wxPySizer *)new wxPySizer();
47255 wxPyEndAllowThreads(__tstate);
47256 if (PyErr_Occurred()) SWIG_fail;
47257 }
47258 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
47259 return resultobj;
47260 fail:
47261 return NULL;
47262 }
47263
47264
47265 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47266 PyObject *resultobj = 0;
47267 wxPySizer *arg1 = (wxPySizer *) 0 ;
47268 PyObject *arg2 = (PyObject *) 0 ;
47269 PyObject *arg3 = (PyObject *) 0 ;
47270 void *argp1 = 0 ;
47271 int res1 = 0 ;
47272 PyObject * obj0 = 0 ;
47273 PyObject * obj1 = 0 ;
47274 PyObject * obj2 = 0 ;
47275 char * kwnames[] = {
47276 (char *) "self",(char *) "self",(char *) "_class", NULL
47277 };
47278
47279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47280 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
47281 if (!SWIG_IsOK(res1)) {
47282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
47283 }
47284 arg1 = reinterpret_cast< wxPySizer * >(argp1);
47285 arg2 = obj1;
47286 arg3 = obj2;
47287 {
47288 PyThreadState* __tstate = wxPyBeginAllowThreads();
47289 (arg1)->_setCallbackInfo(arg2,arg3);
47290 wxPyEndAllowThreads(__tstate);
47291 if (PyErr_Occurred()) SWIG_fail;
47292 }
47293 resultobj = SWIG_Py_Void();
47294 return resultobj;
47295 fail:
47296 return NULL;
47297 }
47298
47299
47300 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47301 PyObject *obj;
47302 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47303 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
47304 return SWIG_Py_Void();
47305 }
47306
47307 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47308 return SWIG_Python_InitShadowInstance(args);
47309 }
47310
47311 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47312 PyObject *resultobj = 0;
47313 int arg1 = (int) wxHORIZONTAL ;
47314 wxBoxSizer *result = 0 ;
47315 int val1 ;
47316 int ecode1 = 0 ;
47317 PyObject * obj0 = 0 ;
47318 char * kwnames[] = {
47319 (char *) "orient", NULL
47320 };
47321
47322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
47323 if (obj0) {
47324 ecode1 = SWIG_AsVal_int(obj0, &val1);
47325 if (!SWIG_IsOK(ecode1)) {
47326 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
47327 }
47328 arg1 = static_cast< int >(val1);
47329 }
47330 {
47331 PyThreadState* __tstate = wxPyBeginAllowThreads();
47332 result = (wxBoxSizer *)new wxBoxSizer(arg1);
47333 wxPyEndAllowThreads(__tstate);
47334 if (PyErr_Occurred()) SWIG_fail;
47335 }
47336 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
47337 return resultobj;
47338 fail:
47339 return NULL;
47340 }
47341
47342
47343 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47344 PyObject *resultobj = 0;
47345 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47346 int result;
47347 void *argp1 = 0 ;
47348 int res1 = 0 ;
47349 PyObject *swig_obj[1] ;
47350
47351 if (!args) SWIG_fail;
47352 swig_obj[0] = args;
47353 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47354 if (!SWIG_IsOK(res1)) {
47355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47356 }
47357 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47358 {
47359 PyThreadState* __tstate = wxPyBeginAllowThreads();
47360 result = (int)(arg1)->GetOrientation();
47361 wxPyEndAllowThreads(__tstate);
47362 if (PyErr_Occurred()) SWIG_fail;
47363 }
47364 resultobj = SWIG_From_int(static_cast< int >(result));
47365 return resultobj;
47366 fail:
47367 return NULL;
47368 }
47369
47370
47371 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47372 PyObject *resultobj = 0;
47373 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47374 int arg2 ;
47375 void *argp1 = 0 ;
47376 int res1 = 0 ;
47377 int val2 ;
47378 int ecode2 = 0 ;
47379 PyObject * obj0 = 0 ;
47380 PyObject * obj1 = 0 ;
47381 char * kwnames[] = {
47382 (char *) "self",(char *) "orient", NULL
47383 };
47384
47385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
47386 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47387 if (!SWIG_IsOK(res1)) {
47388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47389 }
47390 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47391 ecode2 = SWIG_AsVal_int(obj1, &val2);
47392 if (!SWIG_IsOK(ecode2)) {
47393 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
47394 }
47395 arg2 = static_cast< int >(val2);
47396 {
47397 PyThreadState* __tstate = wxPyBeginAllowThreads();
47398 (arg1)->SetOrientation(arg2);
47399 wxPyEndAllowThreads(__tstate);
47400 if (PyErr_Occurred()) SWIG_fail;
47401 }
47402 resultobj = SWIG_Py_Void();
47403 return resultobj;
47404 fail:
47405 return NULL;
47406 }
47407
47408
47409 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47410 PyObject *obj;
47411 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47412 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
47413 return SWIG_Py_Void();
47414 }
47415
47416 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47417 return SWIG_Python_InitShadowInstance(args);
47418 }
47419
47420 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47421 PyObject *resultobj = 0;
47422 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
47423 int arg2 = (int) wxHORIZONTAL ;
47424 wxStaticBoxSizer *result = 0 ;
47425 void *argp1 = 0 ;
47426 int res1 = 0 ;
47427 int val2 ;
47428 int ecode2 = 0 ;
47429 PyObject * obj0 = 0 ;
47430 PyObject * obj1 = 0 ;
47431 char * kwnames[] = {
47432 (char *) "box",(char *) "orient", NULL
47433 };
47434
47435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
47436 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
47437 if (!SWIG_IsOK(res1)) {
47438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
47439 }
47440 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
47441 if (obj1) {
47442 ecode2 = SWIG_AsVal_int(obj1, &val2);
47443 if (!SWIG_IsOK(ecode2)) {
47444 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
47445 }
47446 arg2 = static_cast< int >(val2);
47447 }
47448 {
47449 PyThreadState* __tstate = wxPyBeginAllowThreads();
47450 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
47451 wxPyEndAllowThreads(__tstate);
47452 if (PyErr_Occurred()) SWIG_fail;
47453 }
47454 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
47455 return resultobj;
47456 fail:
47457 return NULL;
47458 }
47459
47460
47461 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47462 PyObject *resultobj = 0;
47463 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
47464 wxStaticBox *result = 0 ;
47465 void *argp1 = 0 ;
47466 int res1 = 0 ;
47467 PyObject *swig_obj[1] ;
47468
47469 if (!args) SWIG_fail;
47470 swig_obj[0] = args;
47471 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
47472 if (!SWIG_IsOK(res1)) {
47473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
47474 }
47475 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
47476 {
47477 PyThreadState* __tstate = wxPyBeginAllowThreads();
47478 result = (wxStaticBox *)(arg1)->GetStaticBox();
47479 wxPyEndAllowThreads(__tstate);
47480 if (PyErr_Occurred()) SWIG_fail;
47481 }
47482 {
47483 resultobj = wxPyMake_wxObject(result, (bool)0);
47484 }
47485 return resultobj;
47486 fail:
47487 return NULL;
47488 }
47489
47490
47491 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47492 PyObject *obj;
47493 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47494 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
47495 return SWIG_Py_Void();
47496 }
47497
47498 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47499 return SWIG_Python_InitShadowInstance(args);
47500 }
47501
47502 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47503 PyObject *resultobj = 0;
47504 int arg1 = (int) 1 ;
47505 int arg2 = (int) 0 ;
47506 int arg3 = (int) 0 ;
47507 int arg4 = (int) 0 ;
47508 wxGridSizer *result = 0 ;
47509 int val1 ;
47510 int ecode1 = 0 ;
47511 int val2 ;
47512 int ecode2 = 0 ;
47513 int val3 ;
47514 int ecode3 = 0 ;
47515 int val4 ;
47516 int ecode4 = 0 ;
47517 PyObject * obj0 = 0 ;
47518 PyObject * obj1 = 0 ;
47519 PyObject * obj2 = 0 ;
47520 PyObject * obj3 = 0 ;
47521 char * kwnames[] = {
47522 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
47523 };
47524
47525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47526 if (obj0) {
47527 ecode1 = SWIG_AsVal_int(obj0, &val1);
47528 if (!SWIG_IsOK(ecode1)) {
47529 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
47530 }
47531 arg1 = static_cast< int >(val1);
47532 }
47533 if (obj1) {
47534 ecode2 = SWIG_AsVal_int(obj1, &val2);
47535 if (!SWIG_IsOK(ecode2)) {
47536 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
47537 }
47538 arg2 = static_cast< int >(val2);
47539 }
47540 if (obj2) {
47541 ecode3 = SWIG_AsVal_int(obj2, &val3);
47542 if (!SWIG_IsOK(ecode3)) {
47543 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
47544 }
47545 arg3 = static_cast< int >(val3);
47546 }
47547 if (obj3) {
47548 ecode4 = SWIG_AsVal_int(obj3, &val4);
47549 if (!SWIG_IsOK(ecode4)) {
47550 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
47551 }
47552 arg4 = static_cast< int >(val4);
47553 }
47554 {
47555 PyThreadState* __tstate = wxPyBeginAllowThreads();
47556 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
47557 wxPyEndAllowThreads(__tstate);
47558 if (PyErr_Occurred()) SWIG_fail;
47559 }
47560 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
47561 return resultobj;
47562 fail:
47563 return NULL;
47564 }
47565
47566
47567 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47568 PyObject *resultobj = 0;
47569 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47570 int arg2 ;
47571 void *argp1 = 0 ;
47572 int res1 = 0 ;
47573 int val2 ;
47574 int ecode2 = 0 ;
47575 PyObject * obj0 = 0 ;
47576 PyObject * obj1 = 0 ;
47577 char * kwnames[] = {
47578 (char *) "self",(char *) "cols", NULL
47579 };
47580
47581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
47582 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47583 if (!SWIG_IsOK(res1)) {
47584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47585 }
47586 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47587 ecode2 = SWIG_AsVal_int(obj1, &val2);
47588 if (!SWIG_IsOK(ecode2)) {
47589 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
47590 }
47591 arg2 = static_cast< int >(val2);
47592 {
47593 PyThreadState* __tstate = wxPyBeginAllowThreads();
47594 (arg1)->SetCols(arg2);
47595 wxPyEndAllowThreads(__tstate);
47596 if (PyErr_Occurred()) SWIG_fail;
47597 }
47598 resultobj = SWIG_Py_Void();
47599 return resultobj;
47600 fail:
47601 return NULL;
47602 }
47603
47604
47605 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47606 PyObject *resultobj = 0;
47607 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47608 int arg2 ;
47609 void *argp1 = 0 ;
47610 int res1 = 0 ;
47611 int val2 ;
47612 int ecode2 = 0 ;
47613 PyObject * obj0 = 0 ;
47614 PyObject * obj1 = 0 ;
47615 char * kwnames[] = {
47616 (char *) "self",(char *) "rows", NULL
47617 };
47618
47619 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
47620 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47621 if (!SWIG_IsOK(res1)) {
47622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47623 }
47624 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47625 ecode2 = SWIG_AsVal_int(obj1, &val2);
47626 if (!SWIG_IsOK(ecode2)) {
47627 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
47628 }
47629 arg2 = static_cast< int >(val2);
47630 {
47631 PyThreadState* __tstate = wxPyBeginAllowThreads();
47632 (arg1)->SetRows(arg2);
47633 wxPyEndAllowThreads(__tstate);
47634 if (PyErr_Occurred()) SWIG_fail;
47635 }
47636 resultobj = SWIG_Py_Void();
47637 return resultobj;
47638 fail:
47639 return NULL;
47640 }
47641
47642
47643 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47644 PyObject *resultobj = 0;
47645 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47646 int arg2 ;
47647 void *argp1 = 0 ;
47648 int res1 = 0 ;
47649 int val2 ;
47650 int ecode2 = 0 ;
47651 PyObject * obj0 = 0 ;
47652 PyObject * obj1 = 0 ;
47653 char * kwnames[] = {
47654 (char *) "self",(char *) "gap", NULL
47655 };
47656
47657 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
47658 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47659 if (!SWIG_IsOK(res1)) {
47660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47661 }
47662 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47663 ecode2 = SWIG_AsVal_int(obj1, &val2);
47664 if (!SWIG_IsOK(ecode2)) {
47665 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
47666 }
47667 arg2 = static_cast< int >(val2);
47668 {
47669 PyThreadState* __tstate = wxPyBeginAllowThreads();
47670 (arg1)->SetVGap(arg2);
47671 wxPyEndAllowThreads(__tstate);
47672 if (PyErr_Occurred()) SWIG_fail;
47673 }
47674 resultobj = SWIG_Py_Void();
47675 return resultobj;
47676 fail:
47677 return NULL;
47678 }
47679
47680
47681 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47682 PyObject *resultobj = 0;
47683 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47684 int arg2 ;
47685 void *argp1 = 0 ;
47686 int res1 = 0 ;
47687 int val2 ;
47688 int ecode2 = 0 ;
47689 PyObject * obj0 = 0 ;
47690 PyObject * obj1 = 0 ;
47691 char * kwnames[] = {
47692 (char *) "self",(char *) "gap", NULL
47693 };
47694
47695 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
47696 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47697 if (!SWIG_IsOK(res1)) {
47698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47699 }
47700 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47701 ecode2 = SWIG_AsVal_int(obj1, &val2);
47702 if (!SWIG_IsOK(ecode2)) {
47703 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
47704 }
47705 arg2 = static_cast< int >(val2);
47706 {
47707 PyThreadState* __tstate = wxPyBeginAllowThreads();
47708 (arg1)->SetHGap(arg2);
47709 wxPyEndAllowThreads(__tstate);
47710 if (PyErr_Occurred()) SWIG_fail;
47711 }
47712 resultobj = SWIG_Py_Void();
47713 return resultobj;
47714 fail:
47715 return NULL;
47716 }
47717
47718
47719 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47720 PyObject *resultobj = 0;
47721 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47722 int result;
47723 void *argp1 = 0 ;
47724 int res1 = 0 ;
47725 PyObject *swig_obj[1] ;
47726
47727 if (!args) SWIG_fail;
47728 swig_obj[0] = args;
47729 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47730 if (!SWIG_IsOK(res1)) {
47731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47732 }
47733 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47734 {
47735 PyThreadState* __tstate = wxPyBeginAllowThreads();
47736 result = (int)(arg1)->GetCols();
47737 wxPyEndAllowThreads(__tstate);
47738 if (PyErr_Occurred()) SWIG_fail;
47739 }
47740 resultobj = SWIG_From_int(static_cast< int >(result));
47741 return resultobj;
47742 fail:
47743 return NULL;
47744 }
47745
47746
47747 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47748 PyObject *resultobj = 0;
47749 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47750 int result;
47751 void *argp1 = 0 ;
47752 int res1 = 0 ;
47753 PyObject *swig_obj[1] ;
47754
47755 if (!args) SWIG_fail;
47756 swig_obj[0] = args;
47757 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47758 if (!SWIG_IsOK(res1)) {
47759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47760 }
47761 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47762 {
47763 PyThreadState* __tstate = wxPyBeginAllowThreads();
47764 result = (int)(arg1)->GetRows();
47765 wxPyEndAllowThreads(__tstate);
47766 if (PyErr_Occurred()) SWIG_fail;
47767 }
47768 resultobj = SWIG_From_int(static_cast< int >(result));
47769 return resultobj;
47770 fail:
47771 return NULL;
47772 }
47773
47774
47775 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47776 PyObject *resultobj = 0;
47777 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47778 int result;
47779 void *argp1 = 0 ;
47780 int res1 = 0 ;
47781 PyObject *swig_obj[1] ;
47782
47783 if (!args) SWIG_fail;
47784 swig_obj[0] = args;
47785 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47786 if (!SWIG_IsOK(res1)) {
47787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47788 }
47789 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47790 {
47791 PyThreadState* __tstate = wxPyBeginAllowThreads();
47792 result = (int)(arg1)->GetVGap();
47793 wxPyEndAllowThreads(__tstate);
47794 if (PyErr_Occurred()) SWIG_fail;
47795 }
47796 resultobj = SWIG_From_int(static_cast< int >(result));
47797 return resultobj;
47798 fail:
47799 return NULL;
47800 }
47801
47802
47803 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47804 PyObject *resultobj = 0;
47805 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47806 int result;
47807 void *argp1 = 0 ;
47808 int res1 = 0 ;
47809 PyObject *swig_obj[1] ;
47810
47811 if (!args) SWIG_fail;
47812 swig_obj[0] = args;
47813 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47814 if (!SWIG_IsOK(res1)) {
47815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47816 }
47817 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47818 {
47819 PyThreadState* __tstate = wxPyBeginAllowThreads();
47820 result = (int)(arg1)->GetHGap();
47821 wxPyEndAllowThreads(__tstate);
47822 if (PyErr_Occurred()) SWIG_fail;
47823 }
47824 resultobj = SWIG_From_int(static_cast< int >(result));
47825 return resultobj;
47826 fail:
47827 return NULL;
47828 }
47829
47830
47831 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47832 PyObject *obj;
47833 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47834 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
47835 return SWIG_Py_Void();
47836 }
47837
47838 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47839 return SWIG_Python_InitShadowInstance(args);
47840 }
47841
47842 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47843 PyObject *resultobj = 0;
47844 int arg1 = (int) 1 ;
47845 int arg2 = (int) 0 ;
47846 int arg3 = (int) 0 ;
47847 int arg4 = (int) 0 ;
47848 wxFlexGridSizer *result = 0 ;
47849 int val1 ;
47850 int ecode1 = 0 ;
47851 int val2 ;
47852 int ecode2 = 0 ;
47853 int val3 ;
47854 int ecode3 = 0 ;
47855 int val4 ;
47856 int ecode4 = 0 ;
47857 PyObject * obj0 = 0 ;
47858 PyObject * obj1 = 0 ;
47859 PyObject * obj2 = 0 ;
47860 PyObject * obj3 = 0 ;
47861 char * kwnames[] = {
47862 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
47863 };
47864
47865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47866 if (obj0) {
47867 ecode1 = SWIG_AsVal_int(obj0, &val1);
47868 if (!SWIG_IsOK(ecode1)) {
47869 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
47870 }
47871 arg1 = static_cast< int >(val1);
47872 }
47873 if (obj1) {
47874 ecode2 = SWIG_AsVal_int(obj1, &val2);
47875 if (!SWIG_IsOK(ecode2)) {
47876 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
47877 }
47878 arg2 = static_cast< int >(val2);
47879 }
47880 if (obj2) {
47881 ecode3 = SWIG_AsVal_int(obj2, &val3);
47882 if (!SWIG_IsOK(ecode3)) {
47883 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
47884 }
47885 arg3 = static_cast< int >(val3);
47886 }
47887 if (obj3) {
47888 ecode4 = SWIG_AsVal_int(obj3, &val4);
47889 if (!SWIG_IsOK(ecode4)) {
47890 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
47891 }
47892 arg4 = static_cast< int >(val4);
47893 }
47894 {
47895 PyThreadState* __tstate = wxPyBeginAllowThreads();
47896 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
47897 wxPyEndAllowThreads(__tstate);
47898 if (PyErr_Occurred()) SWIG_fail;
47899 }
47900 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
47901 return resultobj;
47902 fail:
47903 return NULL;
47904 }
47905
47906
47907 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47908 PyObject *resultobj = 0;
47909 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47910 size_t arg2 ;
47911 int arg3 = (int) 0 ;
47912 void *argp1 = 0 ;
47913 int res1 = 0 ;
47914 size_t val2 ;
47915 int ecode2 = 0 ;
47916 int val3 ;
47917 int ecode3 = 0 ;
47918 PyObject * obj0 = 0 ;
47919 PyObject * obj1 = 0 ;
47920 PyObject * obj2 = 0 ;
47921 char * kwnames[] = {
47922 (char *) "self",(char *) "idx",(char *) "proportion", NULL
47923 };
47924
47925 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47926 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47927 if (!SWIG_IsOK(res1)) {
47928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47929 }
47930 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47931 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47932 if (!SWIG_IsOK(ecode2)) {
47933 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
47934 }
47935 arg2 = static_cast< size_t >(val2);
47936 if (obj2) {
47937 ecode3 = SWIG_AsVal_int(obj2, &val3);
47938 if (!SWIG_IsOK(ecode3)) {
47939 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
47940 }
47941 arg3 = static_cast< int >(val3);
47942 }
47943 {
47944 PyThreadState* __tstate = wxPyBeginAllowThreads();
47945 (arg1)->AddGrowableRow(arg2,arg3);
47946 wxPyEndAllowThreads(__tstate);
47947 if (PyErr_Occurred()) SWIG_fail;
47948 }
47949 resultobj = SWIG_Py_Void();
47950 return resultobj;
47951 fail:
47952 return NULL;
47953 }
47954
47955
47956 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47957 PyObject *resultobj = 0;
47958 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47959 size_t arg2 ;
47960 void *argp1 = 0 ;
47961 int res1 = 0 ;
47962 size_t val2 ;
47963 int ecode2 = 0 ;
47964 PyObject * obj0 = 0 ;
47965 PyObject * obj1 = 0 ;
47966 char * kwnames[] = {
47967 (char *) "self",(char *) "idx", NULL
47968 };
47969
47970 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
47971 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47972 if (!SWIG_IsOK(res1)) {
47973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47974 }
47975 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47976 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47977 if (!SWIG_IsOK(ecode2)) {
47978 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
47979 }
47980 arg2 = static_cast< size_t >(val2);
47981 {
47982 PyThreadState* __tstate = wxPyBeginAllowThreads();
47983 (arg1)->RemoveGrowableRow(arg2);
47984 wxPyEndAllowThreads(__tstate);
47985 if (PyErr_Occurred()) SWIG_fail;
47986 }
47987 resultobj = SWIG_Py_Void();
47988 return resultobj;
47989 fail:
47990 return NULL;
47991 }
47992
47993
47994 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47995 PyObject *resultobj = 0;
47996 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47997 size_t arg2 ;
47998 int arg3 = (int) 0 ;
47999 void *argp1 = 0 ;
48000 int res1 = 0 ;
48001 size_t val2 ;
48002 int ecode2 = 0 ;
48003 int val3 ;
48004 int ecode3 = 0 ;
48005 PyObject * obj0 = 0 ;
48006 PyObject * obj1 = 0 ;
48007 PyObject * obj2 = 0 ;
48008 char * kwnames[] = {
48009 (char *) "self",(char *) "idx",(char *) "proportion", NULL
48010 };
48011
48012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48013 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48014 if (!SWIG_IsOK(res1)) {
48015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48016 }
48017 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48018 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48019 if (!SWIG_IsOK(ecode2)) {
48020 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
48021 }
48022 arg2 = static_cast< size_t >(val2);
48023 if (obj2) {
48024 ecode3 = SWIG_AsVal_int(obj2, &val3);
48025 if (!SWIG_IsOK(ecode3)) {
48026 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
48027 }
48028 arg3 = static_cast< int >(val3);
48029 }
48030 {
48031 PyThreadState* __tstate = wxPyBeginAllowThreads();
48032 (arg1)->AddGrowableCol(arg2,arg3);
48033 wxPyEndAllowThreads(__tstate);
48034 if (PyErr_Occurred()) SWIG_fail;
48035 }
48036 resultobj = SWIG_Py_Void();
48037 return resultobj;
48038 fail:
48039 return NULL;
48040 }
48041
48042
48043 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48044 PyObject *resultobj = 0;
48045 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48046 size_t arg2 ;
48047 void *argp1 = 0 ;
48048 int res1 = 0 ;
48049 size_t val2 ;
48050 int ecode2 = 0 ;
48051 PyObject * obj0 = 0 ;
48052 PyObject * obj1 = 0 ;
48053 char * kwnames[] = {
48054 (char *) "self",(char *) "idx", NULL
48055 };
48056
48057 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
48058 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48059 if (!SWIG_IsOK(res1)) {
48060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48061 }
48062 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48063 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48064 if (!SWIG_IsOK(ecode2)) {
48065 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
48066 }
48067 arg2 = static_cast< size_t >(val2);
48068 {
48069 PyThreadState* __tstate = wxPyBeginAllowThreads();
48070 (arg1)->RemoveGrowableCol(arg2);
48071 wxPyEndAllowThreads(__tstate);
48072 if (PyErr_Occurred()) SWIG_fail;
48073 }
48074 resultobj = SWIG_Py_Void();
48075 return resultobj;
48076 fail:
48077 return NULL;
48078 }
48079
48080
48081 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48082 PyObject *resultobj = 0;
48083 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48084 int arg2 ;
48085 void *argp1 = 0 ;
48086 int res1 = 0 ;
48087 int val2 ;
48088 int ecode2 = 0 ;
48089 PyObject * obj0 = 0 ;
48090 PyObject * obj1 = 0 ;
48091 char * kwnames[] = {
48092 (char *) "self",(char *) "direction", NULL
48093 };
48094
48095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
48096 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48097 if (!SWIG_IsOK(res1)) {
48098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48099 }
48100 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48101 ecode2 = SWIG_AsVal_int(obj1, &val2);
48102 if (!SWIG_IsOK(ecode2)) {
48103 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
48104 }
48105 arg2 = static_cast< int >(val2);
48106 {
48107 PyThreadState* __tstate = wxPyBeginAllowThreads();
48108 (arg1)->SetFlexibleDirection(arg2);
48109 wxPyEndAllowThreads(__tstate);
48110 if (PyErr_Occurred()) SWIG_fail;
48111 }
48112 resultobj = SWIG_Py_Void();
48113 return resultobj;
48114 fail:
48115 return NULL;
48116 }
48117
48118
48119 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48120 PyObject *resultobj = 0;
48121 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48122 int result;
48123 void *argp1 = 0 ;
48124 int res1 = 0 ;
48125 PyObject *swig_obj[1] ;
48126
48127 if (!args) SWIG_fail;
48128 swig_obj[0] = args;
48129 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48130 if (!SWIG_IsOK(res1)) {
48131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48132 }
48133 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48134 {
48135 PyThreadState* __tstate = wxPyBeginAllowThreads();
48136 result = (int)(arg1)->GetFlexibleDirection();
48137 wxPyEndAllowThreads(__tstate);
48138 if (PyErr_Occurred()) SWIG_fail;
48139 }
48140 resultobj = SWIG_From_int(static_cast< int >(result));
48141 return resultobj;
48142 fail:
48143 return NULL;
48144 }
48145
48146
48147 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48148 PyObject *resultobj = 0;
48149 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48150 wxFlexSizerGrowMode arg2 ;
48151 void *argp1 = 0 ;
48152 int res1 = 0 ;
48153 int val2 ;
48154 int ecode2 = 0 ;
48155 PyObject * obj0 = 0 ;
48156 PyObject * obj1 = 0 ;
48157 char * kwnames[] = {
48158 (char *) "self",(char *) "mode", NULL
48159 };
48160
48161 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
48162 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48163 if (!SWIG_IsOK(res1)) {
48164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48165 }
48166 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48167 ecode2 = SWIG_AsVal_int(obj1, &val2);
48168 if (!SWIG_IsOK(ecode2)) {
48169 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
48170 }
48171 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
48172 {
48173 PyThreadState* __tstate = wxPyBeginAllowThreads();
48174 (arg1)->SetNonFlexibleGrowMode(arg2);
48175 wxPyEndAllowThreads(__tstate);
48176 if (PyErr_Occurred()) SWIG_fail;
48177 }
48178 resultobj = SWIG_Py_Void();
48179 return resultobj;
48180 fail:
48181 return NULL;
48182 }
48183
48184
48185 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48186 PyObject *resultobj = 0;
48187 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48188 wxFlexSizerGrowMode result;
48189 void *argp1 = 0 ;
48190 int res1 = 0 ;
48191 PyObject *swig_obj[1] ;
48192
48193 if (!args) SWIG_fail;
48194 swig_obj[0] = args;
48195 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48196 if (!SWIG_IsOK(res1)) {
48197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48198 }
48199 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48200 {
48201 PyThreadState* __tstate = wxPyBeginAllowThreads();
48202 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
48203 wxPyEndAllowThreads(__tstate);
48204 if (PyErr_Occurred()) SWIG_fail;
48205 }
48206 resultobj = SWIG_From_int(static_cast< int >(result));
48207 return resultobj;
48208 fail:
48209 return NULL;
48210 }
48211
48212
48213 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48214 PyObject *resultobj = 0;
48215 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48216 wxArrayInt *result = 0 ;
48217 void *argp1 = 0 ;
48218 int res1 = 0 ;
48219 PyObject *swig_obj[1] ;
48220
48221 if (!args) SWIG_fail;
48222 swig_obj[0] = args;
48223 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48224 if (!SWIG_IsOK(res1)) {
48225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48226 }
48227 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48228 {
48229 PyThreadState* __tstate = wxPyBeginAllowThreads();
48230 {
48231 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
48232 result = (wxArrayInt *) &_result_ref;
48233 }
48234 wxPyEndAllowThreads(__tstate);
48235 if (PyErr_Occurred()) SWIG_fail;
48236 }
48237 {
48238 resultobj = PyList_New(0);
48239 size_t idx;
48240 for (idx = 0; idx < result->GetCount(); idx += 1) {
48241 PyObject* val = PyInt_FromLong( result->Item(idx) );
48242 PyList_Append(resultobj, val);
48243 Py_DECREF(val);
48244 }
48245 }
48246 return resultobj;
48247 fail:
48248 return NULL;
48249 }
48250
48251
48252 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48253 PyObject *resultobj = 0;
48254 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48255 wxArrayInt *result = 0 ;
48256 void *argp1 = 0 ;
48257 int res1 = 0 ;
48258 PyObject *swig_obj[1] ;
48259
48260 if (!args) SWIG_fail;
48261 swig_obj[0] = args;
48262 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48263 if (!SWIG_IsOK(res1)) {
48264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48265 }
48266 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48267 {
48268 PyThreadState* __tstate = wxPyBeginAllowThreads();
48269 {
48270 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
48271 result = (wxArrayInt *) &_result_ref;
48272 }
48273 wxPyEndAllowThreads(__tstate);
48274 if (PyErr_Occurred()) SWIG_fail;
48275 }
48276 {
48277 resultobj = PyList_New(0);
48278 size_t idx;
48279 for (idx = 0; idx < result->GetCount(); idx += 1) {
48280 PyObject* val = PyInt_FromLong( result->Item(idx) );
48281 PyList_Append(resultobj, val);
48282 Py_DECREF(val);
48283 }
48284 }
48285 return resultobj;
48286 fail:
48287 return NULL;
48288 }
48289
48290
48291 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48292 PyObject *obj;
48293 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48294 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
48295 return SWIG_Py_Void();
48296 }
48297
48298 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48299 return SWIG_Python_InitShadowInstance(args);
48300 }
48301
48302 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48303 PyObject *resultobj = 0;
48304 wxStdDialogButtonSizer *result = 0 ;
48305
48306 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
48307 {
48308 PyThreadState* __tstate = wxPyBeginAllowThreads();
48309 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
48310 wxPyEndAllowThreads(__tstate);
48311 if (PyErr_Occurred()) SWIG_fail;
48312 }
48313 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
48314 return resultobj;
48315 fail:
48316 return NULL;
48317 }
48318
48319
48320 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48321 PyObject *resultobj = 0;
48322 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48323 wxButton *arg2 = (wxButton *) 0 ;
48324 void *argp1 = 0 ;
48325 int res1 = 0 ;
48326 void *argp2 = 0 ;
48327 int res2 = 0 ;
48328 PyObject * obj0 = 0 ;
48329 PyObject * obj1 = 0 ;
48330 char * kwnames[] = {
48331 (char *) "self",(char *) "button", NULL
48332 };
48333
48334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
48335 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48336 if (!SWIG_IsOK(res1)) {
48337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48338 }
48339 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48340 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48341 if (!SWIG_IsOK(res2)) {
48342 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
48343 }
48344 arg2 = reinterpret_cast< wxButton * >(argp2);
48345 {
48346 PyThreadState* __tstate = wxPyBeginAllowThreads();
48347 (arg1)->AddButton(arg2);
48348 wxPyEndAllowThreads(__tstate);
48349 if (PyErr_Occurred()) SWIG_fail;
48350 }
48351 resultobj = SWIG_Py_Void();
48352 return resultobj;
48353 fail:
48354 return NULL;
48355 }
48356
48357
48358 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48359 PyObject *resultobj = 0;
48360 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48361 void *argp1 = 0 ;
48362 int res1 = 0 ;
48363 PyObject *swig_obj[1] ;
48364
48365 if (!args) SWIG_fail;
48366 swig_obj[0] = args;
48367 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48368 if (!SWIG_IsOK(res1)) {
48369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48370 }
48371 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48372 {
48373 PyThreadState* __tstate = wxPyBeginAllowThreads();
48374 (arg1)->Realize();
48375 wxPyEndAllowThreads(__tstate);
48376 if (PyErr_Occurred()) SWIG_fail;
48377 }
48378 resultobj = SWIG_Py_Void();
48379 return resultobj;
48380 fail:
48381 return NULL;
48382 }
48383
48384
48385 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48386 PyObject *resultobj = 0;
48387 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48388 wxButton *arg2 = (wxButton *) 0 ;
48389 void *argp1 = 0 ;
48390 int res1 = 0 ;
48391 void *argp2 = 0 ;
48392 int res2 = 0 ;
48393 PyObject * obj0 = 0 ;
48394 PyObject * obj1 = 0 ;
48395 char * kwnames[] = {
48396 (char *) "self",(char *) "button", NULL
48397 };
48398
48399 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48400 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48401 if (!SWIG_IsOK(res1)) {
48402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48403 }
48404 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48405 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48406 if (!SWIG_IsOK(res2)) {
48407 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48408 }
48409 arg2 = reinterpret_cast< wxButton * >(argp2);
48410 {
48411 PyThreadState* __tstate = wxPyBeginAllowThreads();
48412 (arg1)->SetAffirmativeButton(arg2);
48413 wxPyEndAllowThreads(__tstate);
48414 if (PyErr_Occurred()) SWIG_fail;
48415 }
48416 resultobj = SWIG_Py_Void();
48417 return resultobj;
48418 fail:
48419 return NULL;
48420 }
48421
48422
48423 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48424 PyObject *resultobj = 0;
48425 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48426 wxButton *arg2 = (wxButton *) 0 ;
48427 void *argp1 = 0 ;
48428 int res1 = 0 ;
48429 void *argp2 = 0 ;
48430 int res2 = 0 ;
48431 PyObject * obj0 = 0 ;
48432 PyObject * obj1 = 0 ;
48433 char * kwnames[] = {
48434 (char *) "self",(char *) "button", NULL
48435 };
48436
48437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48438 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48439 if (!SWIG_IsOK(res1)) {
48440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48441 }
48442 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48443 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48444 if (!SWIG_IsOK(res2)) {
48445 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48446 }
48447 arg2 = reinterpret_cast< wxButton * >(argp2);
48448 {
48449 PyThreadState* __tstate = wxPyBeginAllowThreads();
48450 (arg1)->SetNegativeButton(arg2);
48451 wxPyEndAllowThreads(__tstate);
48452 if (PyErr_Occurred()) SWIG_fail;
48453 }
48454 resultobj = SWIG_Py_Void();
48455 return resultobj;
48456 fail:
48457 return NULL;
48458 }
48459
48460
48461 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48462 PyObject *resultobj = 0;
48463 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48464 wxButton *arg2 = (wxButton *) 0 ;
48465 void *argp1 = 0 ;
48466 int res1 = 0 ;
48467 void *argp2 = 0 ;
48468 int res2 = 0 ;
48469 PyObject * obj0 = 0 ;
48470 PyObject * obj1 = 0 ;
48471 char * kwnames[] = {
48472 (char *) "self",(char *) "button", NULL
48473 };
48474
48475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
48476 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48477 if (!SWIG_IsOK(res1)) {
48478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48479 }
48480 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48481 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48482 if (!SWIG_IsOK(res2)) {
48483 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
48484 }
48485 arg2 = reinterpret_cast< wxButton * >(argp2);
48486 {
48487 PyThreadState* __tstate = wxPyBeginAllowThreads();
48488 (arg1)->SetCancelButton(arg2);
48489 wxPyEndAllowThreads(__tstate);
48490 if (PyErr_Occurred()) SWIG_fail;
48491 }
48492 resultobj = SWIG_Py_Void();
48493 return resultobj;
48494 fail:
48495 return NULL;
48496 }
48497
48498
48499 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48500 PyObject *resultobj = 0;
48501 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48502 wxButton *result = 0 ;
48503 void *argp1 = 0 ;
48504 int res1 = 0 ;
48505 PyObject *swig_obj[1] ;
48506
48507 if (!args) SWIG_fail;
48508 swig_obj[0] = args;
48509 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48510 if (!SWIG_IsOK(res1)) {
48511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48512 }
48513 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48514 {
48515 PyThreadState* __tstate = wxPyBeginAllowThreads();
48516 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
48517 wxPyEndAllowThreads(__tstate);
48518 if (PyErr_Occurred()) SWIG_fail;
48519 }
48520 {
48521 resultobj = wxPyMake_wxObject(result, (bool)0);
48522 }
48523 return resultobj;
48524 fail:
48525 return NULL;
48526 }
48527
48528
48529 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48530 PyObject *resultobj = 0;
48531 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48532 wxButton *result = 0 ;
48533 void *argp1 = 0 ;
48534 int res1 = 0 ;
48535 PyObject *swig_obj[1] ;
48536
48537 if (!args) SWIG_fail;
48538 swig_obj[0] = args;
48539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48540 if (!SWIG_IsOK(res1)) {
48541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48542 }
48543 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48544 {
48545 PyThreadState* __tstate = wxPyBeginAllowThreads();
48546 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
48547 wxPyEndAllowThreads(__tstate);
48548 if (PyErr_Occurred()) SWIG_fail;
48549 }
48550 {
48551 resultobj = wxPyMake_wxObject(result, (bool)0);
48552 }
48553 return resultobj;
48554 fail:
48555 return NULL;
48556 }
48557
48558
48559 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48560 PyObject *resultobj = 0;
48561 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48562 wxButton *result = 0 ;
48563 void *argp1 = 0 ;
48564 int res1 = 0 ;
48565 PyObject *swig_obj[1] ;
48566
48567 if (!args) SWIG_fail;
48568 swig_obj[0] = args;
48569 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48570 if (!SWIG_IsOK(res1)) {
48571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48572 }
48573 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48574 {
48575 PyThreadState* __tstate = wxPyBeginAllowThreads();
48576 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
48577 wxPyEndAllowThreads(__tstate);
48578 if (PyErr_Occurred()) SWIG_fail;
48579 }
48580 {
48581 resultobj = wxPyMake_wxObject(result, (bool)0);
48582 }
48583 return resultobj;
48584 fail:
48585 return NULL;
48586 }
48587
48588
48589 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48590 PyObject *resultobj = 0;
48591 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48592 wxButton *result = 0 ;
48593 void *argp1 = 0 ;
48594 int res1 = 0 ;
48595 PyObject *swig_obj[1] ;
48596
48597 if (!args) SWIG_fail;
48598 swig_obj[0] = args;
48599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48600 if (!SWIG_IsOK(res1)) {
48601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48602 }
48603 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48604 {
48605 PyThreadState* __tstate = wxPyBeginAllowThreads();
48606 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
48607 wxPyEndAllowThreads(__tstate);
48608 if (PyErr_Occurred()) SWIG_fail;
48609 }
48610 {
48611 resultobj = wxPyMake_wxObject(result, (bool)0);
48612 }
48613 return resultobj;
48614 fail:
48615 return NULL;
48616 }
48617
48618
48619 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48620 PyObject *resultobj = 0;
48621 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48622 wxButton *result = 0 ;
48623 void *argp1 = 0 ;
48624 int res1 = 0 ;
48625 PyObject *swig_obj[1] ;
48626
48627 if (!args) SWIG_fail;
48628 swig_obj[0] = args;
48629 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48630 if (!SWIG_IsOK(res1)) {
48631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48632 }
48633 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48634 {
48635 PyThreadState* __tstate = wxPyBeginAllowThreads();
48636 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
48637 wxPyEndAllowThreads(__tstate);
48638 if (PyErr_Occurred()) SWIG_fail;
48639 }
48640 {
48641 resultobj = wxPyMake_wxObject(result, (bool)0);
48642 }
48643 return resultobj;
48644 fail:
48645 return NULL;
48646 }
48647
48648
48649 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48650 PyObject *obj;
48651 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48652 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
48653 return SWIG_Py_Void();
48654 }
48655
48656 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48657 return SWIG_Python_InitShadowInstance(args);
48658 }
48659
48660 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48661 PyObject *resultobj = 0;
48662 int arg1 = (int) 0 ;
48663 int arg2 = (int) 0 ;
48664 wxGBPosition *result = 0 ;
48665 int val1 ;
48666 int ecode1 = 0 ;
48667 int val2 ;
48668 int ecode2 = 0 ;
48669 PyObject * obj0 = 0 ;
48670 PyObject * obj1 = 0 ;
48671 char * kwnames[] = {
48672 (char *) "row",(char *) "col", NULL
48673 };
48674
48675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
48676 if (obj0) {
48677 ecode1 = SWIG_AsVal_int(obj0, &val1);
48678 if (!SWIG_IsOK(ecode1)) {
48679 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
48680 }
48681 arg1 = static_cast< int >(val1);
48682 }
48683 if (obj1) {
48684 ecode2 = SWIG_AsVal_int(obj1, &val2);
48685 if (!SWIG_IsOK(ecode2)) {
48686 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
48687 }
48688 arg2 = static_cast< int >(val2);
48689 }
48690 {
48691 PyThreadState* __tstate = wxPyBeginAllowThreads();
48692 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
48693 wxPyEndAllowThreads(__tstate);
48694 if (PyErr_Occurred()) SWIG_fail;
48695 }
48696 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
48697 return resultobj;
48698 fail:
48699 return NULL;
48700 }
48701
48702
48703 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48704 PyObject *resultobj = 0;
48705 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48706 void *argp1 = 0 ;
48707 int res1 = 0 ;
48708 PyObject *swig_obj[1] ;
48709
48710 if (!args) SWIG_fail;
48711 swig_obj[0] = args;
48712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
48713 if (!SWIG_IsOK(res1)) {
48714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48715 }
48716 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48717 {
48718 PyThreadState* __tstate = wxPyBeginAllowThreads();
48719 delete arg1;
48720
48721 wxPyEndAllowThreads(__tstate);
48722 if (PyErr_Occurred()) SWIG_fail;
48723 }
48724 resultobj = SWIG_Py_Void();
48725 return resultobj;
48726 fail:
48727 return NULL;
48728 }
48729
48730
48731 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48732 PyObject *resultobj = 0;
48733 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48734 int result;
48735 void *argp1 = 0 ;
48736 int res1 = 0 ;
48737 PyObject *swig_obj[1] ;
48738
48739 if (!args) SWIG_fail;
48740 swig_obj[0] = args;
48741 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48742 if (!SWIG_IsOK(res1)) {
48743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
48744 }
48745 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48746 {
48747 PyThreadState* __tstate = wxPyBeginAllowThreads();
48748 result = (int)((wxGBPosition const *)arg1)->GetRow();
48749 wxPyEndAllowThreads(__tstate);
48750 if (PyErr_Occurred()) SWIG_fail;
48751 }
48752 resultobj = SWIG_From_int(static_cast< int >(result));
48753 return resultobj;
48754 fail:
48755 return NULL;
48756 }
48757
48758
48759 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48760 PyObject *resultobj = 0;
48761 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48762 int result;
48763 void *argp1 = 0 ;
48764 int res1 = 0 ;
48765 PyObject *swig_obj[1] ;
48766
48767 if (!args) SWIG_fail;
48768 swig_obj[0] = args;
48769 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48770 if (!SWIG_IsOK(res1)) {
48771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
48772 }
48773 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48774 {
48775 PyThreadState* __tstate = wxPyBeginAllowThreads();
48776 result = (int)((wxGBPosition const *)arg1)->GetCol();
48777 wxPyEndAllowThreads(__tstate);
48778 if (PyErr_Occurred()) SWIG_fail;
48779 }
48780 resultobj = SWIG_From_int(static_cast< int >(result));
48781 return resultobj;
48782 fail:
48783 return NULL;
48784 }
48785
48786
48787 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48788 PyObject *resultobj = 0;
48789 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48790 int arg2 ;
48791 void *argp1 = 0 ;
48792 int res1 = 0 ;
48793 int val2 ;
48794 int ecode2 = 0 ;
48795 PyObject * obj0 = 0 ;
48796 PyObject * obj1 = 0 ;
48797 char * kwnames[] = {
48798 (char *) "self",(char *) "row", NULL
48799 };
48800
48801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
48802 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48803 if (!SWIG_IsOK(res1)) {
48804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48805 }
48806 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48807 ecode2 = SWIG_AsVal_int(obj1, &val2);
48808 if (!SWIG_IsOK(ecode2)) {
48809 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
48810 }
48811 arg2 = static_cast< int >(val2);
48812 {
48813 PyThreadState* __tstate = wxPyBeginAllowThreads();
48814 (arg1)->SetRow(arg2);
48815 wxPyEndAllowThreads(__tstate);
48816 if (PyErr_Occurred()) SWIG_fail;
48817 }
48818 resultobj = SWIG_Py_Void();
48819 return resultobj;
48820 fail:
48821 return NULL;
48822 }
48823
48824
48825 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48826 PyObject *resultobj = 0;
48827 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48828 int arg2 ;
48829 void *argp1 = 0 ;
48830 int res1 = 0 ;
48831 int val2 ;
48832 int ecode2 = 0 ;
48833 PyObject * obj0 = 0 ;
48834 PyObject * obj1 = 0 ;
48835 char * kwnames[] = {
48836 (char *) "self",(char *) "col", NULL
48837 };
48838
48839 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
48840 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48841 if (!SWIG_IsOK(res1)) {
48842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48843 }
48844 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48845 ecode2 = SWIG_AsVal_int(obj1, &val2);
48846 if (!SWIG_IsOK(ecode2)) {
48847 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
48848 }
48849 arg2 = static_cast< int >(val2);
48850 {
48851 PyThreadState* __tstate = wxPyBeginAllowThreads();
48852 (arg1)->SetCol(arg2);
48853 wxPyEndAllowThreads(__tstate);
48854 if (PyErr_Occurred()) SWIG_fail;
48855 }
48856 resultobj = SWIG_Py_Void();
48857 return resultobj;
48858 fail:
48859 return NULL;
48860 }
48861
48862
48863 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48864 PyObject *resultobj = 0;
48865 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48866 PyObject *arg2 = (PyObject *) 0 ;
48867 bool result;
48868 void *argp1 = 0 ;
48869 int res1 = 0 ;
48870 PyObject * obj0 = 0 ;
48871 PyObject * obj1 = 0 ;
48872 char * kwnames[] = {
48873 (char *) "self",(char *) "other", NULL
48874 };
48875
48876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
48877 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48878 if (!SWIG_IsOK(res1)) {
48879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48880 }
48881 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48882 arg2 = obj1;
48883 {
48884 result = (bool)wxGBPosition___eq__(arg1,arg2);
48885 if (PyErr_Occurred()) SWIG_fail;
48886 }
48887 {
48888 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48889 }
48890 return resultobj;
48891 fail:
48892 return NULL;
48893 }
48894
48895
48896 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48897 PyObject *resultobj = 0;
48898 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48899 PyObject *arg2 = (PyObject *) 0 ;
48900 bool result;
48901 void *argp1 = 0 ;
48902 int res1 = 0 ;
48903 PyObject * obj0 = 0 ;
48904 PyObject * obj1 = 0 ;
48905 char * kwnames[] = {
48906 (char *) "self",(char *) "other", NULL
48907 };
48908
48909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
48910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48911 if (!SWIG_IsOK(res1)) {
48912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48913 }
48914 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48915 arg2 = obj1;
48916 {
48917 result = (bool)wxGBPosition___ne__(arg1,arg2);
48918 if (PyErr_Occurred()) SWIG_fail;
48919 }
48920 {
48921 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48922 }
48923 return resultobj;
48924 fail:
48925 return NULL;
48926 }
48927
48928
48929 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48930 PyObject *resultobj = 0;
48931 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48932 int arg2 = (int) 0 ;
48933 int arg3 = (int) 0 ;
48934 void *argp1 = 0 ;
48935 int res1 = 0 ;
48936 int val2 ;
48937 int ecode2 = 0 ;
48938 int val3 ;
48939 int ecode3 = 0 ;
48940 PyObject * obj0 = 0 ;
48941 PyObject * obj1 = 0 ;
48942 PyObject * obj2 = 0 ;
48943 char * kwnames[] = {
48944 (char *) "self",(char *) "row",(char *) "col", NULL
48945 };
48946
48947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48948 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48949 if (!SWIG_IsOK(res1)) {
48950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48951 }
48952 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48953 if (obj1) {
48954 ecode2 = SWIG_AsVal_int(obj1, &val2);
48955 if (!SWIG_IsOK(ecode2)) {
48956 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
48957 }
48958 arg2 = static_cast< int >(val2);
48959 }
48960 if (obj2) {
48961 ecode3 = SWIG_AsVal_int(obj2, &val3);
48962 if (!SWIG_IsOK(ecode3)) {
48963 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
48964 }
48965 arg3 = static_cast< int >(val3);
48966 }
48967 {
48968 PyThreadState* __tstate = wxPyBeginAllowThreads();
48969 wxGBPosition_Set(arg1,arg2,arg3);
48970 wxPyEndAllowThreads(__tstate);
48971 if (PyErr_Occurred()) SWIG_fail;
48972 }
48973 resultobj = SWIG_Py_Void();
48974 return resultobj;
48975 fail:
48976 return NULL;
48977 }
48978
48979
48980 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48981 PyObject *resultobj = 0;
48982 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48983 PyObject *result = 0 ;
48984 void *argp1 = 0 ;
48985 int res1 = 0 ;
48986 PyObject *swig_obj[1] ;
48987
48988 if (!args) SWIG_fail;
48989 swig_obj[0] = args;
48990 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48991 if (!SWIG_IsOK(res1)) {
48992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48993 }
48994 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48995 {
48996 PyThreadState* __tstate = wxPyBeginAllowThreads();
48997 result = (PyObject *)wxGBPosition_Get(arg1);
48998 wxPyEndAllowThreads(__tstate);
48999 if (PyErr_Occurred()) SWIG_fail;
49000 }
49001 resultobj = result;
49002 return resultobj;
49003 fail:
49004 return NULL;
49005 }
49006
49007
49008 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49009 PyObject *obj;
49010 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49011 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
49012 return SWIG_Py_Void();
49013 }
49014
49015 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49016 return SWIG_Python_InitShadowInstance(args);
49017 }
49018
49019 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49020 PyObject *resultobj = 0;
49021 int arg1 = (int) 1 ;
49022 int arg2 = (int) 1 ;
49023 wxGBSpan *result = 0 ;
49024 int val1 ;
49025 int ecode1 = 0 ;
49026 int val2 ;
49027 int ecode2 = 0 ;
49028 PyObject * obj0 = 0 ;
49029 PyObject * obj1 = 0 ;
49030 char * kwnames[] = {
49031 (char *) "rowspan",(char *) "colspan", NULL
49032 };
49033
49034 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
49035 if (obj0) {
49036 ecode1 = SWIG_AsVal_int(obj0, &val1);
49037 if (!SWIG_IsOK(ecode1)) {
49038 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
49039 }
49040 arg1 = static_cast< int >(val1);
49041 }
49042 if (obj1) {
49043 ecode2 = SWIG_AsVal_int(obj1, &val2);
49044 if (!SWIG_IsOK(ecode2)) {
49045 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
49046 }
49047 arg2 = static_cast< int >(val2);
49048 }
49049 {
49050 PyThreadState* __tstate = wxPyBeginAllowThreads();
49051 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
49052 wxPyEndAllowThreads(__tstate);
49053 if (PyErr_Occurred()) SWIG_fail;
49054 }
49055 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
49056 return resultobj;
49057 fail:
49058 return NULL;
49059 }
49060
49061
49062 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49063 PyObject *resultobj = 0;
49064 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49065 void *argp1 = 0 ;
49066 int res1 = 0 ;
49067 PyObject *swig_obj[1] ;
49068
49069 if (!args) SWIG_fail;
49070 swig_obj[0] = args;
49071 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
49072 if (!SWIG_IsOK(res1)) {
49073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49074 }
49075 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49076 {
49077 PyThreadState* __tstate = wxPyBeginAllowThreads();
49078 delete arg1;
49079
49080 wxPyEndAllowThreads(__tstate);
49081 if (PyErr_Occurred()) SWIG_fail;
49082 }
49083 resultobj = SWIG_Py_Void();
49084 return resultobj;
49085 fail:
49086 return NULL;
49087 }
49088
49089
49090 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49091 PyObject *resultobj = 0;
49092 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49093 int result;
49094 void *argp1 = 0 ;
49095 int res1 = 0 ;
49096 PyObject *swig_obj[1] ;
49097
49098 if (!args) SWIG_fail;
49099 swig_obj[0] = args;
49100 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49101 if (!SWIG_IsOK(res1)) {
49102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
49103 }
49104 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49105 {
49106 PyThreadState* __tstate = wxPyBeginAllowThreads();
49107 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
49108 wxPyEndAllowThreads(__tstate);
49109 if (PyErr_Occurred()) SWIG_fail;
49110 }
49111 resultobj = SWIG_From_int(static_cast< int >(result));
49112 return resultobj;
49113 fail:
49114 return NULL;
49115 }
49116
49117
49118 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49119 PyObject *resultobj = 0;
49120 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49121 int result;
49122 void *argp1 = 0 ;
49123 int res1 = 0 ;
49124 PyObject *swig_obj[1] ;
49125
49126 if (!args) SWIG_fail;
49127 swig_obj[0] = args;
49128 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49129 if (!SWIG_IsOK(res1)) {
49130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
49131 }
49132 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49133 {
49134 PyThreadState* __tstate = wxPyBeginAllowThreads();
49135 result = (int)((wxGBSpan const *)arg1)->GetColspan();
49136 wxPyEndAllowThreads(__tstate);
49137 if (PyErr_Occurred()) SWIG_fail;
49138 }
49139 resultobj = SWIG_From_int(static_cast< int >(result));
49140 return resultobj;
49141 fail:
49142 return NULL;
49143 }
49144
49145
49146 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49147 PyObject *resultobj = 0;
49148 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49149 int arg2 ;
49150 void *argp1 = 0 ;
49151 int res1 = 0 ;
49152 int val2 ;
49153 int ecode2 = 0 ;
49154 PyObject * obj0 = 0 ;
49155 PyObject * obj1 = 0 ;
49156 char * kwnames[] = {
49157 (char *) "self",(char *) "rowspan", NULL
49158 };
49159
49160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
49161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49162 if (!SWIG_IsOK(res1)) {
49163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49164 }
49165 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49166 ecode2 = SWIG_AsVal_int(obj1, &val2);
49167 if (!SWIG_IsOK(ecode2)) {
49168 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
49169 }
49170 arg2 = static_cast< int >(val2);
49171 {
49172 PyThreadState* __tstate = wxPyBeginAllowThreads();
49173 (arg1)->SetRowspan(arg2);
49174 wxPyEndAllowThreads(__tstate);
49175 if (PyErr_Occurred()) SWIG_fail;
49176 }
49177 resultobj = SWIG_Py_Void();
49178 return resultobj;
49179 fail:
49180 return NULL;
49181 }
49182
49183
49184 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49185 PyObject *resultobj = 0;
49186 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49187 int arg2 ;
49188 void *argp1 = 0 ;
49189 int res1 = 0 ;
49190 int val2 ;
49191 int ecode2 = 0 ;
49192 PyObject * obj0 = 0 ;
49193 PyObject * obj1 = 0 ;
49194 char * kwnames[] = {
49195 (char *) "self",(char *) "colspan", NULL
49196 };
49197
49198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
49199 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49200 if (!SWIG_IsOK(res1)) {
49201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49202 }
49203 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49204 ecode2 = SWIG_AsVal_int(obj1, &val2);
49205 if (!SWIG_IsOK(ecode2)) {
49206 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
49207 }
49208 arg2 = static_cast< int >(val2);
49209 {
49210 PyThreadState* __tstate = wxPyBeginAllowThreads();
49211 (arg1)->SetColspan(arg2);
49212 wxPyEndAllowThreads(__tstate);
49213 if (PyErr_Occurred()) SWIG_fail;
49214 }
49215 resultobj = SWIG_Py_Void();
49216 return resultobj;
49217 fail:
49218 return NULL;
49219 }
49220
49221
49222 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49223 PyObject *resultobj = 0;
49224 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49225 PyObject *arg2 = (PyObject *) 0 ;
49226 bool result;
49227 void *argp1 = 0 ;
49228 int res1 = 0 ;
49229 PyObject * obj0 = 0 ;
49230 PyObject * obj1 = 0 ;
49231 char * kwnames[] = {
49232 (char *) "self",(char *) "other", NULL
49233 };
49234
49235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
49236 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49237 if (!SWIG_IsOK(res1)) {
49238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49239 }
49240 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49241 arg2 = obj1;
49242 {
49243 result = (bool)wxGBSpan___eq__(arg1,arg2);
49244 if (PyErr_Occurred()) SWIG_fail;
49245 }
49246 {
49247 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49248 }
49249 return resultobj;
49250 fail:
49251 return NULL;
49252 }
49253
49254
49255 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49256 PyObject *resultobj = 0;
49257 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49258 PyObject *arg2 = (PyObject *) 0 ;
49259 bool result;
49260 void *argp1 = 0 ;
49261 int res1 = 0 ;
49262 PyObject * obj0 = 0 ;
49263 PyObject * obj1 = 0 ;
49264 char * kwnames[] = {
49265 (char *) "self",(char *) "other", NULL
49266 };
49267
49268 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
49269 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49270 if (!SWIG_IsOK(res1)) {
49271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49272 }
49273 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49274 arg2 = obj1;
49275 {
49276 result = (bool)wxGBSpan___ne__(arg1,arg2);
49277 if (PyErr_Occurred()) SWIG_fail;
49278 }
49279 {
49280 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49281 }
49282 return resultobj;
49283 fail:
49284 return NULL;
49285 }
49286
49287
49288 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49289 PyObject *resultobj = 0;
49290 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49291 int arg2 = (int) 1 ;
49292 int arg3 = (int) 1 ;
49293 void *argp1 = 0 ;
49294 int res1 = 0 ;
49295 int val2 ;
49296 int ecode2 = 0 ;
49297 int val3 ;
49298 int ecode3 = 0 ;
49299 PyObject * obj0 = 0 ;
49300 PyObject * obj1 = 0 ;
49301 PyObject * obj2 = 0 ;
49302 char * kwnames[] = {
49303 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
49304 };
49305
49306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49307 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49308 if (!SWIG_IsOK(res1)) {
49309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49310 }
49311 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49312 if (obj1) {
49313 ecode2 = SWIG_AsVal_int(obj1, &val2);
49314 if (!SWIG_IsOK(ecode2)) {
49315 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
49316 }
49317 arg2 = static_cast< int >(val2);
49318 }
49319 if (obj2) {
49320 ecode3 = SWIG_AsVal_int(obj2, &val3);
49321 if (!SWIG_IsOK(ecode3)) {
49322 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
49323 }
49324 arg3 = static_cast< int >(val3);
49325 }
49326 {
49327 PyThreadState* __tstate = wxPyBeginAllowThreads();
49328 wxGBSpan_Set(arg1,arg2,arg3);
49329 wxPyEndAllowThreads(__tstate);
49330 if (PyErr_Occurred()) SWIG_fail;
49331 }
49332 resultobj = SWIG_Py_Void();
49333 return resultobj;
49334 fail:
49335 return NULL;
49336 }
49337
49338
49339 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49340 PyObject *resultobj = 0;
49341 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49342 PyObject *result = 0 ;
49343 void *argp1 = 0 ;
49344 int res1 = 0 ;
49345 PyObject *swig_obj[1] ;
49346
49347 if (!args) SWIG_fail;
49348 swig_obj[0] = args;
49349 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49350 if (!SWIG_IsOK(res1)) {
49351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49352 }
49353 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49354 {
49355 PyThreadState* __tstate = wxPyBeginAllowThreads();
49356 result = (PyObject *)wxGBSpan_Get(arg1);
49357 wxPyEndAllowThreads(__tstate);
49358 if (PyErr_Occurred()) SWIG_fail;
49359 }
49360 resultobj = result;
49361 return resultobj;
49362 fail:
49363 return NULL;
49364 }
49365
49366
49367 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49368 PyObject *obj;
49369 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49370 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
49371 return SWIG_Py_Void();
49372 }
49373
49374 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49375 return SWIG_Python_InitShadowInstance(args);
49376 }
49377
49378 SWIGINTERN int DefaultSpan_set(PyObject *) {
49379 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
49380 return 1;
49381 }
49382
49383
49384 SWIGINTERN PyObject *DefaultSpan_get(void) {
49385 PyObject *pyobj = 0;
49386
49387 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
49388 return pyobj;
49389 }
49390
49391
49392 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49393 PyObject *resultobj = 0;
49394 wxGBSizerItem *result = 0 ;
49395
49396 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
49397 {
49398 PyThreadState* __tstate = wxPyBeginAllowThreads();
49399 result = (wxGBSizerItem *)new wxGBSizerItem();
49400 wxPyEndAllowThreads(__tstate);
49401 if (PyErr_Occurred()) SWIG_fail;
49402 }
49403 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
49404 return resultobj;
49405 fail:
49406 return NULL;
49407 }
49408
49409
49410 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49411 PyObject *resultobj = 0;
49412 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49413 void *argp1 = 0 ;
49414 int res1 = 0 ;
49415 PyObject *swig_obj[1] ;
49416
49417 if (!args) SWIG_fail;
49418 swig_obj[0] = args;
49419 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
49420 if (!SWIG_IsOK(res1)) {
49421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49422 }
49423 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49424 {
49425 PyThreadState* __tstate = wxPyBeginAllowThreads();
49426 delete arg1;
49427
49428 wxPyEndAllowThreads(__tstate);
49429 if (PyErr_Occurred()) SWIG_fail;
49430 }
49431 resultobj = SWIG_Py_Void();
49432 return resultobj;
49433 fail:
49434 return NULL;
49435 }
49436
49437
49438 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49439 PyObject *resultobj = 0;
49440 wxWindow *arg1 = (wxWindow *) 0 ;
49441 wxGBPosition *arg2 = 0 ;
49442 wxGBSpan *arg3 = 0 ;
49443 int arg4 ;
49444 int arg5 ;
49445 PyObject *arg6 = (PyObject *) NULL ;
49446 wxGBSizerItem *result = 0 ;
49447 void *argp1 = 0 ;
49448 int res1 = 0 ;
49449 wxGBPosition temp2 ;
49450 wxGBSpan temp3 ;
49451 int val4 ;
49452 int ecode4 = 0 ;
49453 int val5 ;
49454 int ecode5 = 0 ;
49455 PyObject * obj0 = 0 ;
49456 PyObject * obj1 = 0 ;
49457 PyObject * obj2 = 0 ;
49458 PyObject * obj3 = 0 ;
49459 PyObject * obj4 = 0 ;
49460 PyObject * obj5 = 0 ;
49461 char * kwnames[] = {
49462 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49463 };
49464
49465 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49466 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
49467 if (!SWIG_IsOK(res1)) {
49468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
49469 }
49470 arg1 = reinterpret_cast< wxWindow * >(argp1);
49471 {
49472 arg2 = &temp2;
49473 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49474 }
49475 {
49476 arg3 = &temp3;
49477 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49478 }
49479 ecode4 = SWIG_AsVal_int(obj3, &val4);
49480 if (!SWIG_IsOK(ecode4)) {
49481 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
49482 }
49483 arg4 = static_cast< int >(val4);
49484 ecode5 = SWIG_AsVal_int(obj4, &val5);
49485 if (!SWIG_IsOK(ecode5)) {
49486 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
49487 }
49488 arg5 = static_cast< int >(val5);
49489 if (obj5) {
49490 arg6 = obj5;
49491 }
49492 {
49493 PyThreadState* __tstate = wxPyBeginAllowThreads();
49494 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
49495 wxPyEndAllowThreads(__tstate);
49496 if (PyErr_Occurred()) SWIG_fail;
49497 }
49498 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49499 return resultobj;
49500 fail:
49501 return NULL;
49502 }
49503
49504
49505 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49506 PyObject *resultobj = 0;
49507 wxSizer *arg1 = (wxSizer *) 0 ;
49508 wxGBPosition *arg2 = 0 ;
49509 wxGBSpan *arg3 = 0 ;
49510 int arg4 ;
49511 int arg5 ;
49512 PyObject *arg6 = (PyObject *) NULL ;
49513 wxGBSizerItem *result = 0 ;
49514 int res1 = 0 ;
49515 wxGBPosition temp2 ;
49516 wxGBSpan temp3 ;
49517 int val4 ;
49518 int ecode4 = 0 ;
49519 int val5 ;
49520 int ecode5 = 0 ;
49521 PyObject * obj0 = 0 ;
49522 PyObject * obj1 = 0 ;
49523 PyObject * obj2 = 0 ;
49524 PyObject * obj3 = 0 ;
49525 PyObject * obj4 = 0 ;
49526 PyObject * obj5 = 0 ;
49527 char * kwnames[] = {
49528 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49529 };
49530
49531 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49532 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49533 if (!SWIG_IsOK(res1)) {
49534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
49535 }
49536 {
49537 arg2 = &temp2;
49538 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49539 }
49540 {
49541 arg3 = &temp3;
49542 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49543 }
49544 ecode4 = SWIG_AsVal_int(obj3, &val4);
49545 if (!SWIG_IsOK(ecode4)) {
49546 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
49547 }
49548 arg4 = static_cast< int >(val4);
49549 ecode5 = SWIG_AsVal_int(obj4, &val5);
49550 if (!SWIG_IsOK(ecode5)) {
49551 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
49552 }
49553 arg5 = static_cast< int >(val5);
49554 if (obj5) {
49555 arg6 = obj5;
49556 }
49557 {
49558 PyThreadState* __tstate = wxPyBeginAllowThreads();
49559 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
49560 wxPyEndAllowThreads(__tstate);
49561 if (PyErr_Occurred()) SWIG_fail;
49562 }
49563 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49564 return resultobj;
49565 fail:
49566 return NULL;
49567 }
49568
49569
49570 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49571 PyObject *resultobj = 0;
49572 int arg1 ;
49573 int arg2 ;
49574 wxGBPosition *arg3 = 0 ;
49575 wxGBSpan *arg4 = 0 ;
49576 int arg5 ;
49577 int arg6 ;
49578 PyObject *arg7 = (PyObject *) NULL ;
49579 wxGBSizerItem *result = 0 ;
49580 int val1 ;
49581 int ecode1 = 0 ;
49582 int val2 ;
49583 int ecode2 = 0 ;
49584 wxGBPosition temp3 ;
49585 wxGBSpan temp4 ;
49586 int val5 ;
49587 int ecode5 = 0 ;
49588 int val6 ;
49589 int ecode6 = 0 ;
49590 PyObject * obj0 = 0 ;
49591 PyObject * obj1 = 0 ;
49592 PyObject * obj2 = 0 ;
49593 PyObject * obj3 = 0 ;
49594 PyObject * obj4 = 0 ;
49595 PyObject * obj5 = 0 ;
49596 PyObject * obj6 = 0 ;
49597 char * kwnames[] = {
49598 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49599 };
49600
49601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
49602 ecode1 = SWIG_AsVal_int(obj0, &val1);
49603 if (!SWIG_IsOK(ecode1)) {
49604 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
49605 }
49606 arg1 = static_cast< int >(val1);
49607 ecode2 = SWIG_AsVal_int(obj1, &val2);
49608 if (!SWIG_IsOK(ecode2)) {
49609 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
49610 }
49611 arg2 = static_cast< int >(val2);
49612 {
49613 arg3 = &temp3;
49614 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
49615 }
49616 {
49617 arg4 = &temp4;
49618 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
49619 }
49620 ecode5 = SWIG_AsVal_int(obj4, &val5);
49621 if (!SWIG_IsOK(ecode5)) {
49622 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
49623 }
49624 arg5 = static_cast< int >(val5);
49625 ecode6 = SWIG_AsVal_int(obj5, &val6);
49626 if (!SWIG_IsOK(ecode6)) {
49627 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
49628 }
49629 arg6 = static_cast< int >(val6);
49630 if (obj6) {
49631 arg7 = obj6;
49632 }
49633 {
49634 PyThreadState* __tstate = wxPyBeginAllowThreads();
49635 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
49636 wxPyEndAllowThreads(__tstate);
49637 if (PyErr_Occurred()) SWIG_fail;
49638 }
49639 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49640 return resultobj;
49641 fail:
49642 return NULL;
49643 }
49644
49645
49646 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49647 PyObject *resultobj = 0;
49648 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49649 wxGBPosition result;
49650 void *argp1 = 0 ;
49651 int res1 = 0 ;
49652 PyObject *swig_obj[1] ;
49653
49654 if (!args) SWIG_fail;
49655 swig_obj[0] = args;
49656 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49657 if (!SWIG_IsOK(res1)) {
49658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49659 }
49660 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49661 {
49662 PyThreadState* __tstate = wxPyBeginAllowThreads();
49663 result = ((wxGBSizerItem const *)arg1)->GetPos();
49664 wxPyEndAllowThreads(__tstate);
49665 if (PyErr_Occurred()) SWIG_fail;
49666 }
49667 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
49668 return resultobj;
49669 fail:
49670 return NULL;
49671 }
49672
49673
49674 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49675 PyObject *resultobj = 0;
49676 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49677 wxGBSpan result;
49678 void *argp1 = 0 ;
49679 int res1 = 0 ;
49680 PyObject *swig_obj[1] ;
49681
49682 if (!args) SWIG_fail;
49683 swig_obj[0] = args;
49684 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49685 if (!SWIG_IsOK(res1)) {
49686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49687 }
49688 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49689 {
49690 PyThreadState* __tstate = wxPyBeginAllowThreads();
49691 result = ((wxGBSizerItem const *)arg1)->GetSpan();
49692 wxPyEndAllowThreads(__tstate);
49693 if (PyErr_Occurred()) SWIG_fail;
49694 }
49695 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
49696 return resultobj;
49697 fail:
49698 return NULL;
49699 }
49700
49701
49702 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49703 PyObject *resultobj = 0;
49704 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49705 wxGBPosition *arg2 = 0 ;
49706 bool result;
49707 void *argp1 = 0 ;
49708 int res1 = 0 ;
49709 wxGBPosition temp2 ;
49710 PyObject * obj0 = 0 ;
49711 PyObject * obj1 = 0 ;
49712 char * kwnames[] = {
49713 (char *) "self",(char *) "pos", NULL
49714 };
49715
49716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
49717 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49718 if (!SWIG_IsOK(res1)) {
49719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49720 }
49721 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49722 {
49723 arg2 = &temp2;
49724 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49725 }
49726 {
49727 PyThreadState* __tstate = wxPyBeginAllowThreads();
49728 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
49729 wxPyEndAllowThreads(__tstate);
49730 if (PyErr_Occurred()) SWIG_fail;
49731 }
49732 {
49733 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49734 }
49735 return resultobj;
49736 fail:
49737 return NULL;
49738 }
49739
49740
49741 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49742 PyObject *resultobj = 0;
49743 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49744 wxGBSpan *arg2 = 0 ;
49745 bool result;
49746 void *argp1 = 0 ;
49747 int res1 = 0 ;
49748 wxGBSpan temp2 ;
49749 PyObject * obj0 = 0 ;
49750 PyObject * obj1 = 0 ;
49751 char * kwnames[] = {
49752 (char *) "self",(char *) "span", NULL
49753 };
49754
49755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
49756 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49757 if (!SWIG_IsOK(res1)) {
49758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49759 }
49760 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49761 {
49762 arg2 = &temp2;
49763 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
49764 }
49765 {
49766 PyThreadState* __tstate = wxPyBeginAllowThreads();
49767 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
49768 wxPyEndAllowThreads(__tstate);
49769 if (PyErr_Occurred()) SWIG_fail;
49770 }
49771 {
49772 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49773 }
49774 return resultobj;
49775 fail:
49776 return NULL;
49777 }
49778
49779
49780 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49781 PyObject *resultobj = 0;
49782 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49783 wxGBSizerItem *arg2 = 0 ;
49784 bool result;
49785 void *argp1 = 0 ;
49786 int res1 = 0 ;
49787 void *argp2 = 0 ;
49788 int res2 = 0 ;
49789 PyObject * obj0 = 0 ;
49790 PyObject * obj1 = 0 ;
49791 char * kwnames[] = {
49792 (char *) "self",(char *) "other", NULL
49793 };
49794
49795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
49796 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49797 if (!SWIG_IsOK(res1)) {
49798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49799 }
49800 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49801 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
49802 if (!SWIG_IsOK(res2)) {
49803 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
49804 }
49805 if (!argp2) {
49806 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
49807 }
49808 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
49809 {
49810 PyThreadState* __tstate = wxPyBeginAllowThreads();
49811 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
49812 wxPyEndAllowThreads(__tstate);
49813 if (PyErr_Occurred()) SWIG_fail;
49814 }
49815 {
49816 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49817 }
49818 return resultobj;
49819 fail:
49820 return NULL;
49821 }
49822
49823
49824 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49825 PyObject *resultobj = 0;
49826 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49827 wxGBPosition *arg2 = 0 ;
49828 wxGBSpan *arg3 = 0 ;
49829 bool result;
49830 void *argp1 = 0 ;
49831 int res1 = 0 ;
49832 wxGBPosition temp2 ;
49833 wxGBSpan temp3 ;
49834 PyObject * obj0 = 0 ;
49835 PyObject * obj1 = 0 ;
49836 PyObject * obj2 = 0 ;
49837 char * kwnames[] = {
49838 (char *) "self",(char *) "pos",(char *) "span", NULL
49839 };
49840
49841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49842 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49843 if (!SWIG_IsOK(res1)) {
49844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49845 }
49846 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49847 {
49848 arg2 = &temp2;
49849 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49850 }
49851 {
49852 arg3 = &temp3;
49853 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49854 }
49855 {
49856 PyThreadState* __tstate = wxPyBeginAllowThreads();
49857 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
49858 wxPyEndAllowThreads(__tstate);
49859 if (PyErr_Occurred()) SWIG_fail;
49860 }
49861 {
49862 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49863 }
49864 return resultobj;
49865 fail:
49866 return NULL;
49867 }
49868
49869
49870 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49871 PyObject *resultobj = 0;
49872 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49873 wxGBPosition result;
49874 void *argp1 = 0 ;
49875 int res1 = 0 ;
49876 PyObject *swig_obj[1] ;
49877
49878 if (!args) SWIG_fail;
49879 swig_obj[0] = args;
49880 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49881 if (!SWIG_IsOK(res1)) {
49882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49883 }
49884 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49885 {
49886 PyThreadState* __tstate = wxPyBeginAllowThreads();
49887 result = wxGBSizerItem_GetEndPos(arg1);
49888 wxPyEndAllowThreads(__tstate);
49889 if (PyErr_Occurred()) SWIG_fail;
49890 }
49891 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
49892 return resultobj;
49893 fail:
49894 return NULL;
49895 }
49896
49897
49898 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49899 PyObject *resultobj = 0;
49900 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49901 wxGridBagSizer *result = 0 ;
49902 void *argp1 = 0 ;
49903 int res1 = 0 ;
49904 PyObject *swig_obj[1] ;
49905
49906 if (!args) SWIG_fail;
49907 swig_obj[0] = args;
49908 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49909 if (!SWIG_IsOK(res1)) {
49910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49911 }
49912 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49913 {
49914 PyThreadState* __tstate = wxPyBeginAllowThreads();
49915 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
49916 wxPyEndAllowThreads(__tstate);
49917 if (PyErr_Occurred()) SWIG_fail;
49918 }
49919 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49920 return resultobj;
49921 fail:
49922 return NULL;
49923 }
49924
49925
49926 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49927 PyObject *resultobj = 0;
49928 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49929 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
49930 void *argp1 = 0 ;
49931 int res1 = 0 ;
49932 void *argp2 = 0 ;
49933 int res2 = 0 ;
49934 PyObject * obj0 = 0 ;
49935 PyObject * obj1 = 0 ;
49936 char * kwnames[] = {
49937 (char *) "self",(char *) "sizer", NULL
49938 };
49939
49940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
49941 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49942 if (!SWIG_IsOK(res1)) {
49943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49944 }
49945 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49946 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49947 if (!SWIG_IsOK(res2)) {
49948 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
49949 }
49950 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
49951 {
49952 PyThreadState* __tstate = wxPyBeginAllowThreads();
49953 (arg1)->SetGBSizer(arg2);
49954 wxPyEndAllowThreads(__tstate);
49955 if (PyErr_Occurred()) SWIG_fail;
49956 }
49957 resultobj = SWIG_Py_Void();
49958 return resultobj;
49959 fail:
49960 return NULL;
49961 }
49962
49963
49964 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49965 PyObject *obj;
49966 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49967 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
49968 return SWIG_Py_Void();
49969 }
49970
49971 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49972 return SWIG_Python_InitShadowInstance(args);
49973 }
49974
49975 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49976 PyObject *resultobj = 0;
49977 int arg1 = (int) 0 ;
49978 int arg2 = (int) 0 ;
49979 wxGridBagSizer *result = 0 ;
49980 int val1 ;
49981 int ecode1 = 0 ;
49982 int val2 ;
49983 int ecode2 = 0 ;
49984 PyObject * obj0 = 0 ;
49985 PyObject * obj1 = 0 ;
49986 char * kwnames[] = {
49987 (char *) "vgap",(char *) "hgap", NULL
49988 };
49989
49990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
49991 if (obj0) {
49992 ecode1 = SWIG_AsVal_int(obj0, &val1);
49993 if (!SWIG_IsOK(ecode1)) {
49994 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
49995 }
49996 arg1 = static_cast< int >(val1);
49997 }
49998 if (obj1) {
49999 ecode2 = SWIG_AsVal_int(obj1, &val2);
50000 if (!SWIG_IsOK(ecode2)) {
50001 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
50002 }
50003 arg2 = static_cast< int >(val2);
50004 }
50005 {
50006 PyThreadState* __tstate = wxPyBeginAllowThreads();
50007 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
50008 wxPyEndAllowThreads(__tstate);
50009 if (PyErr_Occurred()) SWIG_fail;
50010 }
50011 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
50012 return resultobj;
50013 fail:
50014 return NULL;
50015 }
50016
50017
50018 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50019 PyObject *resultobj = 0;
50020 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50021 PyObject *arg2 = (PyObject *) 0 ;
50022 wxGBPosition *arg3 = 0 ;
50023 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
50024 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
50025 int arg5 = (int) 0 ;
50026 int arg6 = (int) 0 ;
50027 PyObject *arg7 = (PyObject *) NULL ;
50028 wxGBSizerItem *result = 0 ;
50029 void *argp1 = 0 ;
50030 int res1 = 0 ;
50031 wxGBPosition temp3 ;
50032 wxGBSpan temp4 ;
50033 int val5 ;
50034 int ecode5 = 0 ;
50035 int val6 ;
50036 int ecode6 = 0 ;
50037 PyObject * obj0 = 0 ;
50038 PyObject * obj1 = 0 ;
50039 PyObject * obj2 = 0 ;
50040 PyObject * obj3 = 0 ;
50041 PyObject * obj4 = 0 ;
50042 PyObject * obj5 = 0 ;
50043 PyObject * obj6 = 0 ;
50044 char * kwnames[] = {
50045 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50046 };
50047
50048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
50049 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50050 if (!SWIG_IsOK(res1)) {
50051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50052 }
50053 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50054 arg2 = obj1;
50055 {
50056 arg3 = &temp3;
50057 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
50058 }
50059 if (obj3) {
50060 {
50061 arg4 = &temp4;
50062 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
50063 }
50064 }
50065 if (obj4) {
50066 ecode5 = SWIG_AsVal_int(obj4, &val5);
50067 if (!SWIG_IsOK(ecode5)) {
50068 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
50069 }
50070 arg5 = static_cast< int >(val5);
50071 }
50072 if (obj5) {
50073 ecode6 = SWIG_AsVal_int(obj5, &val6);
50074 if (!SWIG_IsOK(ecode6)) {
50075 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
50076 }
50077 arg6 = static_cast< int >(val6);
50078 }
50079 if (obj6) {
50080 arg7 = obj6;
50081 }
50082 {
50083 PyThreadState* __tstate = wxPyBeginAllowThreads();
50084 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
50085 wxPyEndAllowThreads(__tstate);
50086 if (PyErr_Occurred()) SWIG_fail;
50087 }
50088 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50089 return resultobj;
50090 fail:
50091 return NULL;
50092 }
50093
50094
50095 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50096 PyObject *resultobj = 0;
50097 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50098 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
50099 wxGBSizerItem *result = 0 ;
50100 void *argp1 = 0 ;
50101 int res1 = 0 ;
50102 int res2 = 0 ;
50103 PyObject * obj0 = 0 ;
50104 PyObject * obj1 = 0 ;
50105 char * kwnames[] = {
50106 (char *) "self",(char *) "item", NULL
50107 };
50108
50109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
50110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50111 if (!SWIG_IsOK(res1)) {
50112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50113 }
50114 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50115 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
50116 if (!SWIG_IsOK(res2)) {
50117 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
50118 }
50119 {
50120 PyThreadState* __tstate = wxPyBeginAllowThreads();
50121 result = (wxGBSizerItem *)(arg1)->Add(arg2);
50122 wxPyEndAllowThreads(__tstate);
50123 if (PyErr_Occurred()) SWIG_fail;
50124 }
50125 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50126 return resultobj;
50127 fail:
50128 return NULL;
50129 }
50130
50131
50132 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50133 PyObject *resultobj = 0;
50134 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50135 int arg2 ;
50136 int arg3 ;
50137 wxSize result;
50138 void *argp1 = 0 ;
50139 int res1 = 0 ;
50140 int val2 ;
50141 int ecode2 = 0 ;
50142 int val3 ;
50143 int ecode3 = 0 ;
50144 PyObject * obj0 = 0 ;
50145 PyObject * obj1 = 0 ;
50146 PyObject * obj2 = 0 ;
50147 char * kwnames[] = {
50148 (char *) "self",(char *) "row",(char *) "col", NULL
50149 };
50150
50151 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50152 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50153 if (!SWIG_IsOK(res1)) {
50154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
50155 }
50156 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50157 ecode2 = SWIG_AsVal_int(obj1, &val2);
50158 if (!SWIG_IsOK(ecode2)) {
50159 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
50160 }
50161 arg2 = static_cast< int >(val2);
50162 ecode3 = SWIG_AsVal_int(obj2, &val3);
50163 if (!SWIG_IsOK(ecode3)) {
50164 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
50165 }
50166 arg3 = static_cast< int >(val3);
50167 {
50168 PyThreadState* __tstate = wxPyBeginAllowThreads();
50169 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
50170 wxPyEndAllowThreads(__tstate);
50171 if (PyErr_Occurred()) SWIG_fail;
50172 }
50173 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50174 return resultobj;
50175 fail:
50176 return NULL;
50177 }
50178
50179
50180 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50181 PyObject *resultobj = 0;
50182 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50183 wxSize result;
50184 void *argp1 = 0 ;
50185 int res1 = 0 ;
50186 PyObject *swig_obj[1] ;
50187
50188 if (!args) SWIG_fail;
50189 swig_obj[0] = args;
50190 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50191 if (!SWIG_IsOK(res1)) {
50192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
50193 }
50194 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50195 {
50196 PyThreadState* __tstate = wxPyBeginAllowThreads();
50197 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
50198 wxPyEndAllowThreads(__tstate);
50199 if (PyErr_Occurred()) SWIG_fail;
50200 }
50201 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50202 return resultobj;
50203 fail:
50204 return NULL;
50205 }
50206
50207
50208 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50209 PyObject *resultobj = 0;
50210 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50211 wxSize *arg2 = 0 ;
50212 void *argp1 = 0 ;
50213 int res1 = 0 ;
50214 wxSize temp2 ;
50215 PyObject * obj0 = 0 ;
50216 PyObject * obj1 = 0 ;
50217 char * kwnames[] = {
50218 (char *) "self",(char *) "sz", NULL
50219 };
50220
50221 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
50222 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50223 if (!SWIG_IsOK(res1)) {
50224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50225 }
50226 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50227 {
50228 arg2 = &temp2;
50229 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50230 }
50231 {
50232 PyThreadState* __tstate = wxPyBeginAllowThreads();
50233 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
50234 wxPyEndAllowThreads(__tstate);
50235 if (PyErr_Occurred()) SWIG_fail;
50236 }
50237 resultobj = SWIG_Py_Void();
50238 return resultobj;
50239 fail:
50240 return NULL;
50241 }
50242
50243
50244 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50245 PyObject *resultobj = 0;
50246 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50247 wxWindow *arg2 = (wxWindow *) 0 ;
50248 wxGBPosition result;
50249 void *argp1 = 0 ;
50250 int res1 = 0 ;
50251 void *argp2 = 0 ;
50252 int res2 = 0 ;
50253
50254 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50255 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50256 if (!SWIG_IsOK(res1)) {
50257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50258 }
50259 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50260 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50261 if (!SWIG_IsOK(res2)) {
50262 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50263 }
50264 arg2 = reinterpret_cast< wxWindow * >(argp2);
50265 {
50266 PyThreadState* __tstate = wxPyBeginAllowThreads();
50267 result = (arg1)->GetItemPosition(arg2);
50268 wxPyEndAllowThreads(__tstate);
50269 if (PyErr_Occurred()) SWIG_fail;
50270 }
50271 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50272 return resultobj;
50273 fail:
50274 return NULL;
50275 }
50276
50277
50278 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50279 PyObject *resultobj = 0;
50280 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50281 wxSizer *arg2 = (wxSizer *) 0 ;
50282 wxGBPosition result;
50283 void *argp1 = 0 ;
50284 int res1 = 0 ;
50285 void *argp2 = 0 ;
50286 int res2 = 0 ;
50287
50288 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50289 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50290 if (!SWIG_IsOK(res1)) {
50291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50292 }
50293 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50294 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50295 if (!SWIG_IsOK(res2)) {
50296 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50297 }
50298 arg2 = reinterpret_cast< wxSizer * >(argp2);
50299 {
50300 PyThreadState* __tstate = wxPyBeginAllowThreads();
50301 result = (arg1)->GetItemPosition(arg2);
50302 wxPyEndAllowThreads(__tstate);
50303 if (PyErr_Occurred()) SWIG_fail;
50304 }
50305 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50306 return resultobj;
50307 fail:
50308 return NULL;
50309 }
50310
50311
50312 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50313 PyObject *resultobj = 0;
50314 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50315 size_t arg2 ;
50316 wxGBPosition result;
50317 void *argp1 = 0 ;
50318 int res1 = 0 ;
50319 size_t val2 ;
50320 int ecode2 = 0 ;
50321
50322 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50323 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50324 if (!SWIG_IsOK(res1)) {
50325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50326 }
50327 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50328 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50329 if (!SWIG_IsOK(ecode2)) {
50330 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50331 }
50332 arg2 = static_cast< size_t >(val2);
50333 {
50334 PyThreadState* __tstate = wxPyBeginAllowThreads();
50335 result = (arg1)->GetItemPosition(arg2);
50336 wxPyEndAllowThreads(__tstate);
50337 if (PyErr_Occurred()) SWIG_fail;
50338 }
50339 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50340 return resultobj;
50341 fail:
50342 return NULL;
50343 }
50344
50345
50346 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
50347 int argc;
50348 PyObject *argv[3];
50349
50350 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
50351 --argc;
50352 if (argc == 2) {
50353 int _v = 0;
50354 {
50355 void *vptr = 0;
50356 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50357 _v = SWIG_CheckState(res);
50358 }
50359 if (!_v) goto check_1;
50360 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
50361 }
50362 check_1:
50363
50364 if (argc == 2) {
50365 int _v = 0;
50366 {
50367 void *vptr = 0;
50368 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50369 _v = SWIG_CheckState(res);
50370 }
50371 if (!_v) goto check_2;
50372 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
50373 }
50374 check_2:
50375
50376 if (argc == 2) {
50377 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
50378 }
50379
50380 fail:
50381 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
50382 return NULL;
50383 }
50384
50385
50386 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50387 PyObject *resultobj = 0;
50388 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50389 wxWindow *arg2 = (wxWindow *) 0 ;
50390 wxGBPosition *arg3 = 0 ;
50391 bool result;
50392 void *argp1 = 0 ;
50393 int res1 = 0 ;
50394 void *argp2 = 0 ;
50395 int res2 = 0 ;
50396 wxGBPosition temp3 ;
50397
50398 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50399 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50400 if (!SWIG_IsOK(res1)) {
50401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50402 }
50403 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50404 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50405 if (!SWIG_IsOK(res2)) {
50406 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50407 }
50408 arg2 = reinterpret_cast< wxWindow * >(argp2);
50409 {
50410 arg3 = &temp3;
50411 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50412 }
50413 {
50414 PyThreadState* __tstate = wxPyBeginAllowThreads();
50415 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50416 wxPyEndAllowThreads(__tstate);
50417 if (PyErr_Occurred()) SWIG_fail;
50418 }
50419 {
50420 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50421 }
50422 return resultobj;
50423 fail:
50424 return NULL;
50425 }
50426
50427
50428 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50429 PyObject *resultobj = 0;
50430 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50431 wxSizer *arg2 = (wxSizer *) 0 ;
50432 wxGBPosition *arg3 = 0 ;
50433 bool result;
50434 void *argp1 = 0 ;
50435 int res1 = 0 ;
50436 void *argp2 = 0 ;
50437 int res2 = 0 ;
50438 wxGBPosition temp3 ;
50439
50440 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50441 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50442 if (!SWIG_IsOK(res1)) {
50443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50444 }
50445 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50446 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50447 if (!SWIG_IsOK(res2)) {
50448 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50449 }
50450 arg2 = reinterpret_cast< wxSizer * >(argp2);
50451 {
50452 arg3 = &temp3;
50453 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50454 }
50455 {
50456 PyThreadState* __tstate = wxPyBeginAllowThreads();
50457 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50458 wxPyEndAllowThreads(__tstate);
50459 if (PyErr_Occurred()) SWIG_fail;
50460 }
50461 {
50462 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50463 }
50464 return resultobj;
50465 fail:
50466 return NULL;
50467 }
50468
50469
50470 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50471 PyObject *resultobj = 0;
50472 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50473 size_t arg2 ;
50474 wxGBPosition *arg3 = 0 ;
50475 bool result;
50476 void *argp1 = 0 ;
50477 int res1 = 0 ;
50478 size_t val2 ;
50479 int ecode2 = 0 ;
50480 wxGBPosition temp3 ;
50481
50482 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50483 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50484 if (!SWIG_IsOK(res1)) {
50485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50486 }
50487 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50488 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50489 if (!SWIG_IsOK(ecode2)) {
50490 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50491 }
50492 arg2 = static_cast< size_t >(val2);
50493 {
50494 arg3 = &temp3;
50495 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50496 }
50497 {
50498 PyThreadState* __tstate = wxPyBeginAllowThreads();
50499 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50500 wxPyEndAllowThreads(__tstate);
50501 if (PyErr_Occurred()) SWIG_fail;
50502 }
50503 {
50504 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50505 }
50506 return resultobj;
50507 fail:
50508 return NULL;
50509 }
50510
50511
50512 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
50513 int argc;
50514 PyObject *argv[4];
50515
50516 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
50517 --argc;
50518 if (argc == 3) {
50519 int _v = 0;
50520 {
50521 void *vptr = 0;
50522 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50523 _v = SWIG_CheckState(res);
50524 }
50525 if (!_v) goto check_1;
50526 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
50527 }
50528 check_1:
50529
50530 if (argc == 3) {
50531 int _v = 0;
50532 {
50533 void *vptr = 0;
50534 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50535 _v = SWIG_CheckState(res);
50536 }
50537 if (!_v) goto check_2;
50538 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
50539 }
50540 check_2:
50541
50542 if (argc == 3) {
50543 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
50544 }
50545
50546 fail:
50547 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
50548 return NULL;
50549 }
50550
50551
50552 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50553 PyObject *resultobj = 0;
50554 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50555 wxWindow *arg2 = (wxWindow *) 0 ;
50556 wxGBSpan result;
50557 void *argp1 = 0 ;
50558 int res1 = 0 ;
50559 void *argp2 = 0 ;
50560 int res2 = 0 ;
50561
50562 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50563 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50564 if (!SWIG_IsOK(res1)) {
50565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50566 }
50567 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50568 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50569 if (!SWIG_IsOK(res2)) {
50570 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
50571 }
50572 arg2 = reinterpret_cast< wxWindow * >(argp2);
50573 {
50574 PyThreadState* __tstate = wxPyBeginAllowThreads();
50575 result = (arg1)->GetItemSpan(arg2);
50576 wxPyEndAllowThreads(__tstate);
50577 if (PyErr_Occurred()) SWIG_fail;
50578 }
50579 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50580 return resultobj;
50581 fail:
50582 return NULL;
50583 }
50584
50585
50586 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50587 PyObject *resultobj = 0;
50588 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50589 wxSizer *arg2 = (wxSizer *) 0 ;
50590 wxGBSpan result;
50591 void *argp1 = 0 ;
50592 int res1 = 0 ;
50593 void *argp2 = 0 ;
50594 int res2 = 0 ;
50595
50596 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50597 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50598 if (!SWIG_IsOK(res1)) {
50599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50600 }
50601 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50602 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50603 if (!SWIG_IsOK(res2)) {
50604 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
50605 }
50606 arg2 = reinterpret_cast< wxSizer * >(argp2);
50607 {
50608 PyThreadState* __tstate = wxPyBeginAllowThreads();
50609 result = (arg1)->GetItemSpan(arg2);
50610 wxPyEndAllowThreads(__tstate);
50611 if (PyErr_Occurred()) SWIG_fail;
50612 }
50613 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50614 return resultobj;
50615 fail:
50616 return NULL;
50617 }
50618
50619
50620 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50621 PyObject *resultobj = 0;
50622 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50623 size_t arg2 ;
50624 wxGBSpan result;
50625 void *argp1 = 0 ;
50626 int res1 = 0 ;
50627 size_t val2 ;
50628 int ecode2 = 0 ;
50629
50630 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50632 if (!SWIG_IsOK(res1)) {
50633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50634 }
50635 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50636 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50637 if (!SWIG_IsOK(ecode2)) {
50638 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
50639 }
50640 arg2 = static_cast< size_t >(val2);
50641 {
50642 PyThreadState* __tstate = wxPyBeginAllowThreads();
50643 result = (arg1)->GetItemSpan(arg2);
50644 wxPyEndAllowThreads(__tstate);
50645 if (PyErr_Occurred()) SWIG_fail;
50646 }
50647 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50648 return resultobj;
50649 fail:
50650 return NULL;
50651 }
50652
50653
50654 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
50655 int argc;
50656 PyObject *argv[3];
50657
50658 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
50659 --argc;
50660 if (argc == 2) {
50661 int _v = 0;
50662 {
50663 void *vptr = 0;
50664 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50665 _v = SWIG_CheckState(res);
50666 }
50667 if (!_v) goto check_1;
50668 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
50669 }
50670 check_1:
50671
50672 if (argc == 2) {
50673 int _v = 0;
50674 {
50675 void *vptr = 0;
50676 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50677 _v = SWIG_CheckState(res);
50678 }
50679 if (!_v) goto check_2;
50680 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
50681 }
50682 check_2:
50683
50684 if (argc == 2) {
50685 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
50686 }
50687
50688 fail:
50689 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
50690 return NULL;
50691 }
50692
50693
50694 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50695 PyObject *resultobj = 0;
50696 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50697 wxWindow *arg2 = (wxWindow *) 0 ;
50698 wxGBSpan *arg3 = 0 ;
50699 bool result;
50700 void *argp1 = 0 ;
50701 int res1 = 0 ;
50702 void *argp2 = 0 ;
50703 int res2 = 0 ;
50704 wxGBSpan temp3 ;
50705
50706 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50707 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50708 if (!SWIG_IsOK(res1)) {
50709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50710 }
50711 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50712 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50713 if (!SWIG_IsOK(res2)) {
50714 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
50715 }
50716 arg2 = reinterpret_cast< wxWindow * >(argp2);
50717 {
50718 arg3 = &temp3;
50719 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50720 }
50721 {
50722 PyThreadState* __tstate = wxPyBeginAllowThreads();
50723 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50724 wxPyEndAllowThreads(__tstate);
50725 if (PyErr_Occurred()) SWIG_fail;
50726 }
50727 {
50728 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50729 }
50730 return resultobj;
50731 fail:
50732 return NULL;
50733 }
50734
50735
50736 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50737 PyObject *resultobj = 0;
50738 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50739 wxSizer *arg2 = (wxSizer *) 0 ;
50740 wxGBSpan *arg3 = 0 ;
50741 bool result;
50742 void *argp1 = 0 ;
50743 int res1 = 0 ;
50744 void *argp2 = 0 ;
50745 int res2 = 0 ;
50746 wxGBSpan temp3 ;
50747
50748 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50749 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50750 if (!SWIG_IsOK(res1)) {
50751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50752 }
50753 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50754 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50755 if (!SWIG_IsOK(res2)) {
50756 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
50757 }
50758 arg2 = reinterpret_cast< wxSizer * >(argp2);
50759 {
50760 arg3 = &temp3;
50761 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50762 }
50763 {
50764 PyThreadState* __tstate = wxPyBeginAllowThreads();
50765 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50766 wxPyEndAllowThreads(__tstate);
50767 if (PyErr_Occurred()) SWIG_fail;
50768 }
50769 {
50770 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50771 }
50772 return resultobj;
50773 fail:
50774 return NULL;
50775 }
50776
50777
50778 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50779 PyObject *resultobj = 0;
50780 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50781 size_t arg2 ;
50782 wxGBSpan *arg3 = 0 ;
50783 bool result;
50784 void *argp1 = 0 ;
50785 int res1 = 0 ;
50786 size_t val2 ;
50787 int ecode2 = 0 ;
50788 wxGBSpan temp3 ;
50789
50790 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50791 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50792 if (!SWIG_IsOK(res1)) {
50793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50794 }
50795 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50796 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50797 if (!SWIG_IsOK(ecode2)) {
50798 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
50799 }
50800 arg2 = static_cast< size_t >(val2);
50801 {
50802 arg3 = &temp3;
50803 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50804 }
50805 {
50806 PyThreadState* __tstate = wxPyBeginAllowThreads();
50807 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50808 wxPyEndAllowThreads(__tstate);
50809 if (PyErr_Occurred()) SWIG_fail;
50810 }
50811 {
50812 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50813 }
50814 return resultobj;
50815 fail:
50816 return NULL;
50817 }
50818
50819
50820 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
50821 int argc;
50822 PyObject *argv[4];
50823
50824 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
50825 --argc;
50826 if (argc == 3) {
50827 int _v = 0;
50828 {
50829 void *vptr = 0;
50830 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50831 _v = SWIG_CheckState(res);
50832 }
50833 if (!_v) goto check_1;
50834 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
50835 }
50836 check_1:
50837
50838 if (argc == 3) {
50839 int _v = 0;
50840 {
50841 void *vptr = 0;
50842 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50843 _v = SWIG_CheckState(res);
50844 }
50845 if (!_v) goto check_2;
50846 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
50847 }
50848 check_2:
50849
50850 if (argc == 3) {
50851 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
50852 }
50853
50854 fail:
50855 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
50856 return NULL;
50857 }
50858
50859
50860 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50861 PyObject *resultobj = 0;
50862 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50863 wxWindow *arg2 = (wxWindow *) 0 ;
50864 wxGBSizerItem *result = 0 ;
50865 void *argp1 = 0 ;
50866 int res1 = 0 ;
50867 void *argp2 = 0 ;
50868 int res2 = 0 ;
50869
50870 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50871 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50872 if (!SWIG_IsOK(res1)) {
50873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50874 }
50875 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50876 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50877 if (!SWIG_IsOK(res2)) {
50878 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
50879 }
50880 arg2 = reinterpret_cast< wxWindow * >(argp2);
50881 {
50882 PyThreadState* __tstate = wxPyBeginAllowThreads();
50883 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
50884 wxPyEndAllowThreads(__tstate);
50885 if (PyErr_Occurred()) SWIG_fail;
50886 }
50887 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50888 return resultobj;
50889 fail:
50890 return NULL;
50891 }
50892
50893
50894 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50895 PyObject *resultobj = 0;
50896 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50897 wxSizer *arg2 = (wxSizer *) 0 ;
50898 wxGBSizerItem *result = 0 ;
50899 void *argp1 = 0 ;
50900 int res1 = 0 ;
50901 void *argp2 = 0 ;
50902 int res2 = 0 ;
50903
50904 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50905 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50906 if (!SWIG_IsOK(res1)) {
50907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50908 }
50909 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50910 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50911 if (!SWIG_IsOK(res2)) {
50912 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
50913 }
50914 arg2 = reinterpret_cast< wxSizer * >(argp2);
50915 {
50916 PyThreadState* __tstate = wxPyBeginAllowThreads();
50917 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
50918 wxPyEndAllowThreads(__tstate);
50919 if (PyErr_Occurred()) SWIG_fail;
50920 }
50921 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50922 return resultobj;
50923 fail:
50924 return NULL;
50925 }
50926
50927
50928 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
50929 int argc;
50930 PyObject *argv[3];
50931
50932 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
50933 --argc;
50934 if (argc == 2) {
50935 int _v = 0;
50936 {
50937 void *vptr = 0;
50938 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50939 _v = SWIG_CheckState(res);
50940 }
50941 if (!_v) goto check_1;
50942 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
50943 }
50944 check_1:
50945
50946 if (argc == 2) {
50947 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
50948 }
50949
50950 fail:
50951 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
50952 return NULL;
50953 }
50954
50955
50956 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50957 PyObject *resultobj = 0;
50958 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50959 wxGBPosition *arg2 = 0 ;
50960 wxGBSizerItem *result = 0 ;
50961 void *argp1 = 0 ;
50962 int res1 = 0 ;
50963 wxGBPosition temp2 ;
50964 PyObject * obj0 = 0 ;
50965 PyObject * obj1 = 0 ;
50966 char * kwnames[] = {
50967 (char *) "self",(char *) "pos", NULL
50968 };
50969
50970 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
50971 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50972 if (!SWIG_IsOK(res1)) {
50973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50974 }
50975 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50976 {
50977 arg2 = &temp2;
50978 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50979 }
50980 {
50981 PyThreadState* __tstate = wxPyBeginAllowThreads();
50982 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
50983 wxPyEndAllowThreads(__tstate);
50984 if (PyErr_Occurred()) SWIG_fail;
50985 }
50986 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50987 return resultobj;
50988 fail:
50989 return NULL;
50990 }
50991
50992
50993 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50994 PyObject *resultobj = 0;
50995 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50996 wxPoint *arg2 = 0 ;
50997 wxGBSizerItem *result = 0 ;
50998 void *argp1 = 0 ;
50999 int res1 = 0 ;
51000 wxPoint temp2 ;
51001 PyObject * obj0 = 0 ;
51002 PyObject * obj1 = 0 ;
51003 char * kwnames[] = {
51004 (char *) "self",(char *) "pt", NULL
51005 };
51006
51007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
51008 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51009 if (!SWIG_IsOK(res1)) {
51010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51011 }
51012 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51013 {
51014 arg2 = &temp2;
51015 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
51016 }
51017 {
51018 PyThreadState* __tstate = wxPyBeginAllowThreads();
51019 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
51020 wxPyEndAllowThreads(__tstate);
51021 if (PyErr_Occurred()) SWIG_fail;
51022 }
51023 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51024 return resultobj;
51025 fail:
51026 return NULL;
51027 }
51028
51029
51030 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51031 PyObject *resultobj = 0;
51032 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51033 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
51034 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
51035 bool result;
51036 void *argp1 = 0 ;
51037 int res1 = 0 ;
51038 void *argp2 = 0 ;
51039 int res2 = 0 ;
51040 void *argp3 = 0 ;
51041 int res3 = 0 ;
51042 PyObject * obj0 = 0 ;
51043 PyObject * obj1 = 0 ;
51044 PyObject * obj2 = 0 ;
51045 char * kwnames[] = {
51046 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
51047 };
51048
51049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) 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_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51053 }
51054 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51055 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51056 if (!SWIG_IsOK(res2)) {
51057 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
51058 }
51059 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
51060 if (obj2) {
51061 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51062 if (!SWIG_IsOK(res3)) {
51063 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
51064 }
51065 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
51066 }
51067 {
51068 PyThreadState* __tstate = wxPyBeginAllowThreads();
51069 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
51070 wxPyEndAllowThreads(__tstate);
51071 if (PyErr_Occurred()) SWIG_fail;
51072 }
51073 {
51074 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51075 }
51076 return resultobj;
51077 fail:
51078 return NULL;
51079 }
51080
51081
51082 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51083 PyObject *resultobj = 0;
51084 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51085 wxGBPosition *arg2 = 0 ;
51086 wxGBSpan *arg3 = 0 ;
51087 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
51088 bool result;
51089 void *argp1 = 0 ;
51090 int res1 = 0 ;
51091 wxGBPosition temp2 ;
51092 wxGBSpan temp3 ;
51093 void *argp4 = 0 ;
51094 int res4 = 0 ;
51095 PyObject * obj0 = 0 ;
51096 PyObject * obj1 = 0 ;
51097 PyObject * obj2 = 0 ;
51098 PyObject * obj3 = 0 ;
51099 char * kwnames[] = {
51100 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
51101 };
51102
51103 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51104 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51105 if (!SWIG_IsOK(res1)) {
51106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51107 }
51108 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51109 {
51110 arg2 = &temp2;
51111 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51112 }
51113 {
51114 arg3 = &temp3;
51115 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
51116 }
51117 if (obj3) {
51118 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51119 if (!SWIG_IsOK(res4)) {
51120 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
51121 }
51122 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
51123 }
51124 {
51125 PyThreadState* __tstate = wxPyBeginAllowThreads();
51126 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
51127 wxPyEndAllowThreads(__tstate);
51128 if (PyErr_Occurred()) SWIG_fail;
51129 }
51130 {
51131 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51132 }
51133 return resultobj;
51134 fail:
51135 return NULL;
51136 }
51137
51138
51139 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51140 PyObject *obj;
51141 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51142 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
51143 return SWIG_Py_Void();
51144 }
51145
51146 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51147 return SWIG_Python_InitShadowInstance(args);
51148 }
51149
51150 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51151 PyObject *resultobj = 0;
51152 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51153 wxRelationship arg2 ;
51154 wxWindow *arg3 = (wxWindow *) 0 ;
51155 wxEdge arg4 ;
51156 int arg5 = (int) 0 ;
51157 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
51158 void *argp1 = 0 ;
51159 int res1 = 0 ;
51160 int val2 ;
51161 int ecode2 = 0 ;
51162 void *argp3 = 0 ;
51163 int res3 = 0 ;
51164 int val4 ;
51165 int ecode4 = 0 ;
51166 int val5 ;
51167 int ecode5 = 0 ;
51168 int val6 ;
51169 int ecode6 = 0 ;
51170 PyObject * obj0 = 0 ;
51171 PyObject * obj1 = 0 ;
51172 PyObject * obj2 = 0 ;
51173 PyObject * obj3 = 0 ;
51174 PyObject * obj4 = 0 ;
51175 PyObject * obj5 = 0 ;
51176 char * kwnames[] = {
51177 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
51178 };
51179
51180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
51181 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51182 if (!SWIG_IsOK(res1)) {
51183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51184 }
51185 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51186 ecode2 = SWIG_AsVal_int(obj1, &val2);
51187 if (!SWIG_IsOK(ecode2)) {
51188 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
51189 }
51190 arg2 = static_cast< wxRelationship >(val2);
51191 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
51192 if (!SWIG_IsOK(res3)) {
51193 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
51194 }
51195 arg3 = reinterpret_cast< wxWindow * >(argp3);
51196 ecode4 = SWIG_AsVal_int(obj3, &val4);
51197 if (!SWIG_IsOK(ecode4)) {
51198 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
51199 }
51200 arg4 = static_cast< wxEdge >(val4);
51201 if (obj4) {
51202 ecode5 = SWIG_AsVal_int(obj4, &val5);
51203 if (!SWIG_IsOK(ecode5)) {
51204 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
51205 }
51206 arg5 = static_cast< int >(val5);
51207 }
51208 if (obj5) {
51209 ecode6 = SWIG_AsVal_int(obj5, &val6);
51210 if (!SWIG_IsOK(ecode6)) {
51211 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
51212 }
51213 arg6 = static_cast< int >(val6);
51214 }
51215 {
51216 PyThreadState* __tstate = wxPyBeginAllowThreads();
51217 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
51218 wxPyEndAllowThreads(__tstate);
51219 if (PyErr_Occurred()) SWIG_fail;
51220 }
51221 resultobj = SWIG_Py_Void();
51222 return resultobj;
51223 fail:
51224 return NULL;
51225 }
51226
51227
51228 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51229 PyObject *resultobj = 0;
51230 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51231 wxWindow *arg2 = (wxWindow *) 0 ;
51232 int arg3 = (int) 0 ;
51233 void *argp1 = 0 ;
51234 int res1 = 0 ;
51235 void *argp2 = 0 ;
51236 int res2 = 0 ;
51237 int val3 ;
51238 int ecode3 = 0 ;
51239 PyObject * obj0 = 0 ;
51240 PyObject * obj1 = 0 ;
51241 PyObject * obj2 = 0 ;
51242 char * kwnames[] = {
51243 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51244 };
51245
51246 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51247 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51248 if (!SWIG_IsOK(res1)) {
51249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51250 }
51251 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51252 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51253 if (!SWIG_IsOK(res2)) {
51254 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51255 }
51256 arg2 = reinterpret_cast< wxWindow * >(argp2);
51257 if (obj2) {
51258 ecode3 = SWIG_AsVal_int(obj2, &val3);
51259 if (!SWIG_IsOK(ecode3)) {
51260 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
51261 }
51262 arg3 = static_cast< int >(val3);
51263 }
51264 {
51265 PyThreadState* __tstate = wxPyBeginAllowThreads();
51266 (arg1)->LeftOf(arg2,arg3);
51267 wxPyEndAllowThreads(__tstate);
51268 if (PyErr_Occurred()) SWIG_fail;
51269 }
51270 resultobj = SWIG_Py_Void();
51271 return resultobj;
51272 fail:
51273 return NULL;
51274 }
51275
51276
51277 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51278 PyObject *resultobj = 0;
51279 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51280 wxWindow *arg2 = (wxWindow *) 0 ;
51281 int arg3 = (int) 0 ;
51282 void *argp1 = 0 ;
51283 int res1 = 0 ;
51284 void *argp2 = 0 ;
51285 int res2 = 0 ;
51286 int val3 ;
51287 int ecode3 = 0 ;
51288 PyObject * obj0 = 0 ;
51289 PyObject * obj1 = 0 ;
51290 PyObject * obj2 = 0 ;
51291 char * kwnames[] = {
51292 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51293 };
51294
51295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51296 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51297 if (!SWIG_IsOK(res1)) {
51298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51299 }
51300 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51301 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51302 if (!SWIG_IsOK(res2)) {
51303 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51304 }
51305 arg2 = reinterpret_cast< wxWindow * >(argp2);
51306 if (obj2) {
51307 ecode3 = SWIG_AsVal_int(obj2, &val3);
51308 if (!SWIG_IsOK(ecode3)) {
51309 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
51310 }
51311 arg3 = static_cast< int >(val3);
51312 }
51313 {
51314 PyThreadState* __tstate = wxPyBeginAllowThreads();
51315 (arg1)->RightOf(arg2,arg3);
51316 wxPyEndAllowThreads(__tstate);
51317 if (PyErr_Occurred()) SWIG_fail;
51318 }
51319 resultobj = SWIG_Py_Void();
51320 return resultobj;
51321 fail:
51322 return NULL;
51323 }
51324
51325
51326 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51327 PyObject *resultobj = 0;
51328 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51329 wxWindow *arg2 = (wxWindow *) 0 ;
51330 int arg3 = (int) 0 ;
51331 void *argp1 = 0 ;
51332 int res1 = 0 ;
51333 void *argp2 = 0 ;
51334 int res2 = 0 ;
51335 int val3 ;
51336 int ecode3 = 0 ;
51337 PyObject * obj0 = 0 ;
51338 PyObject * obj1 = 0 ;
51339 PyObject * obj2 = 0 ;
51340 char * kwnames[] = {
51341 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51342 };
51343
51344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51345 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51346 if (!SWIG_IsOK(res1)) {
51347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51348 }
51349 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51350 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51351 if (!SWIG_IsOK(res2)) {
51352 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
51353 }
51354 arg2 = reinterpret_cast< wxWindow * >(argp2);
51355 if (obj2) {
51356 ecode3 = SWIG_AsVal_int(obj2, &val3);
51357 if (!SWIG_IsOK(ecode3)) {
51358 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
51359 }
51360 arg3 = static_cast< int >(val3);
51361 }
51362 {
51363 PyThreadState* __tstate = wxPyBeginAllowThreads();
51364 (arg1)->Above(arg2,arg3);
51365 wxPyEndAllowThreads(__tstate);
51366 if (PyErr_Occurred()) SWIG_fail;
51367 }
51368 resultobj = SWIG_Py_Void();
51369 return resultobj;
51370 fail:
51371 return NULL;
51372 }
51373
51374
51375 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51376 PyObject *resultobj = 0;
51377 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51378 wxWindow *arg2 = (wxWindow *) 0 ;
51379 int arg3 = (int) 0 ;
51380 void *argp1 = 0 ;
51381 int res1 = 0 ;
51382 void *argp2 = 0 ;
51383 int res2 = 0 ;
51384 int val3 ;
51385 int ecode3 = 0 ;
51386 PyObject * obj0 = 0 ;
51387 PyObject * obj1 = 0 ;
51388 PyObject * obj2 = 0 ;
51389 char * kwnames[] = {
51390 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51391 };
51392
51393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51394 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51395 if (!SWIG_IsOK(res1)) {
51396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51397 }
51398 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51399 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51400 if (!SWIG_IsOK(res2)) {
51401 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
51402 }
51403 arg2 = reinterpret_cast< wxWindow * >(argp2);
51404 if (obj2) {
51405 ecode3 = SWIG_AsVal_int(obj2, &val3);
51406 if (!SWIG_IsOK(ecode3)) {
51407 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
51408 }
51409 arg3 = static_cast< int >(val3);
51410 }
51411 {
51412 PyThreadState* __tstate = wxPyBeginAllowThreads();
51413 (arg1)->Below(arg2,arg3);
51414 wxPyEndAllowThreads(__tstate);
51415 if (PyErr_Occurred()) SWIG_fail;
51416 }
51417 resultobj = SWIG_Py_Void();
51418 return resultobj;
51419 fail:
51420 return NULL;
51421 }
51422
51423
51424 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51425 PyObject *resultobj = 0;
51426 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51427 wxWindow *arg2 = (wxWindow *) 0 ;
51428 wxEdge arg3 ;
51429 int arg4 = (int) 0 ;
51430 void *argp1 = 0 ;
51431 int res1 = 0 ;
51432 void *argp2 = 0 ;
51433 int res2 = 0 ;
51434 int val3 ;
51435 int ecode3 = 0 ;
51436 int val4 ;
51437 int ecode4 = 0 ;
51438 PyObject * obj0 = 0 ;
51439 PyObject * obj1 = 0 ;
51440 PyObject * obj2 = 0 ;
51441 PyObject * obj3 = 0 ;
51442 char * kwnames[] = {
51443 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
51444 };
51445
51446 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51447 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51448 if (!SWIG_IsOK(res1)) {
51449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51450 }
51451 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51452 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51453 if (!SWIG_IsOK(res2)) {
51454 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
51455 }
51456 arg2 = reinterpret_cast< wxWindow * >(argp2);
51457 ecode3 = SWIG_AsVal_int(obj2, &val3);
51458 if (!SWIG_IsOK(ecode3)) {
51459 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
51460 }
51461 arg3 = static_cast< wxEdge >(val3);
51462 if (obj3) {
51463 ecode4 = SWIG_AsVal_int(obj3, &val4);
51464 if (!SWIG_IsOK(ecode4)) {
51465 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
51466 }
51467 arg4 = static_cast< int >(val4);
51468 }
51469 {
51470 PyThreadState* __tstate = wxPyBeginAllowThreads();
51471 (arg1)->SameAs(arg2,arg3,arg4);
51472 wxPyEndAllowThreads(__tstate);
51473 if (PyErr_Occurred()) SWIG_fail;
51474 }
51475 resultobj = SWIG_Py_Void();
51476 return resultobj;
51477 fail:
51478 return NULL;
51479 }
51480
51481
51482 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51483 PyObject *resultobj = 0;
51484 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51485 wxWindow *arg2 = (wxWindow *) 0 ;
51486 wxEdge arg3 ;
51487 int arg4 ;
51488 void *argp1 = 0 ;
51489 int res1 = 0 ;
51490 void *argp2 = 0 ;
51491 int res2 = 0 ;
51492 int val3 ;
51493 int ecode3 = 0 ;
51494 int val4 ;
51495 int ecode4 = 0 ;
51496 PyObject * obj0 = 0 ;
51497 PyObject * obj1 = 0 ;
51498 PyObject * obj2 = 0 ;
51499 PyObject * obj3 = 0 ;
51500 char * kwnames[] = {
51501 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
51502 };
51503
51504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51505 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51506 if (!SWIG_IsOK(res1)) {
51507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51508 }
51509 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51510 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51511 if (!SWIG_IsOK(res2)) {
51512 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51513 }
51514 arg2 = reinterpret_cast< wxWindow * >(argp2);
51515 ecode3 = SWIG_AsVal_int(obj2, &val3);
51516 if (!SWIG_IsOK(ecode3)) {
51517 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
51518 }
51519 arg3 = static_cast< wxEdge >(val3);
51520 ecode4 = SWIG_AsVal_int(obj3, &val4);
51521 if (!SWIG_IsOK(ecode4)) {
51522 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
51523 }
51524 arg4 = static_cast< int >(val4);
51525 {
51526 PyThreadState* __tstate = wxPyBeginAllowThreads();
51527 (arg1)->PercentOf(arg2,arg3,arg4);
51528 wxPyEndAllowThreads(__tstate);
51529 if (PyErr_Occurred()) SWIG_fail;
51530 }
51531 resultobj = SWIG_Py_Void();
51532 return resultobj;
51533 fail:
51534 return NULL;
51535 }
51536
51537
51538 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51539 PyObject *resultobj = 0;
51540 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51541 int arg2 ;
51542 void *argp1 = 0 ;
51543 int res1 = 0 ;
51544 int val2 ;
51545 int ecode2 = 0 ;
51546 PyObject * obj0 = 0 ;
51547 PyObject * obj1 = 0 ;
51548 char * kwnames[] = {
51549 (char *) "self",(char *) "val", NULL
51550 };
51551
51552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
51553 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51554 if (!SWIG_IsOK(res1)) {
51555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51556 }
51557 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51558 ecode2 = SWIG_AsVal_int(obj1, &val2);
51559 if (!SWIG_IsOK(ecode2)) {
51560 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
51561 }
51562 arg2 = static_cast< int >(val2);
51563 {
51564 PyThreadState* __tstate = wxPyBeginAllowThreads();
51565 (arg1)->Absolute(arg2);
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_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51577 PyObject *resultobj = 0;
51578 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51579 void *argp1 = 0 ;
51580 int res1 = 0 ;
51581 PyObject *swig_obj[1] ;
51582
51583 if (!args) SWIG_fail;
51584 swig_obj[0] = args;
51585 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51586 if (!SWIG_IsOK(res1)) {
51587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51588 }
51589 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51590 {
51591 PyThreadState* __tstate = wxPyBeginAllowThreads();
51592 (arg1)->Unconstrained();
51593 wxPyEndAllowThreads(__tstate);
51594 if (PyErr_Occurred()) SWIG_fail;
51595 }
51596 resultobj = SWIG_Py_Void();
51597 return resultobj;
51598 fail:
51599 return NULL;
51600 }
51601
51602
51603 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51604 PyObject *resultobj = 0;
51605 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51606 void *argp1 = 0 ;
51607 int res1 = 0 ;
51608 PyObject *swig_obj[1] ;
51609
51610 if (!args) SWIG_fail;
51611 swig_obj[0] = args;
51612 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51613 if (!SWIG_IsOK(res1)) {
51614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51615 }
51616 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51617 {
51618 PyThreadState* __tstate = wxPyBeginAllowThreads();
51619 (arg1)->AsIs();
51620 wxPyEndAllowThreads(__tstate);
51621 if (PyErr_Occurred()) SWIG_fail;
51622 }
51623 resultobj = SWIG_Py_Void();
51624 return resultobj;
51625 fail:
51626 return NULL;
51627 }
51628
51629
51630 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51631 PyObject *resultobj = 0;
51632 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51633 wxWindow *result = 0 ;
51634 void *argp1 = 0 ;
51635 int res1 = 0 ;
51636 PyObject *swig_obj[1] ;
51637
51638 if (!args) SWIG_fail;
51639 swig_obj[0] = args;
51640 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51641 if (!SWIG_IsOK(res1)) {
51642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51643 }
51644 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51645 {
51646 PyThreadState* __tstate = wxPyBeginAllowThreads();
51647 result = (wxWindow *)(arg1)->GetOtherWindow();
51648 wxPyEndAllowThreads(__tstate);
51649 if (PyErr_Occurred()) SWIG_fail;
51650 }
51651 {
51652 resultobj = wxPyMake_wxObject(result, 0);
51653 }
51654 return resultobj;
51655 fail:
51656 return NULL;
51657 }
51658
51659
51660 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51661 PyObject *resultobj = 0;
51662 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51663 wxEdge result;
51664 void *argp1 = 0 ;
51665 int res1 = 0 ;
51666 PyObject *swig_obj[1] ;
51667
51668 if (!args) SWIG_fail;
51669 swig_obj[0] = args;
51670 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51671 if (!SWIG_IsOK(res1)) {
51672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51673 }
51674 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51675 {
51676 PyThreadState* __tstate = wxPyBeginAllowThreads();
51677 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
51678 wxPyEndAllowThreads(__tstate);
51679 if (PyErr_Occurred()) SWIG_fail;
51680 }
51681 resultobj = SWIG_From_int(static_cast< int >(result));
51682 return resultobj;
51683 fail:
51684 return NULL;
51685 }
51686
51687
51688 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51689 PyObject *resultobj = 0;
51690 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51691 wxEdge arg2 ;
51692 void *argp1 = 0 ;
51693 int res1 = 0 ;
51694 int val2 ;
51695 int ecode2 = 0 ;
51696 PyObject * obj0 = 0 ;
51697 PyObject * obj1 = 0 ;
51698 char * kwnames[] = {
51699 (char *) "self",(char *) "which", NULL
51700 };
51701
51702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
51703 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51704 if (!SWIG_IsOK(res1)) {
51705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51706 }
51707 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51708 ecode2 = SWIG_AsVal_int(obj1, &val2);
51709 if (!SWIG_IsOK(ecode2)) {
51710 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
51711 }
51712 arg2 = static_cast< wxEdge >(val2);
51713 {
51714 PyThreadState* __tstate = wxPyBeginAllowThreads();
51715 (arg1)->SetEdge(arg2);
51716 wxPyEndAllowThreads(__tstate);
51717 if (PyErr_Occurred()) SWIG_fail;
51718 }
51719 resultobj = SWIG_Py_Void();
51720 return resultobj;
51721 fail:
51722 return NULL;
51723 }
51724
51725
51726 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51727 PyObject *resultobj = 0;
51728 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51729 int arg2 ;
51730 void *argp1 = 0 ;
51731 int res1 = 0 ;
51732 int val2 ;
51733 int ecode2 = 0 ;
51734 PyObject * obj0 = 0 ;
51735 PyObject * obj1 = 0 ;
51736 char * kwnames[] = {
51737 (char *) "self",(char *) "v", NULL
51738 };
51739
51740 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
51741 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51742 if (!SWIG_IsOK(res1)) {
51743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51744 }
51745 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51746 ecode2 = SWIG_AsVal_int(obj1, &val2);
51747 if (!SWIG_IsOK(ecode2)) {
51748 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
51749 }
51750 arg2 = static_cast< int >(val2);
51751 {
51752 PyThreadState* __tstate = wxPyBeginAllowThreads();
51753 (arg1)->SetValue(arg2);
51754 wxPyEndAllowThreads(__tstate);
51755 if (PyErr_Occurred()) SWIG_fail;
51756 }
51757 resultobj = SWIG_Py_Void();
51758 return resultobj;
51759 fail:
51760 return NULL;
51761 }
51762
51763
51764 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51765 PyObject *resultobj = 0;
51766 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51767 int result;
51768 void *argp1 = 0 ;
51769 int res1 = 0 ;
51770 PyObject *swig_obj[1] ;
51771
51772 if (!args) SWIG_fail;
51773 swig_obj[0] = args;
51774 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51775 if (!SWIG_IsOK(res1)) {
51776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51777 }
51778 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51779 {
51780 PyThreadState* __tstate = wxPyBeginAllowThreads();
51781 result = (int)(arg1)->GetMargin();
51782 wxPyEndAllowThreads(__tstate);
51783 if (PyErr_Occurred()) SWIG_fail;
51784 }
51785 resultobj = SWIG_From_int(static_cast< int >(result));
51786 return resultobj;
51787 fail:
51788 return NULL;
51789 }
51790
51791
51792 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51793 PyObject *resultobj = 0;
51794 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51795 int arg2 ;
51796 void *argp1 = 0 ;
51797 int res1 = 0 ;
51798 int val2 ;
51799 int ecode2 = 0 ;
51800 PyObject * obj0 = 0 ;
51801 PyObject * obj1 = 0 ;
51802 char * kwnames[] = {
51803 (char *) "self",(char *) "m", NULL
51804 };
51805
51806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
51807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51808 if (!SWIG_IsOK(res1)) {
51809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51810 }
51811 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51812 ecode2 = SWIG_AsVal_int(obj1, &val2);
51813 if (!SWIG_IsOK(ecode2)) {
51814 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
51815 }
51816 arg2 = static_cast< int >(val2);
51817 {
51818 PyThreadState* __tstate = wxPyBeginAllowThreads();
51819 (arg1)->SetMargin(arg2);
51820 wxPyEndAllowThreads(__tstate);
51821 if (PyErr_Occurred()) SWIG_fail;
51822 }
51823 resultobj = SWIG_Py_Void();
51824 return resultobj;
51825 fail:
51826 return NULL;
51827 }
51828
51829
51830 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51831 PyObject *resultobj = 0;
51832 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51833 int result;
51834 void *argp1 = 0 ;
51835 int res1 = 0 ;
51836 PyObject *swig_obj[1] ;
51837
51838 if (!args) SWIG_fail;
51839 swig_obj[0] = args;
51840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51841 if (!SWIG_IsOK(res1)) {
51842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51843 }
51844 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51845 {
51846 PyThreadState* __tstate = wxPyBeginAllowThreads();
51847 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
51848 wxPyEndAllowThreads(__tstate);
51849 if (PyErr_Occurred()) SWIG_fail;
51850 }
51851 resultobj = SWIG_From_int(static_cast< int >(result));
51852 return resultobj;
51853 fail:
51854 return NULL;
51855 }
51856
51857
51858 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51859 PyObject *resultobj = 0;
51860 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51861 int result;
51862 void *argp1 = 0 ;
51863 int res1 = 0 ;
51864 PyObject *swig_obj[1] ;
51865
51866 if (!args) SWIG_fail;
51867 swig_obj[0] = args;
51868 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51869 if (!SWIG_IsOK(res1)) {
51870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51871 }
51872 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51873 {
51874 PyThreadState* __tstate = wxPyBeginAllowThreads();
51875 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
51876 wxPyEndAllowThreads(__tstate);
51877 if (PyErr_Occurred()) SWIG_fail;
51878 }
51879 resultobj = SWIG_From_int(static_cast< int >(result));
51880 return resultobj;
51881 fail:
51882 return NULL;
51883 }
51884
51885
51886 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51887 PyObject *resultobj = 0;
51888 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51889 int result;
51890 void *argp1 = 0 ;
51891 int res1 = 0 ;
51892 PyObject *swig_obj[1] ;
51893
51894 if (!args) SWIG_fail;
51895 swig_obj[0] = args;
51896 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51897 if (!SWIG_IsOK(res1)) {
51898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51899 }
51900 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51901 {
51902 PyThreadState* __tstate = wxPyBeginAllowThreads();
51903 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
51904 wxPyEndAllowThreads(__tstate);
51905 if (PyErr_Occurred()) SWIG_fail;
51906 }
51907 resultobj = SWIG_From_int(static_cast< int >(result));
51908 return resultobj;
51909 fail:
51910 return NULL;
51911 }
51912
51913
51914 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51915 PyObject *resultobj = 0;
51916 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51917 bool result;
51918 void *argp1 = 0 ;
51919 int res1 = 0 ;
51920 PyObject *swig_obj[1] ;
51921
51922 if (!args) SWIG_fail;
51923 swig_obj[0] = args;
51924 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51925 if (!SWIG_IsOK(res1)) {
51926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51927 }
51928 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51929 {
51930 PyThreadState* __tstate = wxPyBeginAllowThreads();
51931 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
51932 wxPyEndAllowThreads(__tstate);
51933 if (PyErr_Occurred()) SWIG_fail;
51934 }
51935 {
51936 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51937 }
51938 return resultobj;
51939 fail:
51940 return NULL;
51941 }
51942
51943
51944 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51945 PyObject *resultobj = 0;
51946 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51947 bool arg2 ;
51948 void *argp1 = 0 ;
51949 int res1 = 0 ;
51950 bool val2 ;
51951 int ecode2 = 0 ;
51952 PyObject * obj0 = 0 ;
51953 PyObject * obj1 = 0 ;
51954 char * kwnames[] = {
51955 (char *) "self",(char *) "d", NULL
51956 };
51957
51958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
51959 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51960 if (!SWIG_IsOK(res1)) {
51961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51962 }
51963 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51964 ecode2 = SWIG_AsVal_bool(obj1, &val2);
51965 if (!SWIG_IsOK(ecode2)) {
51966 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
51967 }
51968 arg2 = static_cast< bool >(val2);
51969 {
51970 PyThreadState* __tstate = wxPyBeginAllowThreads();
51971 (arg1)->SetDone(arg2);
51972 wxPyEndAllowThreads(__tstate);
51973 if (PyErr_Occurred()) SWIG_fail;
51974 }
51975 resultobj = SWIG_Py_Void();
51976 return resultobj;
51977 fail:
51978 return NULL;
51979 }
51980
51981
51982 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51983 PyObject *resultobj = 0;
51984 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51985 wxRelationship result;
51986 void *argp1 = 0 ;
51987 int res1 = 0 ;
51988 PyObject *swig_obj[1] ;
51989
51990 if (!args) SWIG_fail;
51991 swig_obj[0] = args;
51992 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51993 if (!SWIG_IsOK(res1)) {
51994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51995 }
51996 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51997 {
51998 PyThreadState* __tstate = wxPyBeginAllowThreads();
51999 result = (wxRelationship)(arg1)->GetRelationship();
52000 wxPyEndAllowThreads(__tstate);
52001 if (PyErr_Occurred()) SWIG_fail;
52002 }
52003 resultobj = SWIG_From_int(static_cast< int >(result));
52004 return resultobj;
52005 fail:
52006 return NULL;
52007 }
52008
52009
52010 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52011 PyObject *resultobj = 0;
52012 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52013 wxRelationship arg2 ;
52014 void *argp1 = 0 ;
52015 int res1 = 0 ;
52016 int val2 ;
52017 int ecode2 = 0 ;
52018 PyObject * obj0 = 0 ;
52019 PyObject * obj1 = 0 ;
52020 char * kwnames[] = {
52021 (char *) "self",(char *) "r", NULL
52022 };
52023
52024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
52025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52026 if (!SWIG_IsOK(res1)) {
52027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52028 }
52029 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52030 ecode2 = SWIG_AsVal_int(obj1, &val2);
52031 if (!SWIG_IsOK(ecode2)) {
52032 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
52033 }
52034 arg2 = static_cast< wxRelationship >(val2);
52035 {
52036 PyThreadState* __tstate = wxPyBeginAllowThreads();
52037 (arg1)->SetRelationship(arg2);
52038 wxPyEndAllowThreads(__tstate);
52039 if (PyErr_Occurred()) SWIG_fail;
52040 }
52041 resultobj = SWIG_Py_Void();
52042 return resultobj;
52043 fail:
52044 return NULL;
52045 }
52046
52047
52048 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52049 PyObject *resultobj = 0;
52050 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52051 wxWindow *arg2 = (wxWindow *) 0 ;
52052 bool result;
52053 void *argp1 = 0 ;
52054 int res1 = 0 ;
52055 void *argp2 = 0 ;
52056 int res2 = 0 ;
52057 PyObject * obj0 = 0 ;
52058 PyObject * obj1 = 0 ;
52059 char * kwnames[] = {
52060 (char *) "self",(char *) "otherW", NULL
52061 };
52062
52063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
52064 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52065 if (!SWIG_IsOK(res1)) {
52066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52067 }
52068 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52069 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52070 if (!SWIG_IsOK(res2)) {
52071 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
52072 }
52073 arg2 = reinterpret_cast< wxWindow * >(argp2);
52074 {
52075 PyThreadState* __tstate = wxPyBeginAllowThreads();
52076 result = (bool)(arg1)->ResetIfWin(arg2);
52077 wxPyEndAllowThreads(__tstate);
52078 if (PyErr_Occurred()) SWIG_fail;
52079 }
52080 {
52081 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52082 }
52083 return resultobj;
52084 fail:
52085 return NULL;
52086 }
52087
52088
52089 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52090 PyObject *resultobj = 0;
52091 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52092 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
52093 wxWindow *arg3 = (wxWindow *) 0 ;
52094 bool result;
52095 void *argp1 = 0 ;
52096 int res1 = 0 ;
52097 void *argp2 = 0 ;
52098 int res2 = 0 ;
52099 void *argp3 = 0 ;
52100 int res3 = 0 ;
52101 PyObject * obj0 = 0 ;
52102 PyObject * obj1 = 0 ;
52103 PyObject * obj2 = 0 ;
52104 char * kwnames[] = {
52105 (char *) "self",(char *) "constraints",(char *) "win", NULL
52106 };
52107
52108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) 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_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52112 }
52113 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52114 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52115 if (!SWIG_IsOK(res2)) {
52116 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
52117 }
52118 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
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_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
52122 }
52123 arg3 = reinterpret_cast< wxWindow * >(argp3);
52124 {
52125 PyThreadState* __tstate = wxPyBeginAllowThreads();
52126 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
52127 wxPyEndAllowThreads(__tstate);
52128 if (PyErr_Occurred()) SWIG_fail;
52129 }
52130 {
52131 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52132 }
52133 return resultobj;
52134 fail:
52135 return NULL;
52136 }
52137
52138
52139 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52140 PyObject *resultobj = 0;
52141 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52142 wxEdge arg2 ;
52143 wxWindow *arg3 = (wxWindow *) 0 ;
52144 wxWindow *arg4 = (wxWindow *) 0 ;
52145 int result;
52146 void *argp1 = 0 ;
52147 int res1 = 0 ;
52148 int val2 ;
52149 int ecode2 = 0 ;
52150 void *argp3 = 0 ;
52151 int res3 = 0 ;
52152 void *argp4 = 0 ;
52153 int res4 = 0 ;
52154 PyObject * obj0 = 0 ;
52155 PyObject * obj1 = 0 ;
52156 PyObject * obj2 = 0 ;
52157 PyObject * obj3 = 0 ;
52158 char * kwnames[] = {
52159 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
52160 };
52161
52162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52163 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52164 if (!SWIG_IsOK(res1)) {
52165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52166 }
52167 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52168 ecode2 = SWIG_AsVal_int(obj1, &val2);
52169 if (!SWIG_IsOK(ecode2)) {
52170 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
52171 }
52172 arg2 = static_cast< wxEdge >(val2);
52173 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52174 if (!SWIG_IsOK(res3)) {
52175 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
52176 }
52177 arg3 = reinterpret_cast< wxWindow * >(argp3);
52178 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
52179 if (!SWIG_IsOK(res4)) {
52180 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
52181 }
52182 arg4 = reinterpret_cast< wxWindow * >(argp4);
52183 {
52184 PyThreadState* __tstate = wxPyBeginAllowThreads();
52185 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
52186 wxPyEndAllowThreads(__tstate);
52187 if (PyErr_Occurred()) SWIG_fail;
52188 }
52189 resultobj = SWIG_From_int(static_cast< int >(result));
52190 return resultobj;
52191 fail:
52192 return NULL;
52193 }
52194
52195
52196 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52197 PyObject *obj;
52198 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52199 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
52200 return SWIG_Py_Void();
52201 }
52202
52203 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52204 PyObject *resultobj = 0;
52205 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52206 wxIndividualLayoutConstraint *result = 0 ;
52207 void *argp1 = 0 ;
52208 int res1 = 0 ;
52209 PyObject *swig_obj[1] ;
52210
52211 if (!args) SWIG_fail;
52212 swig_obj[0] = args;
52213 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52214 if (!SWIG_IsOK(res1)) {
52215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52216 }
52217 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52218 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
52219 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52220 return resultobj;
52221 fail:
52222 return NULL;
52223 }
52224
52225
52226 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52227 PyObject *resultobj = 0;
52228 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52229 wxIndividualLayoutConstraint *result = 0 ;
52230 void *argp1 = 0 ;
52231 int res1 = 0 ;
52232 PyObject *swig_obj[1] ;
52233
52234 if (!args) SWIG_fail;
52235 swig_obj[0] = args;
52236 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52237 if (!SWIG_IsOK(res1)) {
52238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52239 }
52240 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52241 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
52242 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52243 return resultobj;
52244 fail:
52245 return NULL;
52246 }
52247
52248
52249 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52250 PyObject *resultobj = 0;
52251 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52252 wxIndividualLayoutConstraint *result = 0 ;
52253 void *argp1 = 0 ;
52254 int res1 = 0 ;
52255 PyObject *swig_obj[1] ;
52256
52257 if (!args) SWIG_fail;
52258 swig_obj[0] = args;
52259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52260 if (!SWIG_IsOK(res1)) {
52261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52262 }
52263 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52264 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
52265 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52266 return resultobj;
52267 fail:
52268 return NULL;
52269 }
52270
52271
52272 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52273 PyObject *resultobj = 0;
52274 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52275 wxIndividualLayoutConstraint *result = 0 ;
52276 void *argp1 = 0 ;
52277 int res1 = 0 ;
52278 PyObject *swig_obj[1] ;
52279
52280 if (!args) SWIG_fail;
52281 swig_obj[0] = args;
52282 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52283 if (!SWIG_IsOK(res1)) {
52284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52285 }
52286 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52287 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
52288 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52289 return resultobj;
52290 fail:
52291 return NULL;
52292 }
52293
52294
52295 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52296 PyObject *resultobj = 0;
52297 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52298 wxIndividualLayoutConstraint *result = 0 ;
52299 void *argp1 = 0 ;
52300 int res1 = 0 ;
52301 PyObject *swig_obj[1] ;
52302
52303 if (!args) SWIG_fail;
52304 swig_obj[0] = args;
52305 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52306 if (!SWIG_IsOK(res1)) {
52307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52308 }
52309 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52310 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
52311 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52312 return resultobj;
52313 fail:
52314 return NULL;
52315 }
52316
52317
52318 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52319 PyObject *resultobj = 0;
52320 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52321 wxIndividualLayoutConstraint *result = 0 ;
52322 void *argp1 = 0 ;
52323 int res1 = 0 ;
52324 PyObject *swig_obj[1] ;
52325
52326 if (!args) SWIG_fail;
52327 swig_obj[0] = args;
52328 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52329 if (!SWIG_IsOK(res1)) {
52330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52331 }
52332 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52333 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
52334 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52335 return resultobj;
52336 fail:
52337 return NULL;
52338 }
52339
52340
52341 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52342 PyObject *resultobj = 0;
52343 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52344 wxIndividualLayoutConstraint *result = 0 ;
52345 void *argp1 = 0 ;
52346 int res1 = 0 ;
52347 PyObject *swig_obj[1] ;
52348
52349 if (!args) SWIG_fail;
52350 swig_obj[0] = args;
52351 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52352 if (!SWIG_IsOK(res1)) {
52353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52354 }
52355 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52356 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
52357 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52358 return resultobj;
52359 fail:
52360 return NULL;
52361 }
52362
52363
52364 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52365 PyObject *resultobj = 0;
52366 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52367 wxIndividualLayoutConstraint *result = 0 ;
52368 void *argp1 = 0 ;
52369 int res1 = 0 ;
52370 PyObject *swig_obj[1] ;
52371
52372 if (!args) SWIG_fail;
52373 swig_obj[0] = args;
52374 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52375 if (!SWIG_IsOK(res1)) {
52376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52377 }
52378 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52379 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
52380 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52381 return resultobj;
52382 fail:
52383 return NULL;
52384 }
52385
52386
52387 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52388 PyObject *resultobj = 0;
52389 wxLayoutConstraints *result = 0 ;
52390
52391 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
52392 {
52393 PyThreadState* __tstate = wxPyBeginAllowThreads();
52394 result = (wxLayoutConstraints *)new wxLayoutConstraints();
52395 wxPyEndAllowThreads(__tstate);
52396 if (PyErr_Occurred()) SWIG_fail;
52397 }
52398 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
52399 return resultobj;
52400 fail:
52401 return NULL;
52402 }
52403
52404
52405 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52406 PyObject *resultobj = 0;
52407 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52408 void *argp1 = 0 ;
52409 int res1 = 0 ;
52410 PyObject *swig_obj[1] ;
52411
52412 if (!args) SWIG_fail;
52413 swig_obj[0] = args;
52414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
52415 if (!SWIG_IsOK(res1)) {
52416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52417 }
52418 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52419 {
52420 PyThreadState* __tstate = wxPyBeginAllowThreads();
52421 delete arg1;
52422
52423 wxPyEndAllowThreads(__tstate);
52424 if (PyErr_Occurred()) SWIG_fail;
52425 }
52426 resultobj = SWIG_Py_Void();
52427 return resultobj;
52428 fail:
52429 return NULL;
52430 }
52431
52432
52433 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52434 PyObject *resultobj = 0;
52435 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52436 wxWindow *arg2 = (wxWindow *) 0 ;
52437 int *arg3 = (int *) 0 ;
52438 bool result;
52439 void *argp1 = 0 ;
52440 int res1 = 0 ;
52441 void *argp2 = 0 ;
52442 int res2 = 0 ;
52443 int temp3 ;
52444 int res3 = SWIG_TMPOBJ ;
52445 PyObject * obj0 = 0 ;
52446 PyObject * obj1 = 0 ;
52447 char * kwnames[] = {
52448 (char *) "self",(char *) "win", NULL
52449 };
52450
52451 arg3 = &temp3;
52452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
52453 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52454 if (!SWIG_IsOK(res1)) {
52455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52456 }
52457 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52458 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52459 if (!SWIG_IsOK(res2)) {
52460 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
52461 }
52462 arg2 = reinterpret_cast< wxWindow * >(argp2);
52463 {
52464 PyThreadState* __tstate = wxPyBeginAllowThreads();
52465 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
52466 wxPyEndAllowThreads(__tstate);
52467 if (PyErr_Occurred()) SWIG_fail;
52468 }
52469 {
52470 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52471 }
52472 if (SWIG_IsTmpObj(res3)) {
52473 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
52474 } else {
52475 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
52476 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
52477 }
52478 return resultobj;
52479 fail:
52480 return NULL;
52481 }
52482
52483
52484 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52485 PyObject *resultobj = 0;
52486 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52487 bool result;
52488 void *argp1 = 0 ;
52489 int res1 = 0 ;
52490 PyObject *swig_obj[1] ;
52491
52492 if (!args) SWIG_fail;
52493 swig_obj[0] = args;
52494 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52495 if (!SWIG_IsOK(res1)) {
52496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
52497 }
52498 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52499 {
52500 PyThreadState* __tstate = wxPyBeginAllowThreads();
52501 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
52502 wxPyEndAllowThreads(__tstate);
52503 if (PyErr_Occurred()) SWIG_fail;
52504 }
52505 {
52506 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52507 }
52508 return resultobj;
52509 fail:
52510 return NULL;
52511 }
52512
52513
52514 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52515 PyObject *obj;
52516 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52517 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
52518 return SWIG_Py_Void();
52519 }
52520
52521 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52522 return SWIG_Python_InitShadowInstance(args);
52523 }
52524
52525 static PyMethodDef SwigMethods[] = {
52526 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
52527 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
52528 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
52529 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
52530 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
52531 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
52532 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
52533 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
52534 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
52535 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
52536 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52537 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52538 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52539 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52540 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
52541 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
52542 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52543 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
52544 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
52545 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
52546 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
52547 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
52548 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
52549 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
52550 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
52551 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
52552 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
52553 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
52554 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
52555 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
52556 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
52557 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
52558 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52559 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52560 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52561 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52562 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52563 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
52564 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
52565 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
52566 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
52567 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
52568 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
52569 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
52570 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
52571 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
52572 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52573 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52574 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52575 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52576 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52577 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
52578 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52579 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
52580 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
52581 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
52582 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
52583 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
52584 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
52585 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
52586 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
52587 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
52588 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
52589 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
52590 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
52591 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
52592 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
52593 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
52594 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
52595 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
52596 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52597 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
52598 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
52599 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
52600 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
52601 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
52602 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
52603 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
52604 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
52605 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
52606 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
52607 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
52608 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
52609 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
52610 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
52611 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
52612 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
52613 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
52614 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
52615 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
52616 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
52617 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
52618 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52619 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52620 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52621 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52622 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
52623 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
52624 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
52625 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
52626 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
52627 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
52628 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
52629 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
52630 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
52631 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
52632 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
52633 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
52634 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52635 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
52636 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
52637 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
52638 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
52639 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
52640 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
52641 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
52642 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
52643 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
52644 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
52645 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
52646 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
52647 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
52648 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
52649 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
52650 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
52651 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
52652 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
52653 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52654 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
52655 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
52656 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
52657 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52658 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52659 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
52660 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
52661 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
52662 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
52663 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52664 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
52665 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
52666 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
52667 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
52668 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
52669 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
52670 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
52671 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
52672 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
52673 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
52674 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
52675 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
52676 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
52677 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
52678 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
52679 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
52680 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
52681 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
52682 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
52683 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
52684 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
52685 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
52686 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
52687 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
52688 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
52689 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
52690 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
52691 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
52692 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
52693 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
52694 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
52695 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
52696 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
52697 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
52698 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
52699 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
52700 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
52701 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
52702 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
52703 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52704 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52705 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52706 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
52707 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
52708 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
52709 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
52710 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
52711 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
52712 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
52713 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
52714 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
52715 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
52716 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
52717 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
52718 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52719 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52720 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
52721 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52722 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
52723 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
52724 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
52725 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
52726 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
52727 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
52728 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52729 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52730 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
52731 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
52732 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
52733 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52734 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52735 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52736 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
52737 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
52738 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
52739 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
52740 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52741 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
52742 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
52743 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
52744 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52745 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52746 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52747 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
52748 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
52749 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
52750 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
52751 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
52752 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
52753 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
52754 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
52755 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
52756 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
52757 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
52758 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
52759 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
52760 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
52761 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
52762 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
52763 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
52764 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
52765 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
52766 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
52767 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
52768 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
52769 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
52770 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
52771 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
52772 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
52773 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
52774 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
52775 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
52776 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
52777 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
52778 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
52779 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
52780 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
52781 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
52782 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
52783 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
52784 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
52785 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
52786 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
52787 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
52788 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
52789 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
52790 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
52791 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
52792 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
52793 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
52794 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
52795 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
52796 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52797 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
52798 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52799 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
52800 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
52801 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
52802 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
52803 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
52804 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
52805 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
52806 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
52807 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
52808 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
52809 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
52810 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52811 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52812 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
52813 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
52814 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
52815 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
52816 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
52817 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52818 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
52819 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
52820 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
52821 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
52822 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
52823 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
52824 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
52825 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
52826 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
52827 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
52828 { (char *)"Image_Ok", (PyCFunction)_wrap_Image_Ok, METH_O, NULL},
52829 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
52830 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
52831 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
52832 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
52833 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
52834 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
52835 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
52836 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
52837 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
52838 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
52839 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
52840 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
52841 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
52842 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
52843 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
52844 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
52845 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
52846 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
52847 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
52848 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
52849 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
52850 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
52851 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
52852 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
52853 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
52854 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
52855 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
52856 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
52857 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
52858 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
52859 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
52860 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
52861 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
52862 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
52863 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
52864 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52865 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52866 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52867 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
52868 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
52869 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52870 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52871 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
52872 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
52873 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
52874 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
52875 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
52876 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
52877 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
52878 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
52879 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
52880 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
52881 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
52882 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
52883 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
52884 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
52885 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
52886 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
52887 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
52888 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
52889 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
52890 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
52891 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
52892 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
52893 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
52894 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
52895 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
52896 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
52897 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
52898 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
52899 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
52900 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
52901 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
52902 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
52903 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
52904 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
52905 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
52906 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
52907 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
52908 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
52909 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
52910 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
52911 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
52912 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
52913 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
52914 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52915 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52916 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
52917 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
52918 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52919 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52920 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
52921 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
52922 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
52923 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
52924 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
52925 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
52926 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
52927 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
52928 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
52929 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
52930 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
52931 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
52932 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
52933 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
52934 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
52935 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
52936 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
52937 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
52938 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
52939 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
52940 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
52941 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
52942 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
52943 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
52944 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
52945 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
52946 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
52947 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
52948 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
52949 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
52950 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
52951 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
52952 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52953 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
52954 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
52955 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
52956 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
52957 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
52958 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
52959 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
52960 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
52961 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
52962 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
52963 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
52964 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
52965 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
52966 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
52967 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52968 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
52969 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
52970 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
52971 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
52972 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
52973 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52974 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
52975 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
52976 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
52977 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52978 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
52979 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
52980 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52981 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
52982 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
52983 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
52984 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52985 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
52986 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
52987 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52988 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
52989 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
52990 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
52991 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
52992 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
52993 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
52994 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
52995 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
52996 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
52997 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
52998 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
52999 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
53000 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
53001 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
53002 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
53003 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
53004 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
53005 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
53006 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
53007 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
53008 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
53009 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
53010 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
53011 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
53012 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
53013 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
53014 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
53015 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
53016 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
53017 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
53018 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53019 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
53020 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
53021 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
53022 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
53023 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
53024 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
53025 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
53026 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
53027 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
53028 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
53029 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
53030 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
53031 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
53032 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
53033 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
53034 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
53035 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
53036 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
53037 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
53038 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
53039 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
53040 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
53041 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
53042 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
53043 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
53044 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
53045 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
53046 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
53047 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
53048 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
53049 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
53050 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
53051 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53052 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
53053 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
53054 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
53055 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
53056 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
53057 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
53058 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
53059 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53060 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
53061 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
53062 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
53063 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
53064 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
53065 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
53066 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
53067 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
53068 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
53069 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
53070 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
53071 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
53072 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
53073 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
53074 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
53075 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
53076 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
53077 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
53078 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
53079 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
53080 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
53081 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
53082 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
53083 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
53084 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
53085 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
53086 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
53087 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
53088 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
53089 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
53090 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
53091 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
53092 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
53093 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
53094 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
53095 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
53096 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
53097 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53098 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
53099 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
53100 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53101 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53102 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
53103 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
53104 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
53105 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
53106 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
53107 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
53108 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53109 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
53110 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
53111 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53112 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53113 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
53114 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
53115 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53116 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
53117 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
53118 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53119 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
53120 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
53121 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53122 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
53123 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
53124 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
53125 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53126 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
53127 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53128 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
53129 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
53130 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53131 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
53132 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
53133 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
53134 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53135 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
53136 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
53137 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
53138 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53139 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
53140 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
53141 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53142 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
53143 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
53144 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
53145 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
53146 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
53147 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53148 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
53149 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
53150 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
53151 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
53152 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
53153 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
53154 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
53155 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
53156 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53157 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
53158 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
53159 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
53160 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
53161 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53162 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
53163 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
53164 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
53165 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53166 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
53167 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
53168 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
53169 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
53170 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
53171 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
53172 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53173 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
53174 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
53175 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
53176 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
53177 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
53178 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
53179 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
53180 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
53181 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53182 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53183 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53184 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
53185 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
53186 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
53187 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
53188 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
53189 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53190 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
53191 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
53192 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
53193 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
53194 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
53195 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
53196 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53197 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
53198 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
53199 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
53200 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
53201 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
53202 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
53203 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53204 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53205 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
53206 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
53207 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
53208 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53209 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
53210 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
53211 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
53212 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
53213 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
53214 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
53215 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
53216 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
53217 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
53218 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
53219 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
53220 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
53221 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
53222 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
53223 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
53224 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
53225 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53226 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
53227 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
53228 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
53229 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53230 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
53231 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
53232 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
53233 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53234 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
53235 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53236 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
53237 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
53238 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
53239 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
53240 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
53241 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53242 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
53243 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
53244 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
53245 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
53246 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53247 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
53248 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
53249 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53250 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
53251 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53252 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
53253 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
53254 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
53255 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53256 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
53257 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53258 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
53259 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
53260 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
53261 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53262 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
53263 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
53264 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
53265 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
53266 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
53267 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
53268 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53269 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
53270 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
53271 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
53272 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
53273 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
53274 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
53275 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
53276 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
53277 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
53278 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
53279 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
53280 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
53281 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
53282 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
53283 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
53284 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
53285 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
53286 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
53287 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
53288 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53289 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
53290 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
53291 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
53292 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
53293 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
53294 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
53295 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
53296 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
53297 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
53298 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
53299 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
53300 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
53301 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
53302 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
53303 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
53304 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53305 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53306 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53307 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
53308 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
53309 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
53310 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
53311 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
53312 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
53313 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
53314 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
53315 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
53316 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
53317 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53318 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
53319 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
53320 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
53321 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
53322 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
53323 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
53324 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
53325 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
53326 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
53327 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
53328 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
53329 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
53330 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
53331 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
53332 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
53333 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
53334 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
53335 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
53336 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
53337 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
53338 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
53339 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53340 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
53341 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
53342 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
53343 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
53344 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
53345 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53346 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
53347 { (char *)"AcceleratorTable_Ok", (PyCFunction)_wrap_AcceleratorTable_Ok, METH_O, NULL},
53348 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
53349 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
53350 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
53351 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
53352 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
53353 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
53354 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
53355 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
53356 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
53357 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
53358 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
53359 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
53360 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
53361 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
53362 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
53363 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53364 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
53365 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
53366 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
53367 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
53368 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53369 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
53370 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
53371 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
53372 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
53373 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
53374 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53375 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
53376 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
53377 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53378 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53379 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53380 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
53381 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53382 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53383 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
53384 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
53385 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
53386 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
53387 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
53388 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
53389 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53390 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
53391 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
53392 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
53393 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
53394 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
53395 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
53396 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
53397 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
53398 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
53399 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
53400 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
53401 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
53402 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
53403 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
53404 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
53405 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
53406 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
53407 { (char *)"Window_GetBestFittingSize", (PyCFunction)_wrap_Window_GetBestFittingSize, METH_O, NULL},
53408 { (char *)"Window_GetAdjustedBestSize", (PyCFunction)_wrap_Window_GetAdjustedBestSize, METH_O, NULL},
53409 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
53410 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
53411 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
53412 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
53413 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53414 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53415 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53416 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53417 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
53418 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
53419 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53420 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
53421 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
53422 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
53423 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
53424 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
53425 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
53426 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53427 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
53428 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
53429 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
53430 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53431 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
53432 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53433 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
53434 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
53435 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
53436 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53437 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
53438 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53439 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
53440 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53441 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
53442 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
53443 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53444 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
53445 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
53446 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
53447 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
53448 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
53449 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
53450 { (char *)"Window_GetDefaultItem", (PyCFunction)_wrap_Window_GetDefaultItem, METH_O, NULL},
53451 { (char *)"Window_SetDefaultItem", (PyCFunction) _wrap_Window_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
53452 { (char *)"Window_SetTmpDefaultItem", (PyCFunction) _wrap_Window_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
53453 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
53454 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53455 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53456 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
53457 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
53458 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
53459 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
53460 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
53461 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
53462 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
53463 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
53464 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
53465 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
53466 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53467 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53468 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53469 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53470 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
53471 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
53472 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
53473 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
53474 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
53475 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
53476 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53477 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
53478 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
53479 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
53480 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
53481 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
53482 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
53483 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
53484 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
53485 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
53486 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
53487 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
53488 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
53489 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
53490 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
53491 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
53492 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
53493 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
53494 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
53495 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
53496 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
53497 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
53498 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
53499 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
53500 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
53501 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53502 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
53503 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
53504 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
53505 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53506 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53507 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53508 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53509 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
53510 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
53511 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
53512 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
53513 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53514 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
53515 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
53516 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
53517 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
53518 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
53519 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
53520 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
53521 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
53522 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
53523 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
53524 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
53525 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
53526 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
53527 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
53528 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
53529 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
53530 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
53531 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
53532 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
53533 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
53534 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
53535 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
53536 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53537 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
53538 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
53539 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
53540 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
53541 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
53542 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
53543 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
53544 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
53545 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
53546 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53547 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
53548 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
53549 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
53550 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
53551 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
53552 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
53553 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
53554 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
53555 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
53556 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
53557 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
53558 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
53559 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
53560 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
53561 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
53562 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
53563 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
53564 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
53565 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
53566 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
53567 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53568 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
53569 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
53570 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53571 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
53572 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
53573 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
53574 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
53575 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
53576 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
53577 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
53578 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53579 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
53580 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
53581 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
53582 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
53583 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
53584 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
53585 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
53586 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
53587 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53588 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
53589 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
53590 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
53591 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
53592 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
53593 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53594 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
53595 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
53596 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
53597 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53598 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
53599 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53600 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53601 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53602 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53603 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
53604 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
53605 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
53606 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
53607 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53608 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
53609 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53610 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53611 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53612 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
53613 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
53614 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53615 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53616 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53617 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53618 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
53619 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
53620 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
53621 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
53622 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
53623 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
53624 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
53625 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
53626 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
53627 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
53628 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53629 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53630 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53631 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53632 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
53633 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53634 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53635 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53636 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53637 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
53638 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
53639 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53640 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
53641 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53642 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
53643 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
53644 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
53645 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
53646 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
53647 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
53648 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
53649 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
53650 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
53651 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
53652 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
53653 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
53654 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53655 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53656 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
53657 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53658 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
53659 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53660 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
53661 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
53662 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
53663 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
53664 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
53665 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
53666 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53667 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53668 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53669 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
53670 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53671 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53672 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53673 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53674 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53675 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
53676 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
53677 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
53678 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
53679 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53680 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
53681 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
53682 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
53683 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
53684 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
53685 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
53686 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53687 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53688 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
53689 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
53690 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
53691 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
53692 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
53693 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
53694 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
53695 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
53696 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
53697 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
53698 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
53699 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53700 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
53701 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53702 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
53703 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53704 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
53705 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
53706 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
53707 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
53708 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
53709 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
53710 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53711 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
53712 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
53713 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
53714 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
53715 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
53716 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53717 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
53718 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
53719 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53720 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
53721 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
53722 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
53723 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
53724 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
53725 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
53726 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
53727 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
53728 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
53729 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
53730 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
53731 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53732 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
53733 { (char *)"Control_GetLabel", (PyCFunction)_wrap_Control_GetLabel, METH_O, NULL},
53734 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
53735 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
53736 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
53737 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53738 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
53739 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53740 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
53741 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
53742 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53743 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53744 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
53745 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
53746 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
53747 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
53748 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
53749 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
53750 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
53751 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
53752 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
53753 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
53754 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
53755 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
53756 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
53757 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
53758 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
53759 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53760 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
53761 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53762 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
53763 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
53764 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
53765 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
53766 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
53767 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
53768 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
53769 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
53770 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
53771 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
53772 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
53773 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
53774 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
53775 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
53776 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
53777 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
53778 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
53779 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
53780 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53781 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
53782 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
53783 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
53784 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
53785 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53786 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
53787 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53788 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
53789 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
53790 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53791 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
53792 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
53793 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
53794 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
53795 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
53796 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
53797 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
53798 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53799 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
53800 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53801 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
53802 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53803 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
53804 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
53805 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53806 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
53807 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
53808 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
53809 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
53810 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53811 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
53812 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
53813 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
53814 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
53815 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
53816 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
53817 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
53818 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
53819 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53820 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53821 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
53822 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
53823 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
53824 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53825 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
53826 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
53827 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
53828 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
53829 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53830 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
53831 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
53832 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53833 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
53834 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
53835 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
53836 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
53837 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53838 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
53839 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
53840 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
53841 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53842 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
53843 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
53844 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
53845 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
53846 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
53847 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
53848 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
53849 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
53850 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
53851 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
53852 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53853 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
53854 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
53855 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
53856 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
53857 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
53858 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
53859 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
53860 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
53861 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
53862 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
53863 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
53864 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
53865 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
53866 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
53867 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
53868 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
53869 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
53870 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
53871 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
53872 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
53873 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
53874 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
53875 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
53876 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
53877 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
53878 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53879 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
53880 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
53881 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
53882 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
53883 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
53884 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53885 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53886 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53887 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
53888 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
53889 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
53890 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
53891 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
53892 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
53893 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
53894 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
53895 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
53896 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53897 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53898 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53899 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
53900 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
53901 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
53902 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
53903 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
53904 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53905 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53906 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
53907 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
53908 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
53909 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
53910 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
53911 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
53912 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
53913 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
53914 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
53915 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53916 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
53917 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
53918 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53919 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
53920 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
53921 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
53922 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
53923 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
53924 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
53925 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
53926 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
53927 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
53928 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
53929 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53930 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53931 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
53932 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
53933 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
53934 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
53935 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53936 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
53937 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
53938 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
53939 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
53940 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
53941 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
53942 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
53943 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
53944 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
53945 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
53946 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
53947 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
53948 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
53949 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
53950 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
53951 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
53952 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
53953 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
53954 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
53955 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
53956 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
53957 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
53958 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
53959 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
53960 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
53961 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
53962 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
53963 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
53964 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
53965 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
53966 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
53967 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
53968 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
53969 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
53970 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
53971 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
53972 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
53973 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
53974 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
53975 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
53976 { NULL, NULL, 0, NULL }
53977 };
53978
53979
53980 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
53981
53982 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
53983 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
53984 }
53985 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
53986 return (void *)((wxSizer *) ((wxBoxSizer *) x));
53987 }
53988 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
53989 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
53990 }
53991 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
53992 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
53993 }
53994 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
53995 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
53996 }
53997 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
53998 return (void *)((wxSizer *) ((wxGridSizer *) x));
53999 }
54000 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
54001 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
54002 }
54003 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
54004 return (void *)((wxSizer *) ((wxPySizer *) x));
54005 }
54006 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
54007 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
54008 }
54009 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
54010 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54011 }
54012 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
54013 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
54014 }
54015 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
54016 return (void *)((wxEvent *) ((wxMenuEvent *) x));
54017 }
54018 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
54019 return (void *)((wxEvent *) ((wxCloseEvent *) x));
54020 }
54021 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
54022 return (void *)((wxEvent *) ((wxMouseEvent *) x));
54023 }
54024 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
54025 return (void *)((wxEvent *) ((wxEraseEvent *) x));
54026 }
54027 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
54028 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
54029 }
54030 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
54031 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
54032 }
54033 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
54034 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
54035 }
54036 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
54037 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
54038 }
54039 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
54040 return (void *)((wxEvent *) ((wxPyEvent *) x));
54041 }
54042 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
54043 return (void *)((wxEvent *) ((wxIdleEvent *) x));
54044 }
54045 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
54046 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
54047 }
54048 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
54049 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
54050 }
54051 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
54052 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
54053 }
54054 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
54055 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
54056 }
54057 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
54058 return (void *)((wxEvent *) ((wxActivateEvent *) x));
54059 }
54060 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
54061 return (void *)((wxEvent *) ((wxSizeEvent *) x));
54062 }
54063 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
54064 return (void *)((wxEvent *) ((wxMoveEvent *) x));
54065 }
54066 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
54067 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
54068 }
54069 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
54070 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
54071 }
54072 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
54073 return (void *)((wxEvent *) ((wxPaintEvent *) x));
54074 }
54075 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
54076 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
54077 }
54078 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
54079 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
54080 }
54081 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
54082 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
54083 }
54084 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
54085 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
54086 }
54087 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
54088 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
54089 }
54090 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
54091 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
54092 }
54093 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
54094 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
54095 }
54096 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
54097 return (void *)((wxEvent *) ((wxFocusEvent *) x));
54098 }
54099 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
54100 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
54101 }
54102 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
54103 return (void *)((wxEvent *) ((wxShowEvent *) x));
54104 }
54105 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
54106 return (void *)((wxEvent *) ((wxCommandEvent *) x));
54107 }
54108 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
54109 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
54110 }
54111 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
54112 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54113 }
54114 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
54115 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
54116 }
54117 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
54118 return (void *)((wxEvent *) ((wxKeyEvent *) x));
54119 }
54120 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
54121 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
54122 }
54123 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
54124 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
54125 }
54126 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
54127 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
54128 }
54129 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
54130 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
54131 }
54132 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
54133 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
54134 }
54135 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
54136 return (void *)((wxControl *) ((wxControlWithItems *) x));
54137 }
54138 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
54139 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
54140 }
54141 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
54142 return (void *)((wxEvtHandler *) ((wxWindow *) x));
54143 }
54144 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
54145 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
54146 }
54147 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
54148 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
54149 }
54150 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
54151 return (void *)((wxEvtHandler *) ((wxValidator *) x));
54152 }
54153 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
54154 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
54155 }
54156 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
54157 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
54158 }
54159 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
54160 return (void *)((wxEvtHandler *) ((wxMenu *) x));
54161 }
54162 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
54163 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
54164 }
54165 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
54166 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
54167 }
54168 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
54169 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
54170 }
54171 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
54172 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
54173 }
54174 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
54175 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
54176 }
54177 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
54178 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54179 }
54180 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
54181 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
54182 }
54183 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
54184 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
54185 }
54186 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
54187 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
54188 }
54189 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
54190 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54191 }
54192 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
54193 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54194 }
54195 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
54196 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
54197 }
54198 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
54199 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
54200 }
54201 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
54202 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
54203 }
54204 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
54205 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
54206 }
54207 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
54208 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
54209 }
54210 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
54211 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
54212 }
54213 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
54214 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
54215 }
54216 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
54217 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
54218 }
54219 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
54220 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
54221 }
54222 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
54223 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
54224 }
54225 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
54226 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
54227 }
54228 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
54229 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
54230 }
54231 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
54232 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
54233 }
54234 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
54235 return (void *)((wxObject *) ((wxSizerItem *) x));
54236 }
54237 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
54238 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
54239 }
54240 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
54241 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
54242 }
54243 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
54244 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
54245 }
54246 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
54247 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
54248 }
54249 static void *_p_wxSizerTo_p_wxObject(void *x) {
54250 return (void *)((wxObject *) ((wxSizer *) x));
54251 }
54252 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
54253 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
54254 }
54255 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
54256 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
54257 }
54258 static void *_p_wxEventTo_p_wxObject(void *x) {
54259 return (void *)((wxObject *) ((wxEvent *) x));
54260 }
54261 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
54262 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
54263 }
54264 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
54265 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
54266 }
54267 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
54268 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
54269 }
54270 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
54271 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
54272 }
54273 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
54274 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
54275 }
54276 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
54277 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
54278 }
54279 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
54280 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
54281 }
54282 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
54283 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
54284 }
54285 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
54286 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
54287 }
54288 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
54289 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
54290 }
54291 static void *_p_wxControlTo_p_wxObject(void *x) {
54292 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
54293 }
54294 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
54295 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
54296 }
54297 static void *_p_wxFSFileTo_p_wxObject(void *x) {
54298 return (void *)((wxObject *) ((wxFSFile *) x));
54299 }
54300 static void *_p_wxPySizerTo_p_wxObject(void *x) {
54301 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
54302 }
54303 static void *_p_wxPyEventTo_p_wxObject(void *x) {
54304 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
54305 }
54306 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
54307 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
54308 }
54309 static void *_p_wxShowEventTo_p_wxObject(void *x) {
54310 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
54311 }
54312 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
54313 return (void *)((wxObject *) ((wxMenuItem *) x));
54314 }
54315 static void *_p_wxDateEventTo_p_wxObject(void *x) {
54316 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
54317 }
54318 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
54319 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
54320 }
54321 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
54322 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
54323 }
54324 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
54325 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
54326 }
54327 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
54328 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
54329 }
54330 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
54331 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
54332 }
54333 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
54334 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
54335 }
54336 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
54337 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
54338 }
54339 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
54340 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
54341 }
54342 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
54343 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
54344 }
54345 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
54346 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
54347 }
54348 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
54349 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
54350 }
54351 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
54352 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
54353 }
54354 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
54355 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
54356 }
54357 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
54358 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54359 }
54360 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
54361 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54362 }
54363 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
54364 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
54365 }
54366 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
54367 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
54368 }
54369 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
54370 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
54371 }
54372 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
54373 return (void *)((wxObject *) ((wxImageHandler *) x));
54374 }
54375 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
54376 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
54377 }
54378 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
54379 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
54380 }
54381 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
54382 return (void *)((wxObject *) ((wxEvtHandler *) x));
54383 }
54384 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
54385 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54386 }
54387 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
54388 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
54389 }
54390 static void *_p_wxImageTo_p_wxObject(void *x) {
54391 return (void *)((wxObject *) ((wxImage *) x));
54392 }
54393 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
54394 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
54395 }
54396 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
54397 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54398 }
54399 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
54400 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
54401 }
54402 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
54403 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
54404 }
54405 static void *_p_wxWindowTo_p_wxObject(void *x) {
54406 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
54407 }
54408 static void *_p_wxMenuTo_p_wxObject(void *x) {
54409 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
54410 }
54411 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
54412 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
54413 }
54414 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
54415 return (void *)((wxObject *) ((wxFileSystem *) x));
54416 }
54417 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
54418 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
54419 }
54420 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
54421 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
54422 }
54423 static void *_p_wxPyAppTo_p_wxObject(void *x) {
54424 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
54425 }
54426 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
54427 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
54428 }
54429 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
54430 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
54431 }
54432 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
54433 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
54434 }
54435 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
54436 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
54437 }
54438 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
54439 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
54440 }
54441 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
54442 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
54443 }
54444 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
54445 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
54446 }
54447 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
54448 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
54449 }
54450 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
54451 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
54452 }
54453 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
54454 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
54455 }
54456 static void *_p_wxValidatorTo_p_wxObject(void *x) {
54457 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
54458 }
54459 static void *_p_wxControlTo_p_wxWindow(void *x) {
54460 return (void *)((wxWindow *) ((wxControl *) x));
54461 }
54462 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
54463 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
54464 }
54465 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
54466 return (void *)((wxWindow *) ((wxMenuBar *) x));
54467 }
54468 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
54469 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
54470 }
54471 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
54472 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
54473 }
54474 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
54475 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
54476 }
54477 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
54478 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
54479 }
54480 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
54481 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
54482 }
54483 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
54484 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
54485 }
54486 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
54487 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54488 }
54489 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
54490 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
54491 }
54492 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
54493 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
54494 }
54495 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
54496 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
54497 }
54498 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
54499 return (void *)((wxValidator *) ((wxPyValidator *) x));
54500 }
54501 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
54502 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
54503 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};
54504 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
54505 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
54506 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
54507 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
54508 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
54509 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
54510 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
54511 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
54512 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
54513 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
54514 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
54515 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
54516 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
54517 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
54518 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
54519 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
54520 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
54521 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
54522 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
54523 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
54524 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
54525 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
54526 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
54527 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
54528 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
54529 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
54530 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
54531 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
54532 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
54533 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
54534 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
54535 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
54536 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
54537 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
54538 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
54539 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
54540 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
54541 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
54542 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
54543 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
54544 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
54545 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
54546 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
54547 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
54548 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
54549 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
54550 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
54551 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
54552 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
54553 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
54554 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
54555 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
54556 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
54557 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
54558 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
54559 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
54560 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
54561 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
54562 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
54563 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
54564 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
54565 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
54566 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
54567 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
54568 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
54569 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
54570 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
54571 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
54572 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
54573 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
54574 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
54575 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
54576 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
54577 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
54578 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
54579 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
54580 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
54581 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
54582 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
54583 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
54584 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
54585 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
54586 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
54587 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
54588 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
54589 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
54590 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
54591 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
54592 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
54593 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
54594 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
54595 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
54596 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
54597 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
54598 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
54599 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
54600 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
54601 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
54602 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
54603 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
54604 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
54605 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
54606 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
54607 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
54608 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
54609 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
54610 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
54611 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
54612 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
54613 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
54614 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
54615 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
54616 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
54617 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
54618 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
54619 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
54620 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
54621 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
54622 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
54623 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
54624 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
54625 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
54626 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
54627 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
54628 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
54629 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
54630 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
54631
54632 static swig_type_info *swig_type_initial[] = {
54633 &_swigt__p_buffer,
54634 &_swigt__p_char,
54635 &_swigt__p_form_ops_t,
54636 &_swigt__p_int,
54637 &_swigt__p_long,
54638 &_swigt__p_unsigned_char,
54639 &_swigt__p_unsigned_int,
54640 &_swigt__p_unsigned_long,
54641 &_swigt__p_wxANIHandler,
54642 &_swigt__p_wxAcceleratorEntry,
54643 &_swigt__p_wxAcceleratorTable,
54644 &_swigt__p_wxActivateEvent,
54645 &_swigt__p_wxAppTraits,
54646 &_swigt__p_wxArrayString,
54647 &_swigt__p_wxBMPHandler,
54648 &_swigt__p_wxBitmap,
54649 &_swigt__p_wxBoxSizer,
54650 &_swigt__p_wxButton,
54651 &_swigt__p_wxCURHandler,
54652 &_swigt__p_wxCaret,
54653 &_swigt__p_wxChildFocusEvent,
54654 &_swigt__p_wxClipboardTextEvent,
54655 &_swigt__p_wxCloseEvent,
54656 &_swigt__p_wxColour,
54657 &_swigt__p_wxCommandEvent,
54658 &_swigt__p_wxContextMenuEvent,
54659 &_swigt__p_wxControl,
54660 &_swigt__p_wxControlWithItems,
54661 &_swigt__p_wxCursor,
54662 &_swigt__p_wxDC,
54663 &_swigt__p_wxDateEvent,
54664 &_swigt__p_wxDateTime,
54665 &_swigt__p_wxDisplayChangedEvent,
54666 &_swigt__p_wxDropFilesEvent,
54667 &_swigt__p_wxDuplexMode,
54668 &_swigt__p_wxEraseEvent,
54669 &_swigt__p_wxEvent,
54670 &_swigt__p_wxEventLoop,
54671 &_swigt__p_wxEventLoopActivator,
54672 &_swigt__p_wxEvtHandler,
54673 &_swigt__p_wxFSFile,
54674 &_swigt__p_wxFileSystem,
54675 &_swigt__p_wxFileSystemHandler,
54676 &_swigt__p_wxFlexGridSizer,
54677 &_swigt__p_wxFocusEvent,
54678 &_swigt__p_wxFont,
54679 &_swigt__p_wxFrame,
54680 &_swigt__p_wxGBPosition,
54681 &_swigt__p_wxGBSizerItem,
54682 &_swigt__p_wxGBSpan,
54683 &_swigt__p_wxGIFHandler,
54684 &_swigt__p_wxGridBagSizer,
54685 &_swigt__p_wxGridSizer,
54686 &_swigt__p_wxICOHandler,
54687 &_swigt__p_wxIconizeEvent,
54688 &_swigt__p_wxIdleEvent,
54689 &_swigt__p_wxImage,
54690 &_swigt__p_wxImageHandler,
54691 &_swigt__p_wxImageHistogram,
54692 &_swigt__p_wxImage_HSVValue,
54693 &_swigt__p_wxImage_RGBValue,
54694 &_swigt__p_wxIndividualLayoutConstraint,
54695 &_swigt__p_wxInitDialogEvent,
54696 &_swigt__p_wxInputStream,
54697 &_swigt__p_wxInternetFSHandler,
54698 &_swigt__p_wxItemContainer,
54699 &_swigt__p_wxJPEGHandler,
54700 &_swigt__p_wxKeyEvent,
54701 &_swigt__p_wxLayoutConstraints,
54702 &_swigt__p_wxMaximizeEvent,
54703 &_swigt__p_wxMemoryFSHandler,
54704 &_swigt__p_wxMenu,
54705 &_swigt__p_wxMenuBar,
54706 &_swigt__p_wxMenuBarBase,
54707 &_swigt__p_wxMenuEvent,
54708 &_swigt__p_wxMenuItem,
54709 &_swigt__p_wxMouseCaptureChangedEvent,
54710 &_swigt__p_wxMouseEvent,
54711 &_swigt__p_wxMoveEvent,
54712 &_swigt__p_wxNavigationKeyEvent,
54713 &_swigt__p_wxNcPaintEvent,
54714 &_swigt__p_wxNotifyEvent,
54715 &_swigt__p_wxObject,
54716 &_swigt__p_wxOutputStream,
54717 &_swigt__p_wxPCXHandler,
54718 &_swigt__p_wxPNGHandler,
54719 &_swigt__p_wxPNMHandler,
54720 &_swigt__p_wxPaintEvent,
54721 &_swigt__p_wxPaletteChangedEvent,
54722 &_swigt__p_wxPaperSize,
54723 &_swigt__p_wxPoint,
54724 &_swigt__p_wxPoint2D,
54725 &_swigt__p_wxPropagateOnce,
54726 &_swigt__p_wxPropagationDisabler,
54727 &_swigt__p_wxPyApp,
54728 &_swigt__p_wxPyCommandEvent,
54729 &_swigt__p_wxPyDropTarget,
54730 &_swigt__p_wxPyEvent,
54731 &_swigt__p_wxPyFileSystemHandler,
54732 &_swigt__p_wxPyImageHandler,
54733 &_swigt__p_wxPyInputStream,
54734 &_swigt__p_wxPySizer,
54735 &_swigt__p_wxPyValidator,
54736 &_swigt__p_wxQuantize,
54737 &_swigt__p_wxQueryNewPaletteEvent,
54738 &_swigt__p_wxRealPoint,
54739 &_swigt__p_wxRect,
54740 &_swigt__p_wxRegion,
54741 &_swigt__p_wxScrollEvent,
54742 &_swigt__p_wxScrollWinEvent,
54743 &_swigt__p_wxSetCursorEvent,
54744 &_swigt__p_wxShowEvent,
54745 &_swigt__p_wxSize,
54746 &_swigt__p_wxSizeEvent,
54747 &_swigt__p_wxSizer,
54748 &_swigt__p_wxSizerItem,
54749 &_swigt__p_wxStaticBox,
54750 &_swigt__p_wxStaticBoxSizer,
54751 &_swigt__p_wxStdDialogButtonSizer,
54752 &_swigt__p_wxSysColourChangedEvent,
54753 &_swigt__p_wxTIFFHandler,
54754 &_swigt__p_wxToolTip,
54755 &_swigt__p_wxUpdateUIEvent,
54756 &_swigt__p_wxValidator,
54757 &_swigt__p_wxVisualAttributes,
54758 &_swigt__p_wxWindow,
54759 &_swigt__p_wxWindowCreateEvent,
54760 &_swigt__p_wxWindowDestroyEvent,
54761 &_swigt__p_wxXPMHandler,
54762 &_swigt__p_wxZipFSHandler,
54763 };
54764
54765 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
54766 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
54767 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
54768 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
54769 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
54770 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
54771 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
54772 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
54773 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
54774 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
54775 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
54776 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
54777 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
54778 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
54779 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}};
54780 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
54781 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}};
54782 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
54783 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}};
54784 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
54785 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
54786 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
54787 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
54788 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
54789 static swig_cast_info _swigc__p_wxCommandEvent[] = { {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxCommandEvent, 0, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxCommandEvent, 0, 0},{0, 0, 0, 0}};
54790 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
54791 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}};
54792 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
54793 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
54794 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
54795 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
54796 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
54797 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54798 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
54799 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
54800 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
54801 static swig_cast_info _swigc__p_wxEvent[] = { {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_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_wxClipboardTextEvent, _p_wxClipboardTextEventTo_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}};
54802 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
54803 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
54804 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}};
54805 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
54806 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
54807 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}};
54808 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}};
54809 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
54810 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
54811 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
54812 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
54813 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
54814 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
54815 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
54816 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
54817 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}};
54818 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}};
54819 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
54820 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
54821 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
54822 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}};
54823 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
54824 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
54825 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
54826 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
54827 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
54828 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
54829 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
54830 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}};
54831 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
54832 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
54833 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
54834 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
54835 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
54836 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
54837 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
54838 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
54839 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
54840 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
54841 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54842 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
54843 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
54844 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
54845 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
54846 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
54847 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_wxClipboardTextEvent, _p_wxClipboardTextEventTo_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_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_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_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_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxAcceleratorTable, _p_wxAcceleratorTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxImage, _p_wxImageTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxObject, 0, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileSystem, _p_wxFileSystemTo_p_wxObject, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxObject, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxObject, 0, 0}, {&_swigt__p_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}};
54848 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
54849 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
54850 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
54851 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
54852 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
54853 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54854 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
54855 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
54856 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
54857 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
54858 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
54859 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
54860 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
54861 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
54862 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
54863 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
54864 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
54865 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
54866 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
54867 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
54868 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
54869 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
54870 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
54871 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
54872 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
54873 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
54874 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
54875 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
54876 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
54877 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
54878 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
54879 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}};
54880 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}};
54881 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
54882 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
54883 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
54884 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54885 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
54886 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
54887 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
54888 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}};
54889 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
54890 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}};
54891 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
54892 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
54893 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
54894 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
54895
54896 static swig_cast_info *swig_cast_initial[] = {
54897 _swigc__p_buffer,
54898 _swigc__p_char,
54899 _swigc__p_form_ops_t,
54900 _swigc__p_int,
54901 _swigc__p_long,
54902 _swigc__p_unsigned_char,
54903 _swigc__p_unsigned_int,
54904 _swigc__p_unsigned_long,
54905 _swigc__p_wxANIHandler,
54906 _swigc__p_wxAcceleratorEntry,
54907 _swigc__p_wxAcceleratorTable,
54908 _swigc__p_wxActivateEvent,
54909 _swigc__p_wxAppTraits,
54910 _swigc__p_wxArrayString,
54911 _swigc__p_wxBMPHandler,
54912 _swigc__p_wxBitmap,
54913 _swigc__p_wxBoxSizer,
54914 _swigc__p_wxButton,
54915 _swigc__p_wxCURHandler,
54916 _swigc__p_wxCaret,
54917 _swigc__p_wxChildFocusEvent,
54918 _swigc__p_wxClipboardTextEvent,
54919 _swigc__p_wxCloseEvent,
54920 _swigc__p_wxColour,
54921 _swigc__p_wxCommandEvent,
54922 _swigc__p_wxContextMenuEvent,
54923 _swigc__p_wxControl,
54924 _swigc__p_wxControlWithItems,
54925 _swigc__p_wxCursor,
54926 _swigc__p_wxDC,
54927 _swigc__p_wxDateEvent,
54928 _swigc__p_wxDateTime,
54929 _swigc__p_wxDisplayChangedEvent,
54930 _swigc__p_wxDropFilesEvent,
54931 _swigc__p_wxDuplexMode,
54932 _swigc__p_wxEraseEvent,
54933 _swigc__p_wxEvent,
54934 _swigc__p_wxEventLoop,
54935 _swigc__p_wxEventLoopActivator,
54936 _swigc__p_wxEvtHandler,
54937 _swigc__p_wxFSFile,
54938 _swigc__p_wxFileSystem,
54939 _swigc__p_wxFileSystemHandler,
54940 _swigc__p_wxFlexGridSizer,
54941 _swigc__p_wxFocusEvent,
54942 _swigc__p_wxFont,
54943 _swigc__p_wxFrame,
54944 _swigc__p_wxGBPosition,
54945 _swigc__p_wxGBSizerItem,
54946 _swigc__p_wxGBSpan,
54947 _swigc__p_wxGIFHandler,
54948 _swigc__p_wxGridBagSizer,
54949 _swigc__p_wxGridSizer,
54950 _swigc__p_wxICOHandler,
54951 _swigc__p_wxIconizeEvent,
54952 _swigc__p_wxIdleEvent,
54953 _swigc__p_wxImage,
54954 _swigc__p_wxImageHandler,
54955 _swigc__p_wxImageHistogram,
54956 _swigc__p_wxImage_HSVValue,
54957 _swigc__p_wxImage_RGBValue,
54958 _swigc__p_wxIndividualLayoutConstraint,
54959 _swigc__p_wxInitDialogEvent,
54960 _swigc__p_wxInputStream,
54961 _swigc__p_wxInternetFSHandler,
54962 _swigc__p_wxItemContainer,
54963 _swigc__p_wxJPEGHandler,
54964 _swigc__p_wxKeyEvent,
54965 _swigc__p_wxLayoutConstraints,
54966 _swigc__p_wxMaximizeEvent,
54967 _swigc__p_wxMemoryFSHandler,
54968 _swigc__p_wxMenu,
54969 _swigc__p_wxMenuBar,
54970 _swigc__p_wxMenuBarBase,
54971 _swigc__p_wxMenuEvent,
54972 _swigc__p_wxMenuItem,
54973 _swigc__p_wxMouseCaptureChangedEvent,
54974 _swigc__p_wxMouseEvent,
54975 _swigc__p_wxMoveEvent,
54976 _swigc__p_wxNavigationKeyEvent,
54977 _swigc__p_wxNcPaintEvent,
54978 _swigc__p_wxNotifyEvent,
54979 _swigc__p_wxObject,
54980 _swigc__p_wxOutputStream,
54981 _swigc__p_wxPCXHandler,
54982 _swigc__p_wxPNGHandler,
54983 _swigc__p_wxPNMHandler,
54984 _swigc__p_wxPaintEvent,
54985 _swigc__p_wxPaletteChangedEvent,
54986 _swigc__p_wxPaperSize,
54987 _swigc__p_wxPoint,
54988 _swigc__p_wxPoint2D,
54989 _swigc__p_wxPropagateOnce,
54990 _swigc__p_wxPropagationDisabler,
54991 _swigc__p_wxPyApp,
54992 _swigc__p_wxPyCommandEvent,
54993 _swigc__p_wxPyDropTarget,
54994 _swigc__p_wxPyEvent,
54995 _swigc__p_wxPyFileSystemHandler,
54996 _swigc__p_wxPyImageHandler,
54997 _swigc__p_wxPyInputStream,
54998 _swigc__p_wxPySizer,
54999 _swigc__p_wxPyValidator,
55000 _swigc__p_wxQuantize,
55001 _swigc__p_wxQueryNewPaletteEvent,
55002 _swigc__p_wxRealPoint,
55003 _swigc__p_wxRect,
55004 _swigc__p_wxRegion,
55005 _swigc__p_wxScrollEvent,
55006 _swigc__p_wxScrollWinEvent,
55007 _swigc__p_wxSetCursorEvent,
55008 _swigc__p_wxShowEvent,
55009 _swigc__p_wxSize,
55010 _swigc__p_wxSizeEvent,
55011 _swigc__p_wxSizer,
55012 _swigc__p_wxSizerItem,
55013 _swigc__p_wxStaticBox,
55014 _swigc__p_wxStaticBoxSizer,
55015 _swigc__p_wxStdDialogButtonSizer,
55016 _swigc__p_wxSysColourChangedEvent,
55017 _swigc__p_wxTIFFHandler,
55018 _swigc__p_wxToolTip,
55019 _swigc__p_wxUpdateUIEvent,
55020 _swigc__p_wxValidator,
55021 _swigc__p_wxVisualAttributes,
55022 _swigc__p_wxWindow,
55023 _swigc__p_wxWindowCreateEvent,
55024 _swigc__p_wxWindowDestroyEvent,
55025 _swigc__p_wxXPMHandler,
55026 _swigc__p_wxZipFSHandler,
55027 };
55028
55029
55030 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
55031
55032 static swig_const_info swig_const_table[] = {
55033 {0, 0, 0, 0.0, 0, 0}};
55034
55035 #ifdef __cplusplus
55036 }
55037 #endif
55038 /* -----------------------------------------------------------------------------
55039 * Type initialization:
55040 * This problem is tough by the requirement that no dynamic
55041 * memory is used. Also, since swig_type_info structures store pointers to
55042 * swig_cast_info structures and swig_cast_info structures store pointers back
55043 * to swig_type_info structures, we need some lookup code at initialization.
55044 * The idea is that swig generates all the structures that are needed.
55045 * The runtime then collects these partially filled structures.
55046 * The SWIG_InitializeModule function takes these initial arrays out of
55047 * swig_module, and does all the lookup, filling in the swig_module.types
55048 * array with the correct data and linking the correct swig_cast_info
55049 * structures together.
55050 *
55051 * The generated swig_type_info structures are assigned staticly to an initial
55052 * array. We just loop though that array, and handle each type individually.
55053 * First we lookup if this type has been already loaded, and if so, use the
55054 * loaded structure instead of the generated one. Then we have to fill in the
55055 * cast linked list. The cast data is initially stored in something like a
55056 * two-dimensional array. Each row corresponds to a type (there are the same
55057 * number of rows as there are in the swig_type_initial array). Each entry in
55058 * a column is one of the swig_cast_info structures for that type.
55059 * The cast_initial array is actually an array of arrays, because each row has
55060 * a variable number of columns. So to actually build the cast linked list,
55061 * we find the array of casts associated with the type, and loop through it
55062 * adding the casts to the list. The one last trick we need to do is making
55063 * sure the type pointer in the swig_cast_info struct is correct.
55064 *
55065 * First off, we lookup the cast->type name to see if it is already loaded.
55066 * There are three cases to handle:
55067 * 1) If the cast->type has already been loaded AND the type we are adding
55068 * casting info to has not been loaded (it is in this module), THEN we
55069 * replace the cast->type pointer with the type pointer that has already
55070 * been loaded.
55071 * 2) If BOTH types (the one we are adding casting info to, and the
55072 * cast->type) are loaded, THEN the cast info has already been loaded by
55073 * the previous module so we just ignore it.
55074 * 3) Finally, if cast->type has not already been loaded, then we add that
55075 * swig_cast_info to the linked list (because the cast->type) pointer will
55076 * be correct.
55077 * ----------------------------------------------------------------------------- */
55078
55079 #ifdef __cplusplus
55080 extern "C" {
55081 #if 0
55082 } /* c-mode */
55083 #endif
55084 #endif
55085
55086 #if 0
55087 #define SWIGRUNTIME_DEBUG
55088 #endif
55089
55090 SWIGRUNTIME void
55091 SWIG_InitializeModule(void *clientdata) {
55092 size_t i;
55093 swig_module_info *module_head;
55094 static int init_run = 0;
55095
55096 clientdata = clientdata;
55097
55098 if (init_run) return;
55099 init_run = 1;
55100
55101 /* Initialize the swig_module */
55102 swig_module.type_initial = swig_type_initial;
55103 swig_module.cast_initial = swig_cast_initial;
55104
55105 /* Try and load any already created modules */
55106 module_head = SWIG_GetModule(clientdata);
55107 if (module_head) {
55108 swig_module.next = module_head->next;
55109 module_head->next = &swig_module;
55110 } else {
55111 /* This is the first module loaded */
55112 swig_module.next = &swig_module;
55113 SWIG_SetModule(clientdata, &swig_module);
55114 }
55115
55116 /* Now work on filling in swig_module.types */
55117 #ifdef SWIGRUNTIME_DEBUG
55118 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
55119 #endif
55120 for (i = 0; i < swig_module.size; ++i) {
55121 swig_type_info *type = 0;
55122 swig_type_info *ret;
55123 swig_cast_info *cast;
55124
55125 #ifdef SWIGRUNTIME_DEBUG
55126 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
55127 #endif
55128
55129 /* if there is another module already loaded */
55130 if (swig_module.next != &swig_module) {
55131 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
55132 }
55133 if (type) {
55134 /* Overwrite clientdata field */
55135 #ifdef SWIGRUNTIME_DEBUG
55136 printf("SWIG_InitializeModule: found type %s\n", type->name);
55137 #endif
55138 if (swig_module.type_initial[i]->clientdata) {
55139 type->clientdata = swig_module.type_initial[i]->clientdata;
55140 #ifdef SWIGRUNTIME_DEBUG
55141 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
55142 #endif
55143 }
55144 } else {
55145 type = swig_module.type_initial[i];
55146 }
55147
55148 /* Insert casting types */
55149 cast = swig_module.cast_initial[i];
55150 while (cast->type) {
55151 /* Don't need to add information already in the list */
55152 ret = 0;
55153 #ifdef SWIGRUNTIME_DEBUG
55154 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
55155 #endif
55156 if (swig_module.next != &swig_module) {
55157 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
55158 #ifdef SWIGRUNTIME_DEBUG
55159 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
55160 #endif
55161 }
55162 if (ret) {
55163 if (type == swig_module.type_initial[i]) {
55164 #ifdef SWIGRUNTIME_DEBUG
55165 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
55166 #endif
55167 cast->type = ret;
55168 ret = 0;
55169 } else {
55170 /* Check for casting already in the list */
55171 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
55172 #ifdef SWIGRUNTIME_DEBUG
55173 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
55174 #endif
55175 if (!ocast) ret = 0;
55176 }
55177 }
55178
55179 if (!ret) {
55180 #ifdef SWIGRUNTIME_DEBUG
55181 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
55182 #endif
55183 if (type->cast) {
55184 type->cast->prev = cast;
55185 cast->next = type->cast;
55186 }
55187 type->cast = cast;
55188 }
55189 cast++;
55190 }
55191 /* Set entry in modules->types array equal to the type */
55192 swig_module.types[i] = type;
55193 }
55194 swig_module.types[i] = 0;
55195
55196 #ifdef SWIGRUNTIME_DEBUG
55197 printf("**** SWIG_InitializeModule: Cast List ******\n");
55198 for (i = 0; i < swig_module.size; ++i) {
55199 int j = 0;
55200 swig_cast_info *cast = swig_module.cast_initial[i];
55201 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
55202 while (cast->type) {
55203 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
55204 cast++;
55205 ++j;
55206 }
55207 printf("---- Total casts: %d\n",j);
55208 }
55209 printf("**** SWIG_InitializeModule: Cast List ******\n");
55210 #endif
55211 }
55212
55213 /* This function will propagate the clientdata field of type to
55214 * any new swig_type_info structures that have been added into the list
55215 * of equivalent types. It is like calling
55216 * SWIG_TypeClientData(type, clientdata) a second time.
55217 */
55218 SWIGRUNTIME void
55219 SWIG_PropagateClientData(void) {
55220 size_t i;
55221 swig_cast_info *equiv;
55222 static int init_run = 0;
55223
55224 if (init_run) return;
55225 init_run = 1;
55226
55227 for (i = 0; i < swig_module.size; i++) {
55228 if (swig_module.types[i]->clientdata) {
55229 equiv = swig_module.types[i]->cast;
55230 while (equiv) {
55231 if (!equiv->converter) {
55232 if (equiv->type && !equiv->type->clientdata)
55233 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
55234 }
55235 equiv = equiv->next;
55236 }
55237 }
55238 }
55239 }
55240
55241 #ifdef __cplusplus
55242 #if 0
55243 {
55244 /* c-mode */
55245 #endif
55246 }
55247 #endif
55248
55249
55250
55251 #ifdef __cplusplus
55252 extern "C" {
55253 #endif
55254
55255 /* Python-specific SWIG API */
55256 #define SWIG_newvarlink() SWIG_Python_newvarlink()
55257 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
55258 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
55259
55260 /* -----------------------------------------------------------------------------
55261 * global variable support code.
55262 * ----------------------------------------------------------------------------- */
55263
55264 typedef struct swig_globalvar {
55265 char *name; /* Name of global variable */
55266 PyObject *(*get_attr)(void); /* Return the current value */
55267 int (*set_attr)(PyObject *); /* Set the value */
55268 struct swig_globalvar *next;
55269 } swig_globalvar;
55270
55271 typedef struct swig_varlinkobject {
55272 PyObject_HEAD
55273 swig_globalvar *vars;
55274 } swig_varlinkobject;
55275
55276 SWIGINTERN PyObject *
55277 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
55278 return PyString_FromString("<Swig global variables>");
55279 }
55280
55281 SWIGINTERN PyObject *
55282 swig_varlink_str(swig_varlinkobject *v) {
55283 PyObject *str = PyString_FromString("(");
55284 swig_globalvar *var;
55285 for (var = v->vars; var; var=var->next) {
55286 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
55287 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
55288 }
55289 PyString_ConcatAndDel(&str,PyString_FromString(")"));
55290 return str;
55291 }
55292
55293 SWIGINTERN int
55294 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
55295 PyObject *str = swig_varlink_str(v);
55296 fprintf(fp,"Swig global variables ");
55297 fprintf(fp,"%s\n", PyString_AsString(str));
55298 Py_DECREF(str);
55299 return 0;
55300 }
55301
55302 SWIGINTERN void
55303 swig_varlink_dealloc(swig_varlinkobject *v) {
55304 swig_globalvar *var = v->vars;
55305 while (var) {
55306 swig_globalvar *n = var->next;
55307 free(var->name);
55308 free(var);
55309 var = n;
55310 }
55311 }
55312
55313 SWIGINTERN PyObject *
55314 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
55315 PyObject *res = NULL;
55316 swig_globalvar *var = v->vars;
55317 while (var) {
55318 if (strcmp(var->name,n) == 0) {
55319 res = (*var->get_attr)();
55320 break;
55321 }
55322 var = var->next;
55323 }
55324 if (res == NULL && !PyErr_Occurred()) {
55325 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55326 }
55327 return res;
55328 }
55329
55330 SWIGINTERN int
55331 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
55332 int res = 1;
55333 swig_globalvar *var = v->vars;
55334 while (var) {
55335 if (strcmp(var->name,n) == 0) {
55336 res = (*var->set_attr)(p);
55337 break;
55338 }
55339 var = var->next;
55340 }
55341 if (res == 1 && !PyErr_Occurred()) {
55342 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55343 }
55344 return res;
55345 }
55346
55347 SWIGINTERN PyTypeObject*
55348 swig_varlink_type(void) {
55349 static char varlink__doc__[] = "Swig var link object";
55350 static PyTypeObject varlink_type;
55351 static int type_init = 0;
55352 if (!type_init) {
55353 const PyTypeObject tmp
55354 = {
55355 PyObject_HEAD_INIT(NULL)
55356 0, /* Number of items in variable part (ob_size) */
55357 (char *)"swigvarlink", /* Type name (tp_name) */
55358 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
55359 0, /* Itemsize (tp_itemsize) */
55360 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
55361 (printfunc) swig_varlink_print, /* Print (tp_print) */
55362 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
55363 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
55364 0, /* tp_compare */
55365 (reprfunc) swig_varlink_repr, /* tp_repr */
55366 0, /* tp_as_number */
55367 0, /* tp_as_sequence */
55368 0, /* tp_as_mapping */
55369 0, /* tp_hash */
55370 0, /* tp_call */
55371 (reprfunc)swig_varlink_str, /* tp_str */
55372 0, /* tp_getattro */
55373 0, /* tp_setattro */
55374 0, /* tp_as_buffer */
55375 0, /* tp_flags */
55376 varlink__doc__, /* tp_doc */
55377 0, /* tp_traverse */
55378 0, /* tp_clear */
55379 0, /* tp_richcompare */
55380 0, /* tp_weaklistoffset */
55381 #if PY_VERSION_HEX >= 0x02020000
55382 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
55383 #endif
55384 #if PY_VERSION_HEX >= 0x02030000
55385 0, /* tp_del */
55386 #endif
55387 #ifdef COUNT_ALLOCS
55388 0,0,0,0 /* tp_alloc -> tp_next */
55389 #endif
55390 };
55391 varlink_type = tmp;
55392 varlink_type.ob_type = &PyType_Type;
55393 type_init = 1;
55394 }
55395 return &varlink_type;
55396 }
55397
55398 /* Create a variable linking object for use later */
55399 SWIGINTERN PyObject *
55400 SWIG_Python_newvarlink(void) {
55401 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
55402 if (result) {
55403 result->vars = 0;
55404 }
55405 return ((PyObject*) result);
55406 }
55407
55408 SWIGINTERN void
55409 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
55410 swig_varlinkobject *v = (swig_varlinkobject *) p;
55411 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
55412 if (gv) {
55413 size_t size = strlen(name)+1;
55414 gv->name = (char *)malloc(size);
55415 if (gv->name) {
55416 strncpy(gv->name,name,size);
55417 gv->get_attr = get_attr;
55418 gv->set_attr = set_attr;
55419 gv->next = v->vars;
55420 }
55421 }
55422 v->vars = gv;
55423 }
55424
55425 SWIGINTERN PyObject *
55426 SWIG_globals() {
55427 static PyObject *_SWIG_globals = 0;
55428 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
55429 return _SWIG_globals;
55430 }
55431
55432 /* -----------------------------------------------------------------------------
55433 * constants/methods manipulation
55434 * ----------------------------------------------------------------------------- */
55435
55436 /* Install Constants */
55437 SWIGINTERN void
55438 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
55439 PyObject *obj = 0;
55440 size_t i;
55441 for (i = 0; constants[i].type; ++i) {
55442 switch(constants[i].type) {
55443 case SWIG_PY_POINTER:
55444 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
55445 break;
55446 case SWIG_PY_BINARY:
55447 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
55448 break;
55449 default:
55450 obj = 0;
55451 break;
55452 }
55453 if (obj) {
55454 PyDict_SetItemString(d, constants[i].name, obj);
55455 Py_DECREF(obj);
55456 }
55457 }
55458 }
55459
55460 /* -----------------------------------------------------------------------------*/
55461 /* Fix SwigMethods to carry the callback ptrs when needed */
55462 /* -----------------------------------------------------------------------------*/
55463
55464 SWIGINTERN void
55465 SWIG_Python_FixMethods(PyMethodDef *methods,
55466 swig_const_info *const_table,
55467 swig_type_info **types,
55468 swig_type_info **types_initial) {
55469 size_t i;
55470 for (i = 0; methods[i].ml_name; ++i) {
55471 char *c = methods[i].ml_doc;
55472 if (c && (c = strstr(c, "swig_ptr: "))) {
55473 int j;
55474 swig_const_info *ci = 0;
55475 char *name = c + 10;
55476 for (j = 0; const_table[j].type; ++j) {
55477 if (strncmp(const_table[j].name, name,
55478 strlen(const_table[j].name)) == 0) {
55479 ci = &(const_table[j]);
55480 break;
55481 }
55482 }
55483 if (ci) {
55484 size_t shift = (ci->ptype) - types;
55485 swig_type_info *ty = types_initial[shift];
55486 size_t ldoc = (c - methods[i].ml_doc);
55487 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
55488 char *ndoc = (char*)malloc(ldoc + lptr + 10);
55489 if (ndoc) {
55490 char *buff = ndoc;
55491 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
55492 if (ptr) {
55493 strncpy(buff, methods[i].ml_doc, ldoc);
55494 buff += ldoc;
55495 strncpy(buff, "swig_ptr: ", 10);
55496 buff += 10;
55497 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
55498 methods[i].ml_doc = ndoc;
55499 }
55500 }
55501 }
55502 }
55503 }
55504 }
55505
55506 #ifdef __cplusplus
55507 }
55508 #endif
55509
55510 /* -----------------------------------------------------------------------------*
55511 * Partial Init method
55512 * -----------------------------------------------------------------------------*/
55513
55514 #ifdef __cplusplus
55515 extern "C"
55516 #endif
55517 SWIGEXPORT void SWIG_init(void) {
55518 PyObject *m, *d;
55519
55520 /* Fix SwigMethods to carry the callback ptrs when needed */
55521 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
55522
55523 m = Py_InitModule((char *) SWIG_name, SwigMethods);
55524 d = PyModule_GetDict(m);
55525
55526 SWIG_InitializeModule(0);
55527 SWIG_InstallConstants(d,swig_const_table);
55528
55529
55530
55531 #ifndef wxPyUSE_EXPORT
55532 // Make our API structure a CObject so other modules can import it
55533 // from this module.
55534 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
55535 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
55536 Py_XDECREF(cobj);
55537 #endif
55538
55539 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
55540 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
55541 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
55542 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
55543 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
55544 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
55545 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
55546 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
55547 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
55548 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
55549 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
55550 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
55551 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
55552 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
55553 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
55554 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
55555 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
55556 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
55557 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
55558 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
55559 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
55560 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
55561 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
55562 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
55563 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
55564 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
55565 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
55566 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
55567 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
55568 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
55569 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
55570 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
55571 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
55572 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
55573 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
55574 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
55575 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
55576 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
55577 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
55578 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
55579 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
55580 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
55581 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
55582 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
55583 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
55584 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
55585 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
55586 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
55587 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
55588 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
55589 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
55590 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
55591 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
55592 SWIG_Python_SetConstant(d, "ST_DOTS_MIDDLE",SWIG_From_int(static_cast< int >(wxST_DOTS_MIDDLE)));
55593 SWIG_Python_SetConstant(d, "ST_DOTS_END",SWIG_From_int(static_cast< int >(wxST_DOTS_END)));
55594 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
55595 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
55596 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
55597 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
55598 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
55599 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
55600 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
55601 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
55602 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
55603 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
55604 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
55605 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
55606 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
55607 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
55608 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
55609 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
55610 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
55611 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
55612 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
55613 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
55614 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
55615 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
55616 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
55617 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
55618 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
55619 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
55620 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
55621 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
55622 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
55623 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
55624 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
55625 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
55626 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
55627 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
55628 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
55629 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
55630 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
55631 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
55632 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
55633 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
55634 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
55635 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
55636 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
55637 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
55638 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
55639 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
55640 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
55641 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
55642 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
55643 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
55644 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
55645 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
55646 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
55647 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
55648 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
55649 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
55650 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
55651 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
55652 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
55653 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
55654 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
55655 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
55656 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
55657 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
55658 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
55659 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
55660 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
55661 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
55662 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
55663 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
55664 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
55665 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
55666 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
55667 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
55668 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
55669 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
55670 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
55671 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
55672 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
55673 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
55674 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
55675 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
55676 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
55677 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
55678 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
55679 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
55680 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
55681 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
55682 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
55683 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
55684 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
55685 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
55686 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
55687 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
55688 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
55689 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
55690 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
55691 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
55692 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
55693 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
55694 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
55695 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
55696 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
55697 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
55698 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
55699 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
55700 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
55701 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
55702 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
55703 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
55704 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
55705 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
55706 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
55707 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
55708 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
55709 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
55710 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
55711 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
55712 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
55713 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
55714 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
55715 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
55716 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
55717 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
55718 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
55719 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
55720 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
55721 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
55722 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
55723 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
55724 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
55725 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
55726 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
55727 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
55728 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
55729 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
55730 SWIG_Python_SetConstant(d, "OPEN",SWIG_From_int(static_cast< int >(wxOPEN)));
55731 SWIG_Python_SetConstant(d, "SAVE",SWIG_From_int(static_cast< int >(wxSAVE)));
55732 SWIG_Python_SetConstant(d, "HIDE_READONLY",SWIG_From_int(static_cast< int >(wxHIDE_READONLY)));
55733 SWIG_Python_SetConstant(d, "OVERWRITE_PROMPT",SWIG_From_int(static_cast< int >(wxOVERWRITE_PROMPT)));
55734 SWIG_Python_SetConstant(d, "FILE_MUST_EXIST",SWIG_From_int(static_cast< int >(wxFILE_MUST_EXIST)));
55735 SWIG_Python_SetConstant(d, "MULTIPLE",SWIG_From_int(static_cast< int >(wxMULTIPLE)));
55736 SWIG_Python_SetConstant(d, "CHANGE_DIR",SWIG_From_int(static_cast< int >(wxCHANGE_DIR)));
55737 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
55738 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
55739 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
55740 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
55741 SWIG_Python_SetConstant(d, "PD_AUTO_HIDE",SWIG_From_int(static_cast< int >(wxPD_AUTO_HIDE)));
55742 SWIG_Python_SetConstant(d, "PD_APP_MODAL",SWIG_From_int(static_cast< int >(wxPD_APP_MODAL)));
55743 SWIG_Python_SetConstant(d, "PD_CAN_ABORT",SWIG_From_int(static_cast< int >(wxPD_CAN_ABORT)));
55744 SWIG_Python_SetConstant(d, "PD_ELAPSED_TIME",SWIG_From_int(static_cast< int >(wxPD_ELAPSED_TIME)));
55745 SWIG_Python_SetConstant(d, "PD_ESTIMATED_TIME",SWIG_From_int(static_cast< int >(wxPD_ESTIMATED_TIME)));
55746 SWIG_Python_SetConstant(d, "PD_REMAINING_TIME",SWIG_From_int(static_cast< int >(wxPD_REMAINING_TIME)));
55747 SWIG_Python_SetConstant(d, "PD_SMOOTH",SWIG_From_int(static_cast< int >(wxPD_SMOOTH)));
55748 SWIG_Python_SetConstant(d, "PD_CAN_SKIP",SWIG_From_int(static_cast< int >(wxPD_CAN_SKIP)));
55749 SWIG_Python_SetConstant(d, "DD_NEW_DIR_BUTTON",SWIG_From_int(static_cast< int >(wxDD_NEW_DIR_BUTTON)));
55750 SWIG_Python_SetConstant(d, "DD_DEFAULT_STYLE",SWIG_From_int(static_cast< int >(wxDD_DEFAULT_STYLE)));
55751 SWIG_Python_SetConstant(d, "DD_CHANGE_DIR",SWIG_From_int(static_cast< int >(wxDD_CHANGE_DIR)));
55752 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
55753 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
55754 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
55755 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
55756 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
55757 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
55758 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
55759 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
55760 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
55761 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
55762 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
55763 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
55764 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
55765 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
55766 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
55767 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
55768 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
55769 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
55770 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
55771 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
55772 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
55773 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
55774 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
55775 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
55776 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
55777 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
55778 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
55779 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
55780 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
55781 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
55782 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
55783 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
55784 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
55785 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
55786 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
55787 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
55788 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
55789 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
55790 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
55791 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
55792 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
55793 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
55794 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
55795 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
55796 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
55797 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
55798 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
55799 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
55800 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
55801 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
55802 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
55803 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
55804 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
55805 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
55806 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
55807 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
55808 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
55809 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
55810 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
55811 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
55812 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
55813 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
55814 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
55815 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
55816 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
55817 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
55818 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
55819 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
55820 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
55821 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
55822 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
55823 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
55824 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
55825 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
55826 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
55827 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
55828 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
55829 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
55830 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
55831 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
55832 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
55833 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
55834 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
55835 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
55836 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
55837 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
55838 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
55839 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
55840 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
55841 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
55842 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
55843 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
55844 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
55845 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
55846 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
55847 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
55848 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
55849 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
55850 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
55851 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
55852 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
55853 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
55854 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
55855 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
55856 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
55857 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
55858 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
55859 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
55860 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
55861 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
55862 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
55863 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
55864 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
55865 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
55866 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
55867 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
55868 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
55869 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
55870 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
55871 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
55872 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
55873 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
55874 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
55875 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
55876 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
55877 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
55878 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
55879 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
55880 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
55881 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
55882 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
55883 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
55884 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
55885 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
55886 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
55887 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
55888 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
55889 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
55890 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
55891 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
55892 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
55893 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
55894 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
55895 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
55896 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
55897 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
55898 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
55899 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
55900 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
55901 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
55902 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
55903 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
55904 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
55905 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
55906 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
55907 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
55908 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
55909 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
55910 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
55911 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
55912 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
55913 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
55914 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
55915 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
55916 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
55917 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
55918 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
55919 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
55920 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
55921 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
55922 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
55923 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
55924 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
55925 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
55926 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
55927 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
55928 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
55929 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
55930 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
55931 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
55932 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
55933 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
55934 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
55935 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
55936 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
55937 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
55938 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
55939 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
55940 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
55941 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
55942 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
55943 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
55944 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
55945 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
55946 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
55947 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
55948 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
55949 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
55950 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
55951 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
55952 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
55953 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
55954 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
55955 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
55956 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
55957 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
55958 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
55959 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
55960 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
55961 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
55962 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
55963 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
55964 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
55965 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
55966 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
55967 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
55968 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
55969 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
55970 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
55971 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
55972 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
55973 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
55974 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
55975 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
55976 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
55977 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
55978 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
55979 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
55980 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
55981 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
55982 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
55983 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
55984 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
55985 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
55986 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
55987 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
55988 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
55989 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
55990 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
55991 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
55992 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
55993 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
55994 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
55995 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
55996 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
55997 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
55998 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
55999 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
56000 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
56001 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
56002 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
56003 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
56004 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
56005 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
56006 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
56007 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
56008 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
56009 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
56010 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
56011 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
56012 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
56013 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
56014 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
56015 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
56016 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
56017 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
56018 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
56019 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
56020 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
56021 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
56022 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
56023 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
56024 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
56025 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
56026 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
56027 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
56028 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
56029 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
56030 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
56031 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
56032 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
56033 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
56034 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
56035 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
56036 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
56037 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
56038 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
56039 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
56040 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
56041 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
56042 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
56043 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
56044 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
56045 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
56046 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
56047 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
56048 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
56049 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
56050 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
56051 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
56052 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
56053 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
56054 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
56055 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
56056 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
56057 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
56058 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
56059 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
56060 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
56061 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
56062 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
56063 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
56064 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
56065 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
56066 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
56067 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
56068 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
56069 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
56070 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
56071 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
56072 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
56073 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
56074 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
56075 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
56076 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
56077 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
56078 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
56079 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
56080 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
56081 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
56082 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
56083 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
56084 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
56085 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
56086 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
56087 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
56088 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
56089 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
56090 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
56091 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
56092 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
56093 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
56094 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
56095 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
56096 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
56097 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
56098 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
56099 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
56100 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
56101 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
56102 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
56103 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
56104 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
56105 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
56106 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
56107 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
56108 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
56109 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
56110 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
56111 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
56112 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
56113 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
56114 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
56115 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
56116 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
56117 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
56118 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
56119 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
56120 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
56121 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
56122 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
56123 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
56124 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
56125 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
56126 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
56127 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
56128 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
56129 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
56130 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
56131 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
56132 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
56133 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
56134 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
56135 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
56136 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
56137 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
56138 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
56139 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
56140 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
56141 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
56142 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
56143 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
56144 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
56145 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
56146 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
56147 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
56148 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
56149 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
56150 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
56151 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
56152 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
56153 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
56154 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
56155 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
56156 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
56157 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
56158 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
56159 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
56160 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
56161 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
56162 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
56163 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
56164 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
56165 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
56166 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
56167 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
56168 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
56169 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
56170 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
56171 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
56172 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
56173 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
56174 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
56175 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
56176 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
56177 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
56178 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
56179 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
56180 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
56181 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
56182 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
56183 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
56184 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
56185 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
56186 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
56187 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
56188 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
56189 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
56190 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
56191 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
56192 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
56193 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
56194 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
56195 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
56196 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
56197 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
56198 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
56199 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
56200 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
56201 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
56202 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
56203 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
56204 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
56205 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
56206 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
56207 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
56208 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
56209 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
56210 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
56211
56212 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
56213
56214
56215 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
56216
56217 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
56218 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
56219 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
56220 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
56221 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
56222 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
56223 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
56224 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
56225 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
56226 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
56227 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
56228 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
56229 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
56230 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
56231 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
56232 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
56233 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
56234 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
56235 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
56236 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
56237 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
56238 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
56239 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
56240 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
56241 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
56242 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
56243 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
56244 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
56245 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
56246 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
56247 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
56248 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
56249 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
56250 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
56251 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
56252 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
56253 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
56254 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
56255 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
56256 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
56257 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
56258 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
56259 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
56260 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
56261 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
56262 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
56263 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
56264 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
56265 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
56266 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
56267 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
56268 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
56269 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
56270 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
56271 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
56272 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
56273 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
56274 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
56275 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
56276 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
56277 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
56278 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
56279 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
56280 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
56281 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
56282 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
56283 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
56284 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
56285 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
56286 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
56287 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
56288 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
56289 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
56290 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
56291 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
56292 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
56293 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
56294 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
56295 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
56296 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
56297 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
56298 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
56299 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
56300 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
56301 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
56302 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
56303 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
56304 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
56305 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
56306 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
56307 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
56308 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
56309 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
56310 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
56311 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
56312 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
56313 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
56314 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
56315 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
56316 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
56317 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
56318 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
56319 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
56320 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
56321 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
56322 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
56323 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
56324 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
56325 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
56326 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
56327 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
56328 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
56329 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
56330 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
56331 PyDict_SetItemString(d, "wxEVT_POWER", PyInt_FromLong(wxEVT_POWER));
56332 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
56333 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
56334 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
56335 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
56336 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
56337 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
56338 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
56339 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
56340 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
56341 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
56342 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
56343 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
56344 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
56345 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
56346 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
56347 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
56348 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
56349 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
56350 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
56351 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
56352 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
56353 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
56354 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
56355 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
56356 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
56357 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
56358 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
56359 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
56360 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
56361 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
56362 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
56363 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
56364 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
56365 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
56366 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
56367 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
56368 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
56369 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
56370 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
56371 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
56372 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
56373 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
56374 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
56375 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
56376 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
56377 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
56378 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
56379 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
56380 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
56381 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
56382 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
56383 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
56384 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
56385 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
56386 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
56387 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
56388 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
56389 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
56390 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
56391 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
56392 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
56393 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
56394 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
56395 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
56396 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
56397 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
56398 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
56399 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
56400 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
56401 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
56402 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
56403 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
56404 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
56405 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
56406 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
56407 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
56408 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
56409 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
56410 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
56411 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
56412 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
56413 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
56414 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
56415 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
56416 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
56417 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
56418 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
56419 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
56420 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
56421 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
56422 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
56423 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
56424
56425 // Initialize threading, some globals and such
56426 __wxPyPreStart(d);
56427
56428
56429 // Although these are defined in __version__ they need to be here too so
56430 // that an assert can be done to ensure that the wxPython and the wxWindows
56431 // versions match.
56432 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
56433 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
56434 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
56435
56436 }
56437
wxWidgets (Impactor)